Release v1.0.2

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

Conflicts:
	Makefile

.gitignore

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

.travis.yml

@@ -1,15 +1,11 @@
 language: erlang
-
-otp_release:
-  - 18.0
-
-sudo: false
-
 script: "make compile && rm -rf .git && make test"
-
 notifications:
   irc: "irc.freenode.org#elixir-lang"
   recipients:
     - jose.valim@plataformatec.com.br
     - eric.meadows.jonsson@gmail.com
-
+otp_release:
+  - 17.0
+  - 17.1
+  - 17.3

CODE_OF_CONDUCT.md

@@ -1,56 +0,0 @@
-# Code of Conduct
-
-Contact: elixir-lang-conduct@googlegroups.com
-
-## Why have a Code of Conduct?
-
-As contributors and maintainers of this project, we are committed to providing a friendly, safe and welcoming environment for all, regardless of age, disability, gender, nationality, race, religion, sexuality, or similar personal characteristic.
-
-The goal of the Code of Conduct is to specify a baseline standard of behavior so that people with different social values and communication styles can talk about Elixir effectively, productively, and respectfully, even in face of disagreements. The Code of Conduct also provides a mechanism for resolving conflicts in the community when they arise.
-
-## Our Values
-
-These are the values Elixir developers should aspire to:
-
-  * Be friendly and welcoming
-  * Be patient
-    * Remember that people have varying communication styles and that not everyone is using their native language. (Meaning and tone can be lost in translation.)
-  * Be thoughtful
-    * Productive communication requires effort. Think about how your words will be interpreted.
-    * Remember that sometimes it is best to refrain entirely from commenting.
-  * Be respectful
-    * In particular, respect differences of opinion. It is important that we resolve disagreements and differing views constructively.
-  * Avoid destructive behavior
-    * Derailing: stay on topic; if you want to talk about something else, start a new conversation.
-    * Unconstructive criticism: don't merely decry the current state of affairs; offer (or at least solicit) suggestions as to how things may be improved.
-    * Snarking (pithy, unproductive, sniping comments).
-
-The following actions are explicitly forbidden:
-
-  * Insulting, demeaning, hateful, or threatening remarks.
-  * Discrimination based on age, disability, gender, nationality, race, religion, sexuality, or similar personal characteristic.
-  * Bullying or systematic harassment.
-  * Unwelcome sexual advances.
-  * Incitement to any of these.
-
-## Where does the Code of Conduct apply?
-
-If you participate in or contribute to the Elixir ecosystem in any way, you are encouraged to follow the Code of Conduct while doing so.
-
-Explicit enforcement of the Code of Conduct applies to the official mediums operated by the Elixir project:
-
-* The official GitHub projects and code reviews.
-* The official elixir-lang mailing lists.
-* The #elixir-lang IRC channel on Freenode.
-
-Other Elixir activities (such as conferences, meetups, and other unofficial forums) are encouraged to adopt this Code of Conduct. Such groups must provide their own contact information.
-
-Project maintainers may remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by emailing: elixir-lang-conduct@googlegroups.com. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. **All reports will be kept confidential**.
-
-**The goal of the Code of Conduct is to resolve conflicts in the most harmonious way possible**. We hope that in most cases issues may be resolved through polite discussion and mutual agreement. Bannings and other forceful measures are to be employed only as a last resort. **Do not** post about the issue publicly or try to rally sentiment against a particular individual or group.
-
-## Acknowledgements
-
-This document was based on the Code of Conduct from the Go project with parts derived from Django's Code of Conduct, Rust's Code of Conduct and the Contributor Covenant.

CONTRIBUTING.md

@@ -0,0 +1,265 @@
+# 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
+
+Use the issues tracker for:
+
+* [bug reports](#bugs-reports)
+* [submitting pull requests](#pull-requests)
+
+Please **do not** use the issue tracker for personal support requests nor feature requests. Support requests should be sent to:
+
+* [the elixir-talk mailing list](http://groups.google.com/group/elixir-lang-talk)
+* [Stack Overflow](http://stackoverflow.com/questions/ask?tags=elixir)
+* [#elixir-lang](irc://chat.freenode.net/elixir-lang)
+
+Feature requests can be discussed on [the elixir-core mailing list](http://groups.google.com/group/elixir-lang-core).
+
+We do our best to keep the issue tracker tidy and organized, making it useful
+for everyone. For example, we classify open issues per application and perceived
+difficulty of the issue, making it easier for developers to
+[contribute to Elixir](#contributing).
+
+## Bug reports
+
+A bug is a _demonstrable problem_ that is caused by the code in the repository.
+Good bug reports are extremely helpful - thank you!
+
+Guidelines for bug reports:
+
+1. **Use the GitHub issue search** — check if the issue has already been
+   reported.
+
+2. **Check if the issue has been fixed** — try to reproduce it using the
+   `master` branch in the repository.
+
+3. **Isolate and report the problem** — ideally create a reduced test
+   case.
+
+Please try to be as detailed as possible in your report. Include information about
+your Operating System, your Erlang and Elixir versions. Please provide steps to
+reproduce the issue as well as the outcome you were expecting! All these details
+will help developers to fix any potential bugs.
+
+Example:
+
+> Short and descriptive example bug report title
+>
+> A summary of the issue and the environment in which it occurs. If suitable,
+> include the steps required to reproduce the bug.
+>
+> 1. This is the first step
+> 2. This is the second step
+> 3. Further steps, etc.
+>
+> `<url>` - a link to the reduced test case (e.g. a GitHub Gist)
+>
+> Any other information you want to share that is relevant to the issue being
+> reported. This might include the lines of code that you have identified as
+> causing the bug, and potential solutions (and your opinions on their
+> merits).
+
+## Feature requests
+
+Feature requests are welcome and should be discussed on [the elixir-core mailing list](http://groups.google.com/group/elixir-lang-core). But take a moment to find
+out whether your idea fits with the scope and aims of the project. It's up to *you*
+to make a strong case to convince the community of the merits of this feature.
+Please provide as much detail and context as possible.
+
+## Contributing
+
+We incentivize everyone to contribute to Elixir and help us tackle
+existing issues! To do so, there are a few things you need to know
+about the code. First, Elixir code is divided in applications inside
+the `lib` folder:
+
+* `elixir` - Contains Elixir's kernel and stdlib
+
+* `eex` - Template engine that allows you to embed Elixir
+
+* `ex_unit` - Simple test framework that ships with Elixir
+
+* `iex` — IEx, Elixir's interactive shell
+
+* `mix` — Elixir's build tool
+
+You can run all tests in the root directory with `make test` and you can
+also run tests for a specific framework `make test_#{NAME}`, for example,
+`make test_ex_unit`.
+
+In case you are changing a single file, you can compile and run tests only
+for that particular file for fast development cycles. For example, if you
+are changing the String module, you can compile it and run its tests as:
+
+    $ bin/elixirc lib/elixir/lib/string.ex -o lib/elixir/ebin
+    $ bin/elixir lib/elixir/test/elixir/string_test.exs
+
+After your changes are done, please remember to run the full suite with
+`make test`.
+
+From time to time, your tests may fail in an existing Elixir checkout and
+may require a clean start by running `make clean compile`. You can always
+check [the official build status on Travis-CI](https://travis-ci.org/elixir-lang/elixir).
+
+With tests running and passing, you are ready to contribute to Elixir and
+send your pull requests.
+
+## Contributing Documentation
+
+Code documentation (`@doc`, `@moduledoc`, `@typedoc`) has a special convention:
+the first paragraph is considered to be a short summary.
+
+For functions, macros and callbacks say what it will do. For example write
+something like:
+
+```elixir
+@doc """
+Returns only those elements for which `fun` is true.
+
+...
+"""
+def filter(collection, fun) ...
+```
+
+For modules, protocols and types say what it is. For example write
+something like:
+
+```elixir
+defmodule File.Stat do
+  @moduledoc """
+  Information about a file.
+
+  ...
+  """
+
+  defstruct [...]
+end
+```
+
+Keep in mind that the first paragraph might show up in a summary somewhere, long
+texts in the first paragraph create very ugly summaries. As a rule of thumb
+anything longer than 80 characters is too long.
+
+Try to keep unneccesary details out of the first paragraph, it's only there to
+give a user a quick idea of what the documented "thing" does/is. The rest of the
+documentation string can contain the details, for example when a value and when
+`nil` is returned.
+
+If possible include examples, preferably in a form that works with doctests. For
+example:
+
+```elixir
+@doc """
+Return only those elements for which `fun` is true.
+
+## Examples
+
+    iex> Enum.filter([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
+    [2]
+
+"""
+def filter(collection, fun) ...
+```
+
+This makes it easy to test the examples so that they don't go stale and examples
+are often a great help in explaining what a function does.
+
+## Pull requests
+
+Good pull requests - patches, improvements, new features - are a fantastic
+help. They should remain focused in scope and avoid containing unrelated
+commits.
+
+**IMPORTANT**: By submitting a patch, you agree that your work will be
+licensed under the license used by the project.
+
+If you have any large pull request in mind (e.g. implementing features,
+refactoring code, etc), **please ask first** otherwise you risk spending
+a lot of time working on something that the project's developers might
+not want to merge into the project.
+
+Please adhere to the coding conventions in the project (indentation,
+accurate comments, etc.) and don't forget to add your own tests and
+documentation. When working with git, we recommend the following process
+in order to craft an excellent pull request:
+
+1. [Fork](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. Make sure all the tests are still passing.
+
+   ```bash
+   make test
+   ```
+
+   This command will compile the code in your branch and use that
+   version of Elixir to run the tests. This is needed to ensure your changes can
+   pass all the tests.
+
+6. Push your topic branch up to your fork:
+
+   ```bash
+   git push origin <topic-branch-name>
+   ```
+
+7. [Open a Pull Request](https://help.github.com/articles/using-pull-requests/)
+    with a clear title and description.
+
+8. If you haven't updated your pull request for a while, you should consider
+   rebasing on master and resolving any conflicts.
+
+   **IMPORTANT**: _Never ever_ merge upstream `master` into your branches. You
+   should always `git rebase` on `master` to bring your changes up to date when
+   necessary.
+
+   ```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/1058
+* https://github.com/elixir-lang/elixir/pull/1059
+
+Thank you for your contributions!

ISSUE_TEMPLATE.md

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

LEGAL

@@ -0,0 +1,8 @@
+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_parser.erl (generated by build scripts)

LICENSE

@@ -1,4 +1,4 @@
-Copyright 2012 Plataformatec
+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.

Makefile

@@ -1,30 +1,29 @@
-REBAR ?= "$(CURDIR)/rebar"
-PREFIX ?= /usr/local
-DOCS := v1.3
-CANONICAL := stable
+REBAR := rebar
+DOCS := v1.0
 ELIXIRC := bin/elixirc --verbose --ignore-module-conflict
 ERLC := erlc -I lib/elixir/include
 ERL := erl -I lib/elixir/include -noshell -pa lib/elixir/ebin
 VERSION := $(strip $(shell cat VERSION))
 Q := @
+PREFIX := /usr/local
 LIBDIR := lib
 INSTALL = install
 INSTALL_DIR = $(INSTALL) -m755 -d
 INSTALL_DATA = $(INSTALL) -m644
 INSTALL_PROGRAM = $(INSTALL) -m755
-GIT_REVISION = $(strip $(shell git rev-parse HEAD 2> /dev/null ))
-GIT_TAG = $(strip $(shell head="$(call GIT_REVISION)"; git tag --points-at $$head 2> /dev/null | tail -1) )
 
-.PHONY: install compile erlang elixir build_plt clean_plt dialyze test clean install_man clean_man docs Docs.zip Precompiled.zip publish_zips publish_docs publish_mix
+.PHONY: install compile erlang elixir build_plt clean_plt dialyze test clean docs release_docs release_zip check_erlang_release
 .NOTPARALLEL: compile
 
 #==> Functions
 
+# This check should work for older versions like R16B
+# as well as new verions like 17.1 and 18
 define CHECK_ERLANG_RELEASE
-	$(Q) erl -noshell -eval 'io:fwrite("~s", [erlang:system_info(otp_release) >= "18"])' -s erlang halt | grep -q '^true'; \
-		if [ $$? != 0 ]; then \
-		   echo "At least Erlang 18.0 is required to build Elixir"; \
-		   exit 1; \
+	$(Q) erl -noshell -eval 'io:fwrite("~s", [erlang:system_info(otp_release)])' -s erlang halt | grep -q '^1[789]'; \
+		if [ $$? != 0 ]; then                                                                                        \
+		   echo "At least Erlang 17.0 is required to build Elixir";                                                  \
+		   exit 1;                                                                                                   \
 		fi;
 endef
 
@@ -43,7 +42,7 @@ lib/$(1)/ebin/Elixir.$(2).beam: $(wildcard lib/$(1)/lib/*.ex) $(wildcard lib/$(1
 	@ rm -rf lib/$(1)/ebin
 	$(Q) cd lib/$(1) && ../../$$(ELIXIRC) "lib/**/*.ex" -o ebin
 
-test_$(1): compile $(1)
+test_$(1): $(1)
 	@ echo "==> $(1) (exunit)"
 	$(Q) cd lib/$(1) && ../../bin/elixir -r "test/test_helper.exs" -pr "test/**/*_test.exs";
 endef
@@ -65,7 +64,7 @@ lib/elixir/src/elixir.app.src: src/elixir.app.src
 	$(Q) cat src/elixir.app.src >>lib/elixir/src/elixir.app.src
 
 erlang:
-	$(Q) cd lib/elixir && $(REBAR) compile
+	$(Q) cd lib/elixir && ../../$(REBAR) compile
 
 # Since Mix depends on EEx and EEx depends on
 # Mix, we first compile EEx without the .app
@@ -74,7 +73,7 @@ elixir: stdlib lib/eex/ebin/Elixir.EEx.beam mix ex_unit logger eex iex
 
 stdlib: $(KERNEL) VERSION
 $(KERNEL): lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex lib/elixir/lib/*/*/*.ex
-	$(Q) if [ ! -f $(KERNEL) ]; then                  \
+	$(Q) if [ ! -f $(KERNEL) ]; then                    \
 		echo "==> bootstrap (compile)";                 \
 		$(ERL) -s elixir_compiler core -s erlang halt;  \
 	fi
@@ -83,11 +82,12 @@ $(KERNEL): lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex lib/elixir/lib/*/*/*.ex
 	$(Q) cd lib/elixir && ../../$(ELIXIRC) "lib/**/*.ex" -o ebin;
 	$(Q) $(MAKE) unicode
 	$(Q) rm -rf lib/elixir/ebin/elixir.app
-	$(Q) cd lib/elixir && $(REBAR) compile
+	$(Q) cd lib/elixir && ../../$(REBAR) compile
 
 unicode: $(UNICODE)
 $(UNICODE): lib/elixir/unicode/*
 	@ echo "==> unicode (compile)";
+	@ echo "Embedding the Unicode database... (this may take a while)"
 	$(Q) cd lib/elixir && ../../$(ELIXIRC) unicode/unicode.ex -o ebin;
 
 $(eval $(call APP_TEMPLATE,ex_unit,ExUnit))
@@ -99,7 +99,6 @@ $(eval $(call APP_TEMPLATE,iex,IEx))
 install: compile
 	@ echo "==> elixir (install)"
 	$(Q) for dir in lib/*; do \
-		rm -Rf $(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin; \
 		$(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin"; \
 		$(INSTALL_DATA) $$dir/ebin/* "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin"; \
 	done
@@ -109,10 +108,9 @@ install: compile
 	$(Q) for file in "$(DESTDIR)$(PREFIX)"/$(LIBDIR)/elixir/bin/* ; do \
 		ln -sf "../$(LIBDIR)/elixir/bin/$${file##*/}" "$(DESTDIR)$(PREFIX)/bin/" ; \
 	done
-	$(MAKE) install_man
 
 clean:
-	cd lib/elixir && $(REBAR) clean
+	cd lib/elixir && ../../$(REBAR) clean
 	rm -rf ebin
 	rm -rf lib/*/ebin
 	rm -rf lib/elixir/test/ebin
@@ -121,72 +119,46 @@ clean:
 	rm -rf lib/mix/test/fixtures/deps_on_git_repo
 	rm -rf lib/mix/test/fixtures/git_rebar
 	rm -rf lib/elixir/src/elixir.app.src
-	$(MAKE) clean_man
 
 clean_exbeam:
 	$(Q) rm -f lib/*/ebin/Elixir.*.beam
 
-#==> Create Documentation
+#==> Release tasks
 
-LOGO_PATH = $(shell test -f ../docs/logo.png && echo "--logo ../docs/logo.png")
-SOURCE_REF = $(shell tag="$(call GIT_TAG)" revision="$(call GIT_REVISION)"; echo "$${tag:-$$revision}\c")
-COMPILE_DOCS = bin/elixir ../ex_doc/bin/ex_doc "$(1)" "$(VERSION)" "lib/$(2)/ebin" -m "$(3)" -u "https://github.com/elixir-lang/elixir" --source-ref "$(call SOURCE_REF)" $(call LOGO_PATH) -o doc/$(2) -a http://elixir-lang.org/docs/$(CANONICAL)/$(2)/ -p http://elixir-lang.org/docs.html $(4)
+SOURCE_REF = $(shell head="$$(git rev-parse HEAD)" tag="$$(git tag --points-at $$head | tail -1)" ; echo "$${tag:-$$head}\c")
+DOCS = bin/elixir ../ex_doc/bin/ex_doc "$(1)" "$(VERSION)" "lib/$(2)/ebin" -m "$(3)" -u "https://github.com/elixir-lang/elixir" --source-ref "$(call SOURCE_REF)" -o docs/$(2) -p http://elixir-lang.org/docs.html
 
-docs: compile ../ex_doc/bin/ex_doc docs_elixir docs_eex docs_mix docs_iex docs_ex_unit docs_logger
-
-docs_elixir: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (elixir)"
-	$(Q) rm -rf doc/elixir
-	$(call COMPILE_DOCS,Elixir,elixir,Kernel,-e "lib/elixir/pages/Behaviours.md" -e "lib/elixir/pages/Naming Conventions.md" -e "lib/elixir/pages/Typespecs.md" -e "lib/elixir/pages/Writing Documentation.md")
-
-docs_eex: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (eex)"
-	$(Q) rm -rf doc/eex
-	$(call COMPILE_DOCS,EEx,eex,EEx)
-
-docs_mix: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (mix)"
-	$(Q) rm -rf doc/mix
-	$(call COMPILE_DOCS,Mix,mix,Mix)
-
-docs_iex: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (iex)"
-	$(Q) rm -rf doc/iex
-	$(call COMPILE_DOCS,IEx,iex,IEx)
-
-docs_ex_unit: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (ex_unit)"
-	$(Q) rm -rf doc/ex_unit
-	$(call COMPILE_DOCS,ExUnit,ex_unit,ExUnit)
-
-docs_logger: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (logger)"
-	$(Q) rm -rf doc/logger
-	$(call COMPILE_DOCS,Logger,logger,Logger)
+docs: compile ../ex_doc/bin/ex_doc
+	$(Q) rm -rf docs
+	$(call DOCS,Elixir,elixir,Kernel)
+	$(call DOCS,EEx,eex,EEx)
+	$(call DOCS,Mix,mix,Mix)
+	$(call DOCS,IEx,iex,IEx)
+	$(call DOCS,ExUnit,ex_unit,ExUnit)
+	$(call DOCS,Logger,logger,Logger)
 
 ../ex_doc/bin/ex_doc:
 	@ echo "ex_doc is not found in ../ex_doc as expected. See README for more information."
 	@ false
 
-#==> Zips
+release_zip: compile
+	rm -rf v$(VERSION).zip
+	zip -9 -r v$(VERSION).zip bin CHANGELOG.md LEGAL lib/*/ebin LICENSE Makefile README.md VERSION
 
-Docs.zip: docs
-	rm -rf Docs-v$(VERSION).zip
-	zip -9 -r Docs-v$(VERSION).zip CHANGELOG.md doc NOTICE LICENSE README.md
-	@ echo "Docs file created $(CURDIR)/Docs-v$(VERSION).zip"
+release_docs: docs
+	cd ../docs
+	rm -rf ../docs/$(DOCS)
+	mv docs ../docs/$(DOCS)
 
-Precompiled.zip: build_man compile
-	rm -rf Precompiled-v$(VERSION).zip
-	zip -9 -r Precompiled-v$(VERSION).zip bin CHANGELOG.md lib/*/ebin LICENSE man NOTICE README.md VERSION
-	@ echo "Precompiled file created $(CURDIR)/Precompiled-v$(VERSION).zip"
+# This task requires aws-cli to be installed and set up for access to s3.hex.pm
+# See: http://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html
 
-#==> Publish
-
-publish_zips: Precompiled.zip Docs.zip
-
-publish_docs: docs
-	rm -rf ../docs/$(DOCS)/*/
-	cp -R doc/* ../docs/$(DOCS)
+publish_mix: compile
+	cd lib/mix && MIX_ENV=prod mix escript.build
+	aws s3 cp lib/mix/mix s3://s3.hex.pm/builds/mix/v$(VERSION)/mix --acl public-read
+	aws s3 cp lib/mix/mix s3://s3.hex.pm/builds/mix/mix --acl public-read
+	rm lib/mix/mix
+	rm -rf lib/mix/_build
 
 #==> Tests tasks
 
@@ -205,7 +177,11 @@ $(TEST_EBIN)/%.beam: $(TEST_ERL)/%.erl
 	$(Q) mkdir -p $(TEST_EBIN)
 	$(Q) $(ERLC) -o $(TEST_EBIN) $<
 
-test_elixir: test_stdlib test_ex_unit test_logger test_mix test_eex test_iex
+test_elixir: test_stdlib test_ex_unit test_logger test_doc_test test_mix test_eex test_iex
+
+test_doc_test: compile
+	@ echo "==> doctest (exunit)"
+	$(Q) cd lib/elixir && ../../bin/elixir -r "test/doc_test.exs";
 
 test_stdlib: compile
 	@ echo "==> elixir (exunit)"
@@ -233,31 +209,3 @@ build_plt: clean_plt $(PLT)
 dialyze: compile $(PLT)
 	@ echo "==> Dialyzing Elixir..."
 	$(Q) dialyzer --plt $(PLT) $(DIALYZER_OPTS) lib/*/ebin
-
-#==> Man page tasks
-
-build_man: man/iex.1 man/elixir.1
-
-man/iex.1:
-	$(Q) cp man/iex.1.in man/iex.1
-	$(Q) sed -i.bak "/{COMMON}/r common" man/iex.1
-	$(Q) sed -i.bak "/{COMMON}/d" man/iex.1
-	$(Q) rm man/iex.1.bak
-
-man/elixir.1:
-	$(Q) cp man/elixir.1.in man/elixir.1
-	$(Q) sed -i.bak "/{COMMON}/r common" man/elixir.1
-	$(Q) sed -i.bak "/{COMMON}/d" man/elixir.1
-	$(Q) rm man/elixir.1.bak
-
-clean_man:
-	rm -f man/elixir.1
-	rm -f man/iex.1
-
-install_man: build_man
-	$(Q) mkdir -p $(DESTDIR)$(PREFIX)/share/man/man1
-	$(Q) $(INSTALL_DATA) man/elixir.1  $(DESTDIR)$(PREFIX)/share/man/man1
-	$(Q) $(INSTALL_DATA) man/elixirc.1 $(DESTDIR)$(PREFIX)/share/man/man1
-	$(Q) $(INSTALL_DATA) man/iex.1     $(DESTDIR)$(PREFIX)/share/man/man1
-	$(Q) $(INSTALL_DATA) man/mix.1     $(DESTDIR)$(PREFIX)/share/man/man1
-	$(MAKE) clean_man

NOTICE

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

README.md

@@ -1,135 +1,59 @@
 ![Elixir](https://github.com/elixir-lang/elixir-lang.github.com/raw/master/images/logo/logo.png)
 =========
-[![Build Status](https://secure.travis-ci.org/elixir-lang/elixir.svg?branch=master
-"Build Status")](https://travis-ci.org/elixir-lang/elixir)
+[![Build Status](https://secure.travis-ci.org/elixir-lang/elixir.svg?branch=master "Build Status")](http://travis-ci.org/elixir-lang/elixir)
 
-For more about Elixir, installation and documentation,
-[check Elixir's website](http://elixir-lang.org/).
+For more about Elixir, installation and documentation, [check Elixir's website](http://elixir-lang.org/).
 
 ## Usage
 
-To run Elixir from source, clone this repository to your machine, compile and test it:
+If you want to contribute to Elixir or run it from source, clone this repository to your machine, compile and test it:
 
-```sh
-git clone https://github.com/elixir-lang/elixir.git
-cd elixir
-make clean test
-```
+    $ git clone https://github.com/elixir-lang/elixir.git
+    $ cd elixir
+    $ make clean test
 
-> Note: if you are running on Windows,
-[this article includes important notes for compiling Elixir from source
-on Windows](https://github.com/elixir-lang/elixir/wiki/Windows).
+> Note: if you are running on Windows, [this article includes important notes for compiling Elixir from source on Windows](https://github.com/elixir-lang/elixir/wiki/Windows).
 
-If Elixir fails to build (specifically when pulling in a new version via
-`git`), be sure to remove any previous build artifacts by running
-`make clean`, then `make test`.
+If Elixir fails to build (specifically when pulling in a new version via git), be sure to remove any previous build artifacts by running `make clean`, then `make test`.
 
-If tests pass, you are ready to move on to the
-[Getting Started guide][1] or to try Interactive Elixir by running:
-`bin/iex` in your terminal.
+If tests pass, you are ready to move on to the [Getting Started guide][1] or to try Interactive Elixir by running: `bin/iex` in your terminal.
 
-However, if tests fail, it is likely you have an outdated Erlang version
-(Elixir requires Erlang 18.0 or later). You can check your Erlang version
-by calling `erl` in the command line. You will see some information as follows:
+However, if tests fail, it is likely you have an outdated Erlang version (Elixir requires Erlang 17.0 or later). You can check your Erlang version by calling `erl` in the command line. You will see some information as follows:
 
-    Erlang/OTP 18 [erts-7.0] [source] [smp:2:2] [async-threads:10] [hipe] [kernel-poll:false]
+    Erlang/OTP 17 [erts-6.0] [source-07b8f44] [64-bit] [smp:4:4] [async-threads:10] [hipe] [kernel-poll:false]
 
-If you have the correct version and tests still fail, please
-[open an issue][2].
-
-## Contributing
-
-We welcome everyone to contribute to Elixir and help us tackle
-existing issues! To do so, there are a few things you need to know
-about the code. First, Elixir code is divided in applications inside
-the `lib` folder:
-
-* `elixir` - Contains Elixir's kernel and stdlib
-
-* `eex` - Template engine that allows you to embed Elixir
-
-* `ex_unit` - Simple test framework that ships with Elixir
-
-* `iex` - IEx, Elixir's interactive shell
-
-* `logger` - The built-in logger
-
-* `mix` - Elixir's build tool
-
-You can run all tests in the root directory with `make test` and you can
-also run tests for a specific framework `make test_#{NAME}`, for example,
-`make test_ex_unit`.
-
-In case you are changing a single file, you can compile and run tests only
-for that particular file for fast development cycles. For example, if you
-are changing the String module, you can compile it and run its tests as:
-
-```sh
-bin/elixirc lib/elixir/lib/string.ex -o lib/elixir/ebin
-bin/elixir lib/elixir/test/elixir/string_test.exs
-```
-
-After your changes are done, please remember to run the full suite with
-`make test`.
-
-From time to time, your tests may fail in an existing Elixir checkout and
-may require a clean start by running `make clean compile`. You can always
-check [the official build status on Travis-CI](https://travis-ci.org/elixir-lang/elixir).
-
-With tests running and passing, you are ready to contribute to Elixir and
-[send a pull request](https://help.github.com/articles/using-pull-requests/).
-We have saved some excellent pull requests we have received in the past in
-case you are looking for some examples:
-
-* [Implement Enum.member? – Pull Request](https://github.com/elixir-lang/elixir/pull/992)
-* [Add String.valid? – Pull Request](https://github.com/elixir-lang/elixir/pull/1058)
-* [Implement capture_io for ExUnit – Pull Request](https://github.com/elixir-lang/elixir/pull/1059)
-
-We usually keep a list of enhancements and bugs [in the issue tracker][2].
-For proposing a new feature, please start a discussion in the
-[Elixir Core mailing list][3]. Keep in mind that it is your responsibility
-to argue and explain why a feature is useful and how it will impact the
-codebase and the community. Finally, remember all interactions in our official
-spaces follow our [Code of Conduct][7].
+If you have the correct version and tests still fail, feel free to [open an issue][2].
 
 ## Building documentation
 
-Building the documentation requires [ExDoc](https://github.com/elixir-lang/ex_doc)
-to be installed and built alongside Elixir:
+Building the documentation requires [ex_doc](https://github.com/elixir-lang/ex_doc) to be installed and built in the same containing folder as elixir.
 
-```sh
-# After cloning and compiling Elixir, in its parent directory:
-git clone git://github.com/elixir-lang/ex_doc.git
-cd ex_doc && ../elixir/bin/mix do deps.get, compile
-cd ../elixir && make docs
-```
+    # 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
 
-This will produce documentation sets for `elixir`, `mix`, etc., under
-the `doc` directory. If you are planning to contribute documentation,
-[please check our best practices for writing documentation](http://elixir-lang.org/docs/stable/elixir/writing-documentation.html).
+## Contributing
 
-## Development links
+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].
 
-  * [Elixir Website][1]
-  * [Elixir Documentation][6]
-  * [Elixir Core Mailing list (development)][3]
-  * [Issues tracker][2]
-  * [Code of Conduct][7]
-  * **[#elixir-lang][4]** on [Freenode][5] IRC
+## Important links
+
+* \#elixir-lang on freenode IRC
+* [Website][1]
+* [Issue tracker][2]
+* [elixir-talk Mailing list (questions)][3]
+* [elixir-core Mailing list (development)][4]
 
   [1]: http://elixir-lang.org
   [2]: https://github.com/elixir-lang/elixir/issues
-  [3]: https://groups.google.com/group/elixir-lang-core
-  [4]: https://webchat.freenode.net/?channels=#elixir-lang
-  [5]: http://www.freenode.net
-  [6]: http://elixir-lang.org/docs.html
-  [7]: CODE_OF_CONDUCT.md
+  [3]: http://groups.google.com/group/elixir-lang-talk
+  [4]: http://groups.google.com/group/elixir-lang-core
 
 ## License
 
 "Elixir" and the Elixir logo are copyright (c) 2012 Plataformatec.
 
-Elixir source code is released under Apache 2 License.
+Elixir source code is released under Apache 2 License with some parts under Erlang's license (EPL).
 
-Check [NOTICE](NOTICE) and [LICENSE](LICENSE) files for more
-information.
+Check [LEGAL](LEGAL) and [LICENSE](LICENSE) files for more information.

RELEASE.md

@@ -14,36 +14,30 @@ This document simply outlines the release process:
 
 5. Run `make clean test` to ensure all tests pass from scratch and the CI is green
 
-6. Recompile an existing project (for example, Ecto) to ensure manifests can be upgraded
+6. Ensure minimum supported Hex works with new release (instructions upcoming)
 
-7. Push branch and the new tag
+7. Push master and the new tag
 
-8. Publish new docs with `make publish_docs`, copy docs to `docs/stable` if appropriate, and push to GitHub Pages
+8. Release new docs with `make release_docs`, move docs to `docs/stable` if appropriate, and push
 
-9. Publish new zips with `make publish_zips`, upload `Precompiled.zip` and `Docs.zip` to GitHub Releases
+9. Release new zip with `make release_zip`, push `Precompiled.zip` to GitHub Releases
 
 10. Add the release to `elixir.csv` file in `elixir-lang/elixir-lang.github.com`
 
+11. Build and push standalone Mix with `make publish_mix` (requires AWS credentials)
+
 ## New vMAJOR.MINOR releases
 
 11. Create a new branch "vMAJOR.MINOR"
 
-12. Move docs generation to `docs/vMAJOR.MINOR` in Makefile, set CANONICAL to stable and copy them to `docs/stable` (change index.html accordingly)
+12. Move docs generation to `docs/vOLD-MAJOR.OLD-MINOR` and copy them to `docs/stable`
 
-13. In master, bump versions, start new CHANGELOG, add `-dev` back and commit "Start vVERSION+1"
+13. Bump versions, start new CHANGELOG, add `-dev` back and commit "Start vVERSION+1"
+
+14. `make release_docs` and push it to `elixir-lang/docs`
 
 ## Places where version is mentioned
 
-* VERSION
+* VERSION (make sure there is no newline in this file)
 * CHANGELOG.md
 * src/elixir.app.src (not lib/elixir/src/elixir.app.src)
-
-## Deprecation policy
-
-Elixir deprecations happens in 3 steps:
-
-  1. The feature is soft-deprecated. It means both CHANGELOG and documentation must list the feature as deprecated but no warning is effectively emitted by running the code. There is no requirement to soft-deprecate a feature.
-
-  2. The feature is effectively deprecated by emitting warnings on usage. In order to deprecate a feature, the proposed alternative MUST exist for AT LEAST two versions. For example, `Enum.uniq/2` was soft-deprecated in favor of `Enum.uniq_by/2` in Elixir v1.1. This means a deprecation warning may only be emitted by Elixir v1.3 or later.
-
-  3. The feature is removed. This can only happen on major releases. This means deprecated features in Elixir v1.x shall only be removed by Elixir v2.x.

VERSION

@@ -1 +1 @@
-1.3.2
+1.0.2

bin/elixir

@@ -2,29 +2,25 @@
 if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
   echo "Usage: `basename $0` [options] [.exs file] [data]
 
-  -v                          Prints version and exits
-  -e COMMAND                  Evaluates the given command (*)
-  -r FILE                     Requires the given files/patterns (*)
-  -S SCRIPT                   Finds and executes the given script in PATH
-  -pr FILE                    Requires the given files/patterns in parallel (*)
-  -pa PATH                    Prepends the given path to Erlang code path (*)
-  -pz PATH                    Appends the given path to Erlang code path (*)
-
-  --app APP                   Starts the given app and its dependencies (*)
-  --cookie COOKIE             Sets a cookie for this distributed node
-  --detached                  Starts the Erlang VM detached from console
-  --erl SWITCHES              Switches to be passed down to Erlang (*)
-  --hidden                    Makes a hidden node
-  --logger-otp-reports BOOL   Enables or disables OTP reporting
-  --logger-sasl-reports BOOL  Enables or disables SASL reporting
-  --name NAME                 Makes and assigns a name to the distributed node
-  --no-halt                   Does not halt the Erlang VM after execution
-  --sname NAME                Makes and assigns a short name to the distributed node
-  --werl                      Uses Erlang's Windows shell GUI (Windows only)
+  -v                Prints version and exit
+  -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_OPTIONS or --erl" >&2
+** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTIONS or --erl" >&2
   exit 1
 fi
 
@@ -39,7 +35,6 @@ readlink_f () {
 }
 
 MODE="elixir"
-ERL_EXEC="erl"
 ERL=""
 I=1
 
@@ -71,28 +66,11 @@ while [ $I -le $# ]; do
         eval "VAL=\${$I}"
         ERL="$ERL `echo $PEEK | cut -c 2-` "$VAL""
         ;;
-    --logger-otp-reports)
-        I=$(expr $I + 1)
-        eval "VAL=\${$I}"
-        if [ "$VAL" == 'true' ] || [ "$VAL" == 'false' ]; then
-            ERL="$ERL -logger handle_otp_reports "$VAL""
-        fi
-        ;;
-    --logger-sasl-reports)
-        I=$(expr $I + 1)
-        eval "VAL=\${$I}"
-        if [ "$VAL" == 'true' ] || [ "$VAL" == 'false' ]; then
-            ERL="$ERL -logger handle_sasl_reports "$VAL""
-        fi
-        ;;
     --erl)
         I=$(expr $I + 1)
         eval "VAL=\${$I}"
         ERL="$ERL "$VAL""
         ;;
-    --werl)
-        USE_WERL=true
-        ;;
     *)
         break
         ;;
@@ -111,15 +89,11 @@ if [ "$OS" != "Windows_NT" ]; then
   if test -t 1 -a -t 2; then ERL="-elixir ansi_enabled true $ERL"; fi
 fi
 
-if [ "$OS" = "Windows_NT" ] && [ $USE_WERL ]; then
-    ERL_EXEC="werl"
-fi
-
 if [ -z "$ERL_PATH" ]; then
   if [ -f "$SCRIPT_PATH/../releases/RELEASES" ] && [ -f "$SCRIPT_PATH/erl" ]; then
-    ERL_PATH="$SCRIPT_PATH"/"$ERL_EXEC"
+    ERL_PATH="$SCRIPT_PATH"/erl
   else
-    ERL_PATH="$ERL_EXEC"
+    ERL_PATH=erl
   fi
 fi
 

bin/elixir.bat

@@ -1,38 +1,34 @@
-@if defined ELIXIR_CLI_ECHO (@echo on) else  (@echo off)
+@echo off
 setlocal
-if    ""%1""==""""       goto :documentation
-if /I ""%1""==""--help"" goto :documentation
-if /I ""%1""==""-h""     goto :documentation
-if /I ""%1""==""/h""     goto :documentation
-if    ""%1""==""/?""     goto :documentation
+if "%1"==""       goto documentation
+if "%1"=="--help" goto documentation
+if "%1"=="-h"     goto documentation
+if "%1"=="/h"     goto documentation
 goto parseopts
 
 :documentation
 echo Usage: %~nx0 [options] [.exs file] [data]
 echo.
-echo   -v                          Prints version and exits
-echo   -e COMMAND                  Evaluates the given command (*)
-echo   -r FILE                     Requires the given files/patterns (*)
-echo   -S SCRIPT                   Finds and executes the given script in PATH
-echo   -pr FILE                    Requires the given files/patterns in parallel (*)
-echo   -pa PATH                    Prepends the given path to Erlang code path (*)
-echo   -pz PATH                    Appends the given path to Erlang code path (*)
-echo.
-echo   --app APP                   Starts the given app and its dependencies (*)
-echo   --cookie COOKIE             Sets a cookie for this distributed node
-echo   --detached                  Starts the Erlang VM detached from console
-echo   --erl SWITCHES              Switches to be passed down to Erlang (*)
-echo   --hidden                    Makes a hidden node
-echo   --logger-otp-reports BOOL   Enables or disables OTP reporting
-echo   --logger-sasl-reports BOOL  Enables or disables SASL reporting
-echo   --name NAME                 Makes and assigns a name to the distributed node
-echo   --no-halt                   Does not halt the Erlang VM after execution
-echo   --sname NAME                Makes and assigns a short name to the distributed node
-echo   --werl                      Uses Erlang's Windows shell GUI
+echo   -v                Prints version and exit
+echo   -e command        Evaluates the given command (*)
+echo   -r file           Requires the given files/patterns (*)
+echo   -S script         Finds and executes the given script
+echo   -pr file          Requires the given files/patterns in parallel (*)
+echo   -pa path          Prepends the given path to Erlang code path (*)
+echo   -pz path          Appends the given path to Erlang code path (*)
+echo   --app app         Start the given app and its dependencies (*)
+echo   --erl switches    Switches to be passed down to erlang (*)
+echo   --name name       Makes and assigns a name to the distributed node
+echo   --sname name      Makes and assigns a short name to the distributed node
+echo   --cookie cookie   Sets a cookie for this distributed node
+echo   --hidden          Makes a hidden node
+echo   --detached        Starts the Erlang VM detached from console
+echo   --werl            Uses Erlang's Windows shell GUI
+echo   --no-halt         Does not halt the Erlang VM after execution
 echo.
 echo ** Options marked with (*) can be given more than once
 echo ** Options given after the .exs file or -- are passed down to the executed code
-echo ** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS or --erl
+echo ** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTIONS or --erl
 goto end
 
 :parseopts
@@ -70,7 +66,7 @@ if "%par%"=="""" (
 rem ******* EXECUTION OPTIONS **********************
 IF "%par%"==""--werl"" (Set useWerl=1)
 IF "%par%"==""+iex"" (Set runMode="iex")
-rem ******* ELIXIR PARAMETERS **********************
+rem ******* elixir parameters **********************
 rem Note: we don't have to do anything with options that don't take an argument
 IF """"=="%par:-e=%"      (shift) 
 IF """"=="%par:-r=%"      (shift) 
@@ -80,14 +76,12 @@ IF """"=="%par:-pz=%"     (shift)
 IF """"=="%par:--app=%"   (shift) 
 IF """"=="%par:--remsh=%" (shift) 
 rem ******* ERLANG PARAMETERS **********************
-IF """"=="%par:--detached=%"            (Set parsErlang=%parsErlang% -detached) 
-IF """"=="%par:--hidden=%"              (Set parsErlang=%parsErlang% -hidden)
-IF """"=="%par:--cookie=%"              (Set parsErlang=%parsErlang% -setcookie %1 && shift)
-IF """"=="%par:--sname=%"               (Set parsErlang=%parsErlang% -sname %1 && shift) 
-IF """"=="%par:--name=%"                (Set parsErlang=%parsErlang% -name %1 && shift) 
-IF """"=="%par:--logger-otp-reports=%"  (Set parsErlang=%parsErlang% -logger handle_otp_reports %1 && shift) 
-IF """"=="%par:--logger-sasl-reports=%" (Set parsErlang=%parsErlang% -logger handle_sasl_reports %1 && shift) 
-IF """"=="%par:--erl=%"                 (Set beforeExtra=%beforeExtra% %~1 && shift) 
+IF """"=="%par:--detached=%" (Set parsErlang=%parsErlang% -detached) 
+IF """"=="%par:--hidden=%"   (Set parsErlang=%parsErlang% -hidden)
+IF """"=="%par:--cookie=%"   (Set parsErlang=%parsErlang% -setcookie %1 && shift)
+IF """"=="%par:--sname=%"    (Set parsErlang=%parsErlang% -sname %1 && shift) 
+IF """"=="%par:--name=%"     (Set parsErlang=%parsErlang% -name %1 && shift) 
+IF """"=="%par:--erl=%"      (Set beforeExtra=%beforeExtra% %~1 && shift) 
 goto:startloop
 
 rem ******* assume all pre-params are parsed ********************
@@ -101,12 +95,12 @@ for  /d %%d in ("%originPath%..\lib\*.") do (
 SETLOCAL disabledelayedexpansion
 :run
 IF NOT %runMode% == "iex" (
-  set beforeExtra=-noshell -s elixir start_cli %beforeExtra%
+  set beforeExtra=-s elixir start_cli %beforeExtra%
 )
 IF %useWerl% EQU 1 (
   start werl.exe %ext_libs% %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
 ) ELSE (
-  erl.exe %ext_libs% %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
+  erl.exe %ext_libs% -noshell %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
 )
 :end
 endlocal

bin/elixirc

@@ -2,16 +2,16 @@
 if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
   echo "Usage: `basename $0` [elixir switches] [compiler switches] [.ex files]
 
-  -o                   The directory to output compiled files
-  --no-docs            Do not attach documentation to compiled modules
-  --no-debug-info      Do not attach debug info to compiled modules
-  --verbose            Print compilation status
-  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+  -o               The directory to output compiled files
+  --no-docs        Do not attach documentation to compiled modules
+  --no-debug-info  Do not attach debug info to compiled modules
   --ignore-module-conflict
+  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+  --verbose        Print informational messages.
 
 ** Options given after -- are passed down to the executed code
-** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS
-** Options can be passed to the Erlang compiler using ERL_COMPILER_OPTIONS" >&2
+** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTIONS
+** Options can be passed to the erlang compiler using ERL_COMPILER_OPTIONS" >&2
   exit 1
 fi
 

bin/elixirc.bat

@@ -1,11 +1,9 @@
-@if defined ELIXIR_CLI_ECHO (@echo on) else  (@echo off)
-setlocal
+@echo off
 set argc=0
 for %%A in (%*) do (
-    if /I "%%A"=="--help" goto documentation
-    if /I "%%A"=="-h"     goto documentation
-    if /I "%%A"=="/h"     goto documentation
-    if    "%%A"=="/?"     goto documentation
+    if "%%A"=="--help" goto documentation
+    if "%%A"=="-h"     goto documentation
+    if "%%A"=="/h"     goto documentation
     set /A argc+=1
 )
 if %argc%==0 goto documentation
@@ -14,20 +12,15 @@ goto run
 :documentation
 echo Usage: %~nx0 [elixir switches] [compiler switches] [.ex files]
 echo.
-echo  -o                   The directory to output compiled files
-echo  --no-docs            Do not attach documentation to compiled modules
-echo  --no-debug-info      Do not attach debug info to compiled modules
-echo  --verbose            Print compilation status
-echo  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+echo  -o               The directory to output compiled files
+echo  --no-docs        Do not attach documentation to compiled modules
+echo  --no-debug-info  Do not attach debug info to compiled modules
 echo  --ignore-module-conflict
+echo  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+echo  --verbose        Print informational messages.
 echo.
 echo ** Options given after -- are passed down to the executed code
-echo ** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS
-echo ** Options can be passed to the Erlang compiler using ERL_COMPILER_OPTIONS
-goto end
-
+echo ** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTIONS
+echo ** Options can be passed to the erlang compiler using ERL_COMPILER_OPTIONS >&2
 :run
 call "%~dp0\elixir.bat" +elixirc %*
-
-:end
-endlocal

bin/iex

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

bin/iex.bat

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

bin/mix

@@ -1,3 +1,4 @@
 #!/usr/bin/env elixir
+# Reminder: apply any changes in this file to bin\mix.bat
 Mix.start
 Mix.CLI.main

bin/mix.bat

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

lib/eex/lib/eex.ex

@@ -9,7 +9,7 @@ end
 defmodule EEx do
   @moduledoc ~S"""
   EEx stands for Embedded Elixir. It allows you to embed
-  Elixir code inside a string in a robust way.
+  Elixir code inside a string in a robust way:
 
       iex> EEx.eval_string "foo <%= bar %>", [bar: "baz"]
       "foo baz"
@@ -35,14 +35,13 @@ defmodule EEx do
 
   ## Options
 
-  All functions in this module accept EEx-related options.
+  All functions in this module accepts EEx-related options.
   They are:
 
     * `:line` - the line to be used as the template start. Defaults to 1.
     * `:file` - the file to be used in the template. Defaults to the given
       file the template is read from or to "nofile" when compiling from a string.
     * `:engine` - the EEx engine to be used for compilation.
-    * `:trim` - trims whitespace left/right of quotation tags
 
   ## Engine
 
@@ -63,9 +62,9 @@ defmodule EEx do
 
   All expressions that output something to the template
   **must** use the equals sign (`=`). Since everything in
-  Elixir is an expression, there are no exceptions for this rule.
-  For example, while some template languages would special-case
-  `if/2` clauses, they are treated the same in EEx and
+  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 %>
@@ -86,11 +85,11 @@ defmodule EEx do
       iex> EEx.eval_string "<%= @foo %>", assigns: [foo: 1]
       "1"
 
-  In other words, `<%= @foo %>` translates to:
+  In other words, `<%= @foo %>` is simply translated to:
 
-      <%= {:ok, v} = Access.fetch(assigns, :foo); v %>
+      <%= Dict.get assigns, :foo %>
 
-  The `assigns` extension is useful when the number of variables
+  The assigns extension is useful when the number of variables
   required by the template is not specified at compilation time.
   """
 
@@ -163,7 +162,7 @@ defmodule EEx do
   end
 
   @doc """
-  Gets a string `source` and generate a quoted expression
+  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
@@ -171,7 +170,7 @@ defmodule EEx do
   end
 
   @doc """
-  Gets a `filename` and generate a quoted expression
+  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
@@ -180,7 +179,7 @@ defmodule EEx do
   end
 
   @doc """
-  Gets a string `source` and evaluate the values using the `bindings`.
+  Get a string `source` and evaluate the values using the `bindings`.
 
   ## Examples
 
@@ -194,15 +193,15 @@ defmodule EEx do
   end
 
   @doc """
-  Gets a `filename` and evaluate the values using the `bindings`.
+  Get a `filename` and evaluate the values using the `bindings`.
 
   ## Examples
 
-      # sample.eex
+      # sample.ex
       foo <%= bar %>
 
       # iex
-      EEx.eval_file "sample.eex", [bar: "baz"] #=> "foo baz"
+      EEx.eval_file "sample.ex", [bar: "baz"] #=> "foo baz"
 
   """
   def eval_file(filename, bindings \\ [], options \\ []) do

lib/eex/lib/eex/compiler.ex

@@ -12,12 +12,11 @@ defmodule EEx.Compiler do
   def compile(source, opts) do
     file   = opts[:file] || "nofile"
     line   = opts[:line] || 1
-    trim   = opts[:trim] || false
-    case EEx.Tokenizer.tokenize(source, line, trim: trim) do
+    case EEx.Tokenizer.tokenize(source, line) do
       {:ok, tokens} ->
         state = %{engine: opts[:engine] || @default_engine,
                   file: file, line: line, quoted: [], start_line: nil}
-        generate_buffer(tokens, state.engine.init(opts), [], state)
+        generate_buffer(tokens, "", [], state)
       {:error, line, message} ->
         raise EEx.SyntaxError, line: line, file: file, message: message
     end
@@ -25,38 +24,38 @@ defmodule EEx.Compiler do
 
   # Generates the buffers by handling each expression from the tokenizer
 
-  defp generate_buffer([{:text, chars} | t], buffer, scope, state) do
+  defp generate_buffer([{:text, chars}|t], buffer, scope, state) do
     buffer = state.engine.handle_text(buffer, IO.chardata_to_string(chars))
     generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{:expr, line, mark, chars} | t], buffer, scope, state) do
+  defp generate_buffer([{:expr, line, mark, chars}|t], buffer, scope, state) do
     expr = Code.string_to_quoted!(chars, [line: line, file: state.file])
-    buffer = state.engine.handle_expr(buffer, IO.chardata_to_string(mark), expr)
+    buffer = state.engine.handle_expr(buffer, mark, expr)
     generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{:start_expr, start_line, mark, chars} | t], buffer, scope, state) do
+  defp generate_buffer([{:start_expr, start_line, mark, chars}|t], buffer, scope, state) do
     {contents, line, t} = look_ahead_text(t, start_line, chars)
-    {contents, t} = generate_buffer(t, "", [contents | scope],
+    {contents, t} = generate_buffer(t, "", [contents|scope],
                                     %{state | quoted: [], line: line, start_line: start_line})
-    buffer = state.engine.handle_expr(buffer, IO.chardata_to_string(mark), contents)
+    buffer = state.engine.handle_expr(buffer, mark, contents)
     generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{:middle_expr, line, _, chars} | t], buffer, [current | scope], state) do
+  defp generate_buffer([{:middle_expr, line, _, chars}|t], buffer, [current|scope], state) do
     {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
-    generate_buffer(t, "", [wrapped | scope], %{state | line: line})
+    generate_buffer(t, "", [wrapped|scope], %{state | line: line})
   end
 
-  defp generate_buffer([{:end_expr, line, _, chars} | t], buffer, [current | _], state) do
+  defp generate_buffer([{:end_expr, line, _, chars}|t], buffer, [current|_], state) do
     {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
     tuples = Code.string_to_quoted!(wrapped, [line: state.start_line, file: state.file])
     buffer = insert_quoted(tuples, state.quoted)
     {buffer, t}
   end
 
-  defp generate_buffer([{:end_expr, line, _, chars} | _], _buffer, [], state) do
+  defp generate_buffer([{:end_expr, line, _, chars}|_], _buffer, [], state) do
     raise EEx.SyntaxError, message: "unexpected token #{inspect chars}", file: state.file, line: line
   end
 
@@ -74,14 +73,14 @@ defmodule EEx.Compiler do
   defp wrap_expr(current, line, buffer, chars, state) do
     new_lines = List.duplicate(?\n, line - state.line)
     key = length(state.quoted)
-    placeholder = '__EEX__(' ++ Integer.to_charlist(key) ++ ');'
+    placeholder = '__EEX__(' ++ Integer.to_char_list(key) ++ ');'
     {current ++ placeholder ++ new_lines ++ chars,
-     %{state | quoted: [{key, buffer} | state.quoted]}}
+     %{state | quoted: [{key, buffer}|state.quoted]}}
   end
 
   # Look text ahead on expressions
 
-  defp look_ahead_text([{:text, text}, {:middle_expr, line, _, chars} | t]=list, start, contents) do
+  defp look_ahead_text([{:text, text}, {:middle_expr, line, _, chars}|t]=list, start, contents) do
     if only_spaces?(text) do
       {contents ++ text ++ chars, line, t}
     else

lib/eex/lib/eex/engine.ex

@@ -4,8 +4,6 @@ defmodule EEx.Engine do
 
   An engine needs to implement three functions:
 
-    * `init(opts)` - returns the initial buffer
-
     * `handle_body(quoted)` - receives the final built quoted
       expression, should do final post-processing and return a
       quoted expression.
@@ -27,20 +25,17 @@ defmodule EEx.Engine do
   default implementations for the functions above.
   """
 
-  @callback init(Keyword.t) :: Macro.t
-  @callback handle_body(Macro.t) :: Macro.t
-  @callback handle_text(Macro.t, String.t) :: Macro.t
-  @callback handle_expr(Macro.t, String.t, Macro.t) :: Macro.t
+  use Behaviour
+
+  defcallback handle_body(Macro.t) :: Macro.t
+  defcallback handle_text(Macro.t, binary) :: Macro.t
+  defcallback handle_expr(Macro.t, binary, Macro.t) :: Macro.t
 
   @doc false
   defmacro __using__(_) do
     quote do
       @behaviour EEx.Engine
 
-      def init(opts) do
-        EEx.Engine.init(opts)
-      end
-
       def handle_body(body) do
         EEx.Engine.handle_body(body)
       end
@@ -49,22 +44,19 @@ defmodule EEx.Engine do
         EEx.Engine.handle_text(buffer, text)
       end
 
-      def handle_expr(buffer, marker, expr) do
-        EEx.Engine.handle_expr(buffer, marker, expr)
+      def handle_expr(buffer, mark, expr) do
+        EEx.Engine.handle_expr(buffer, mark, expr)
       end
 
-      defoverridable [handle_body: 1, handle_expr: 3, handle_text: 2, init: 1]
+      defoverridable [handle_body: 1, handle_expr: 3, handle_text: 2]
     end
   end
 
   @doc """
   Handles assigns in quoted expressions.
 
-  A warning will be printed on missing assigns.
-  Future versions will raise.
-
   This can be added to any custom engine by invoking
-  `handle_assign/1` with `Macro.prewalk/2`:
+  `handle_assign/3` with `Macro.prewalk/1`:
 
       def handle_expr(buffer, token, expr) do
         expr = Macro.prewalk(expr, &EEx.Engine.handle_assign/1)
@@ -74,36 +66,16 @@ defmodule EEx.Engine do
   """
   def handle_assign({:@, meta, [{name, _, atom}]}) when is_atom(name) and is_atom(atom) do
     line = meta[:line] || 0
-    quote line: line, do: EEx.Engine.fetch_assign!(var!(assigns), unquote(name))
+    quote line: line, do: Dict.get(var!(assigns), unquote(name))
   end
+
   def handle_assign(arg) do
     arg
   end
 
-  @doc false
-  # TODO: Raise on 2.0
-  def fetch_assign!(assigns, key) do
-    case Access.fetch(assigns, key) do
-      {:ok, val} ->
-        val
-      :error ->
-        keys = Enum.map(assigns, &elem(&1, 0))
-        IO.warn "assign @#{key} not available in EEx template. " <>
-                "Please ensure all assigns are given as options. " <>
-                "Available assigns: #{inspect keys}"
-        nil
-    end
-  end
-
   @doc """
-  Returns an empty string as initial buffer.
-  """
-  def init(_opts) do
-    ""
-  end
-
-  @doc """
-  The default implementation simply returns the given expression.
+  The default implementation implementation simply returns the
+  given expression.
   """
   def handle_body(quoted) do
     quoted
@@ -124,19 +96,18 @@ defmodule EEx.Engine do
 
   All other markers are not implemented by this engine.
   """
-  @spec handle_expr(Macro.t, String.t, Macro.t) :: Macro.t
   def handle_expr(buffer, "=", expr) do
     quote do
-      tmp1 = unquote(buffer)
-      tmp1 <> String.Chars.to_string(unquote(expr))
+      tmp = unquote(buffer)
+      tmp <> String.Chars.to_string(unquote(expr))
     end
   end
 
   def handle_expr(buffer, "", expr) do
     quote do
-      tmp2 = unquote(buffer)
+      tmp = unquote(buffer)
       unquote(expr)
-      tmp2
+      tmp
     end
   end
 end

lib/eex/lib/eex/smart_engine.ex

@@ -11,9 +11,9 @@ defmodule EEx.SmartEngine do
       "1"
 
   In the example above, we can access the value `foo` under
-  the binding `assigns` using `@foo`. This is useful because
-  a template, after being compiled, can receive different
-  assigns and would not require recompilation for each
+  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.
 
   Assigns can also be used when compiled to a function:

lib/eex/lib/eex/tokenizer.ex

@@ -2,7 +2,7 @@ defmodule EEx.Tokenizer do
   @moduledoc false
 
   @doc """
-  Tokenizes the given charlist or binary.
+  Tokenizes the given char list or binary.
 
   It returns {:ok, list} with the following tokens:
 
@@ -14,77 +14,77 @@ defmodule EEx.Tokenizer do
 
   Or `{:error, line, error}` in case of errors.
   """
-  def tokenize(bin, line, opts \\ [])
-
-  def tokenize(bin, line, opts) when is_binary(bin) do
-    tokenize(String.to_charlist(bin), line, opts)
+  def tokenize(bin, line) when is_binary(bin) do
+    tokenize(String.to_char_list(bin), line)
   end
 
-  def tokenize(list, line, opts) do
-    tokenize(list, line, opts, [], [])
+  def tokenize(list, line) do
+    tokenize(list, line, [], [])
   end
 
-  defp tokenize('<%%' ++ t, line, opts, buffer, acc) do
-   tokenize t, line, opts, [?%, ?< | buffer], acc
-  end
-
-  defp tokenize('<%#' ++ t, line, opts, buffer, acc) do
-    case expr(t, line, []) do
+  defp tokenize('<%%' ++ t, line, buffer, acc) do
+    case expr(t, line, [?%, ?<|buffer]) do
       {:error, _, _} = error -> error
-      {:ok, _, new_line, rest} ->
-        {rest, new_line, buffer} = trim_if_needed(rest, new_line, opts, buffer, acc)
-        tokenize rest, new_line, opts, buffer, acc
+      {:ok, buffer, new_line, rest} ->
+        tokenize rest, new_line, [?>, ?%|buffer], acc
     end
   end
 
-  defp tokenize('<%' ++ t, line, opts, buffer, acc) do
+  defp tokenize('<%#' ++ t, line, buffer, acc) do
+    case expr(t, line, []) do
+      {:error, _, _} = error -> error
+      {:ok, _, new_line, rest} ->
+        tokenize rest, new_line, buffer, acc
+    end
+  end
+
+  defp tokenize('<%' ++ t, line, buffer, acc) do
     {marker, t} = retrieve_marker(t)
 
     case expr(t, line, []) do
       {:error, _, _} = error -> error
       {:ok, expr, new_line, rest} ->
         token = token_name(expr)
-        {rest, new_line, buffer} = trim_if_needed(rest, new_line, opts, buffer, acc)
         acc   = tokenize_text(buffer, acc)
         final = {token, line, marker, Enum.reverse(expr)}
-        tokenize rest, new_line, opts, [], [final | acc]
+        tokenize rest, new_line, [], [final | acc]
     end
   end
 
-  defp tokenize('\n' ++ t, line, opts, buffer, acc) do
-    tokenize t, line + 1, opts, [?\n | buffer], acc
+  defp tokenize('\n' ++ t, line, buffer, acc) do
+    tokenize t, line + 1, [?\n|buffer], acc
   end
 
-  defp tokenize([h | t], line, opts, buffer, acc) do
-    tokenize t, line, opts, [h | buffer], acc
+  defp tokenize([h|t], line, buffer, acc) do
+    tokenize t, line, [h|buffer], acc
   end
 
-  defp tokenize([], _line, _opts, buffer, acc) do
+  defp tokenize([], _line, buffer, acc) do
     {:ok, Enum.reverse(tokenize_text(buffer, acc))}
   end
 
   # Retrieve marker for <%
 
   defp retrieve_marker('=' ++ t) do
-    {'=', t}
+    {"=", t}
   end
 
   defp retrieve_marker(t) do
-    {'', t}
+    {"", t}
   end
 
   # Tokenize an expression until we find %>
 
-  defp expr([?%, ?> | t], line, buffer) do
+  defp expr([?%, ?>|t], line, buffer) do
     {:ok, buffer, line, t}
   end
 
   defp expr('\n' ++ t, line, buffer) do
-    expr t, line + 1, [?\n | buffer]
+    expr t, line + 1, [?\n|buffer]
   end
 
-  defp expr([h | t], line, buffer) do
-    expr t, line, [h | buffer]
+  defp expr([h|t], line, buffer) do
+    expr t, line, [h|buffer]
   end
 
   defp expr([], line, _buffer) do
@@ -94,15 +94,15 @@ defmodule EEx.Tokenizer do
   # Receive an expression content and check
   # if it is a start, middle or an end token.
   #
-  # Start tokens finish with "do" and "fn ->"
-  # Middle tokens are marked with "->" or keywords
-  # End tokens contain only the end word and optionally ")"
+  # 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
+  defp token_name([h|t]) when h in [?\s, ?\t] do
     token_name(t)
   end
 
-  defp token_name('od' ++ [h | _]) when h in [?\s, ?\t, ?)] do
+  defp token_name('od' ++ [h|_]) when h in [?\s, ?\t, ?)] do
     :start_expr
   end
 
@@ -115,7 +115,7 @@ defmodule EEx.Tokenizer do
     # token and, if so, it is not followed by an "end"
     # token. If this is the case, we are on a start expr.
     case :elixir_tokenizer.tokenize(rest, 1, file: "eex", check_terminators: false) do
-      {:ok, _line, _column, tokens} ->
+      {:ok, _line, tokens} ->
         tokens   = Enum.reverse(tokens)
         fn_index = fn_index(tokens)
 
@@ -143,7 +143,7 @@ defmodule EEx.Tokenizer do
     Enum.find_index tokens, fn
       {:fn_paren, _} -> true
       {:fn, _}       -> true
-      _              -> false
+      _                -> false
     end
   end
 
@@ -169,47 +169,4 @@ defmodule EEx.Tokenizer do
   defp tokenize_text(buffer, acc) do
     [{:text, Enum.reverse(buffer)} | acc]
   end
-
-  # If trim mode is enabled and the token is on a line with
-  # only itself and whitespace, trim the whitespace around it,
-  # including the line break following it if there is one.
-
-  defp trim_if_needed(rest, line, opts, buffer, acc) do
-    original = {rest, line, buffer}
-    if opts[:trim] do
-      case {trim_left(buffer, acc), trim_right(rest, line)} do
-        {{true, new_buffer}, {true, new_rest, new_line}} ->
-          {new_rest, new_line, new_buffer}
-        _ ->
-          original
-      end
-    else
-      original
-    end
-  end
-
-  defp trim_left(buffer, acc) do
-    case {trim_whitespace(buffer), acc} do
-      {[?\n | _] = trimmed_buffer, _} -> {true, trimmed_buffer}
-      {[], []} -> {true, []}
-      _ -> {false, buffer}
-    end
-  end
-
-  defp trim_right(rest, line) do
-    case trim_whitespace(rest) do
-      [?\r, ?\n | trimmed_rest] -> {true, trimmed_rest, line + 1}
-      [?\n | trimmed_rest] -> {true, trimmed_rest, line + 1}
-      [] -> {true, [], line}
-      _ -> {false, rest, line}
-    end
-  end
-
-  defp trim_whitespace([h | t]) when h == ?\s or h == ?\t do
-    trim_whitespace(t)
-  end
-
-  defp trim_whitespace(list) do
-    list
-  end
 end

lib/eex/test/eex/smart_engine_test.exs

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

lib/eex/test/eex/tokenizer_test.exs

@@ -14,17 +14,17 @@ defmodule EEx.TokenizerTest do
 
   test "strings with embedded code" do
     assert T.tokenize('foo <% bar %>', 1) ==
-           {:ok, [{:text, 'foo '}, {:expr, 1, '', ' bar '}]}
+           {:ok, [{:text, 'foo '}, {:expr, 1, "", ' bar '}]}
   end
 
   test "strings with embedded equals code" do
     assert T.tokenize('foo <%= bar %>', 1) ==
-           {:ok, [{:text, 'foo '}, {:expr, 1, '=', ' bar '}]}
+           {:ok, [{:text, 'foo '}, {:expr, 1, "=", ' bar '}]}
   end
 
   test "strings with more than one line" do
     assert T.tokenize('foo\n<%= bar %>', 1) ==
-           {:ok, [{:text, 'foo\n'}, {:expr, 2, '=', ' bar '}]}
+           {:ok, [{:text, 'foo\n'}, {:expr, 2, "=", ' bar '}]}
   end
 
   test "strings with more than one line and expression with more than one line" do
@@ -37,9 +37,9 @@ baz %>
 
     assert T.tokenize(string, 1) == {:ok, [
       {:text, 'foo '},
-      {:expr, 1, '=', ' bar\n\nbaz '},
+      {:expr, 1, "=", ' bar\n\nbaz '},
       {:text, '\n'},
-      {:expr, 4, '', ' foo '},
+      {:expr, 4, "", ' foo '},
       {:text, '\n'}
     ]}
   end
@@ -56,20 +56,6 @@ baz %>
     ]}
   end
 
-  test "quotation with interpolation" do
-    assert T.tokenize('a <%% b <%= c %> <%= d %> e %> f', 1) == {:ok, [
-      {:text, 'a <% b '},
-      {:expr, 1, '=', ' c '},
-      {:text, ' '},
-      {:expr, 1, '=', ' d '},
-      {:text, ' e %> f'}
-    ]}
-
-    assert T.tokenize('<%%% a <%%= b %> c %>', 1) == {:ok, [
-      {:text, '<%% a <%= b %> c %>'}
-    ]}
-  end
-
   test "comments" do
     assert T.tokenize('foo <%# true %>', 1) == {:ok, [
       {:text, 'foo '}
@@ -85,79 +71,36 @@ baz %>
   test "strings with embedded do end" do
     assert T.tokenize('foo <% if true do %>bar<% end %>', 1) == {:ok, [
       {:text, 'foo '},
-      {:start_expr, 1, '', ' if true do '},
+      {:start_expr, 1, "", ' if true do '},
       {:text, 'bar'},
-      {:end_expr, 1, '', ' end '}
+      {:end_expr, 1, "", ' end '}
     ]}
   end
 
   test "strings with embedded -> end" do
     assert T.tokenize('foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>', 1) == {:ok, [
       {:text, 'foo '},
-      {:start_expr, 1, '', ' cond do '},
-      {:middle_expr, 1, '', ' false -> '},
+      {:start_expr, 1, "", ' cond do '},
+      {:middle_expr, 1, "", ' false -> '},
       {:text, 'bar'},
-      {:middle_expr, 1, '', ' true -> '},
+      {:middle_expr, 1, "", ' true -> '},
       {:text, 'baz'},
-      {:end_expr, 1, '', ' end '}
+      {:end_expr, 1, "", ' end '}
     ]}
   end
 
   test "strings with embedded keywords blocks" do
     assert T.tokenize('foo <% if true do %>bar<% else %>baz<% end %>', 1) == {:ok, [
       {:text, 'foo '},
-      {:start_expr, 1, '', ' if true do '},
+      {:start_expr, 1, "", ' if true do '},
       {:text, 'bar'},
-      {:middle_expr, 1, '', ' else '},
+      {:middle_expr, 1, "", ' else '},
       {:text, 'baz'},
-      {:end_expr, 1, '', ' end '}
+      {:end_expr, 1, "", ' end '}
     ]}
   end
 
-  test "trim mode" do
-    template = '\t<%= if true do %> \n TRUE \n  <% else %>\n FALSE \n  <% end %>  '
-    assert T.tokenize(template, 1, trim: true) == {:ok, [
-      {:start_expr, 1, '=', ' if true do '},
-      {:text, ' TRUE \n'},
-      {:middle_expr, 3, '', ' else '},
-      {:text, ' FALSE \n'},
-      {:end_expr, 5, '', ' end '}
-    ]}
-  end
-
-  test "trim mode with comment" do
-    assert T.tokenize('  <%# comment %>  \n123', 1, trim: true) == {:ok, [
-      {:text, '123'}
-    ]}
-  end
-
-  test "trim mode with CRLF" do
-    assert T.tokenize('0\r\n  <%= 12 %>  \r\n34', 1, trim: true) == {:ok, [
-      {:text, '0\r\n'},
-      {:expr, 2, '=', ' 12 '},
-      {:text, '34'}
-    ]}
-  end
-
-  test "trim mode set to false" do
-    assert T.tokenize(' <%= 12 %> \n', 1, trim: false) == {:ok, [
-      {:text, ' '},
-      {:expr, 1, '=', ' 12 '},
-      {:text, ' \n'}
-    ]}
-  end
-
-  test "trim mode no false positives" do
-    assert_not_trimmed = fn x -> assert T.tokenize(x, 1, trim: true) == T.tokenize(x, 1) end
-
-    assert_not_trimmed.('foo <%= "bar" %>  ')
-    assert_not_trimmed.('\n  <%= "foo" %>bar')
-    assert_not_trimmed.('  <%% hello %>  ')
-    assert_not_trimmed.('  <%= 01 %><%= 23 %>\n')
-  end
-
   test "raise syntax error when there is start mark and no end mark" do
     assert T.tokenize('foo <% :bar', 1) == {:error, 1, "missing token '%>'"}
-    assert T.tokenize('<%# true ', 1) == {:error, 1, "missing token '%>'"}
   end
 end

lib/eex/test/eex_test.exs

@@ -98,10 +98,6 @@ defmodule EExTest do
     assert_eval "foo baz", "foo <%= if true do %><%= if false do %>bar<% else %>baz<% end %><% end %>"
   end
 
-  test "evaluates with parentheses after end in end token" do
-    assert_eval " 101  102  103 ", "<%= Enum.map([1, 2, 3], (fn x -> %> <%= 100 + x %> <% end) ) %>"
-  end
-
   test "evaluates with defined variable" do
     assert_eval "foo 1", "foo <% bar = 1 %><%= bar %>"
   end
@@ -236,10 +232,6 @@ foo
     assert_eval expected, string
   end
 
-  test "respects files" do
-    assert_eval "sample.ex", "<%= __ENV__.file %>", [], file: "sample.ex"
-  end
-
   test "properly handle functions" do
     expected = """
 
@@ -260,7 +252,7 @@ Number <%= x %>
     assert_eval expected, string
   end
 
-  test "properly handle functions on the left side of clauses" do
+  test "do not consider already finished functions" do
     expected = """
 foo
 
@@ -295,18 +287,6 @@ foo
     assert_eval "\n\n  Good\n \n", string
   end
 
-  test "evaluates expressions with buffers" do
-    string = """
-    <%= 123 %>
-    <% if true do %>
-      <%= 456 %>
-    <% end %>
-    <%= 789 %>
-    """
-
-    assert_eval "123\n\n789\n", string
-  end
-
   test "for comprehensions" do
     string = """
     <%= for _name <- packages || [] do %>
@@ -316,7 +296,7 @@ foo
     assert_eval "\ndone\n", string, packages: nil, all: nil
   end
 
-  test "Unicode" do
+  test "unicode" do
     template = """
       • <%= "•" %> •
       <%= "Jößé Vâlìm" %> Jößé Vâlìm
@@ -325,12 +305,6 @@ foo
     assert result == "  • • •\n  Jößé Vâlìm Jößé Vâlìm\n"
   end
 
-  test "trim mode" do
-    string = "<%= 123 %> \n456\n  <%= 789 %>"
-    expected = "123456\n789"
-    assert_eval expected, string, [], trim: true
-  end
-
   test "evaluates the source from a given file" do
     filename = Path.join(__DIR__, "fixtures/eex_template.eex")
     result = EEx.eval_file(filename)
@@ -344,7 +318,7 @@ foo
   end
 
   test "raises an Exception when there's an error with the given file" do
-    assert_raise File.Error, "could not read file \"non-existent.eex\": no such file or directory", fn ->
+    assert_raise File.Error, "could not read file non-existent.eex: no such file or directory", fn ->
       filename = "non-existent.eex"
       EEx.compile_file(filename)
     end
@@ -370,7 +344,7 @@ foo
         {EExTest.Compiled,
           :before_compile,
           0,
-          [file: to_charlist(Path.relative_to_cwd(__ENV__.file)), line: 7]
+          [file: to_char_list(Path.relative_to_cwd(__ENV__.file)), line: 7]
        }
      }
 
@@ -379,7 +353,7 @@ foo
         {EExTest.Compiled,
           :after_compile,
           0,
-          [file: to_charlist(Path.relative_to_cwd(__ENV__.file)), line: 22]
+          [file: to_char_list(Path.relative_to_cwd(__ENV__.file)), line: 22]
        }
      }
 
@@ -396,10 +370,6 @@ foo
   defmodule TestEngine do
     @behaviour EEx.Engine
 
-    def init(_opts) do
-      ""
-    end
-
     def handle_body(body) do
       {:wrapped, body}
     end
@@ -417,9 +387,8 @@ foo
     assert {:wrapped, "foo"} = EEx.eval_string("foo", [], engine: TestEngine)
   end
 
-  defp assert_eval(expected, actual, binding \\ [], opts \\ []) do
-    opts = Enum.into [file: __ENV__.file, engine: EEx.Engine], opts
-    result = EEx.eval_string(actual, binding, opts)
+  defp assert_eval(expected, actual, binding \\ []) do
+    result = EEx.eval_string(actual, binding, file: __ENV__.file, engine: EEx.Engine)
     assert result == expected
   end
 end

lib/eex/test/test_helper.exs

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

lib/elixir/lib/access.ex

@@ -1,23 +1,15 @@
-defmodule Access do
+defprotocol Access do
   @moduledoc """
-  Key-based access to data structures using the `data[key]` syntax.
+  The Access protocol is used by `foo[bar]` and also
+  empowers the nested update functions in Kernel.
 
-  Elixir provides two syntaxes for accessing values. `user[:name]`
-  is used by dynamic structures, like maps and keywords, while
-  `user.name` is used by structs. The main difference is that
-  `user[:name]` won't raise if the key `:name` is missing but
-  `user.name` will raise if there is no `:name` key.
+  For instance, `foo[bar]` translates `Access.get(foo, bar)`.
+  `Kernel.get_in/2`, `Kernel.put_in/3`, `Kernel.update_in/3` and
+  `Kernel.get_and_update_in/3` are also all powered by the Access
+  protocol.
 
-  Besides the cases above, this module provides convenience
-  functions for accessing other structures, like `at/1` for
-  lists and `elem/1` for tuples. Those functions can be used
-  by the nested update functions in `Kernel`, such as
-  `Kernel.get_in/2`, `Kernel.put_in/3`, `Kernel.update_in/3`,
-  `Kernel.get_and_update_in/3` and friends.
-
-  ## Dynamic lookups
-
-  Out of the box, Access works with `Keyword` and `Map`:
+  This protocol is implemented by default for keywords, maps
+  and dictionary like types:
 
       iex> keywords = [a: 1, b: 2]
       iex> keywords[:a]
@@ -31,186 +23,113 @@ defmodule Access do
       iex> star_ratings[1.5]
       "★☆"
 
-  Access can be combined with `Kernel.put_in/3` to put a value
-  in a given key:
-
-      iex> map = %{a: 1, b: 2}
-      iex> put_in map[:a], 3
-      %{a: 3, b: 2}
-
-  This syntax is very convenient as it can be nested arbitrarily:
-
-      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
-      iex> put_in users["john"][:age], 28
-      %{"john" => %{age: 28}, "meg" => %{age: 23}}
-
-  Furthermore, Access transparently ignores `nil` values:
-
-      iex> keywords = [a: 1, b: 2]
-      iex> keywords[:c][:unknown]
-      nil
-
-  Since Access is a behaviour, it can be implemented to key-value
-  data structures. The implementation should be added to the
-  module that defines the struct being access. Access requires the
-  key comparison to be implemented using the `===` operator.
-
-  ## Static lookups
-
-  The Access syntax (`foo[bar]`) cannot be used to access fields in
-  structs, since structs do not implement the Access behaviour by
-  default. It is also design decision: the dynamic access lookup
-  is meant to be used for dynamic key-value structures, like maps
-  and keywords, and not by static ones like structs.
-
-  Therefore Elixir provides a static lookup for map and structs
-  fields. Imagine a struct named `User` with name and age fields.
-  The following would raise:
-
-      user = %User{name: "john"}
-      user[:name]
-      ** (UndefinedFunctionError) undefined function User.fetch/2
-         (User does not implement the Access behaviour)
-
-  Structs instead use the `user.name` syntax:
-
-      user.name
-      #=> "john"
-
-  The same `user.name` syntax can also be used by `Kernel.put_in/2`
-  to for updating structs fields:
-
-      put_in user.name, "mary"
-      %User{name: "mary"}
-
-  Differently from `user[:name]`, `user.name` is not extensible via
-  a behaviour and is restricted to only maps and structs.
-
-  Summing up:
-
-    * `user[:name]` is used by dynamic structures, is extensible and
-      does not raise on missing keys
-    * `user.name` is used by static structures, it is not extensible
-      and it will raise on missing keys
-
-  ## Accessors
-
-  While Elixir provides built-in syntax only for traversing dynamic
-  and static key-value structures, this module provides convenience
-  functions for traversing other structures, like tuples and lists,
-  to be used alongside `Kernel.put_in/2` in others.
-
-  For instance, given a user with a list of languages, here is how to
-  deeply traverse the map and convert all language names to uppercase:
-
-      iex> user = %{name: "john",
-      ...>          languages: [%{name: "elixir", type: :functional},
-      ...>                      %{name: "c", type: :procedural}]}
-      iex> update_in user, [:languages, Access.all(), :name], &String.upcase/1
-      %{name: "john",
-        languages: [%{name: "ELIXIR", type: :functional},
-                    %{name: "C", type: :procedural}]}
-
-  See the functions `key/1`, `key!/1`, `elem/1` and `all/0` for the current
-  accessors.
+  The key comparison must be implemented using the `===` operator.
   """
 
-  @type t :: list | map | nil
-  @type key :: any
-  @type value :: any
-
-  @callback fetch(t, key) :: {:ok, value} | :error
-  @callback get(t, key, value) :: value
-  @callback get_and_update(t, key, (value -> {value, value} | :pop)) :: {value, t}
-  @callback pop(t, key) :: {value, t}
-
-  defmacrop raise_undefined_behaviour(e, struct, top) do
-    quote do
-      stacktrace = System.stacktrace
-      e =
-        case stacktrace do
-          [unquote(top) | _] ->
-            %{unquote(e) | reason: "#{inspect unquote(struct)} does not implement the Access behaviour"}
-          _ ->
-            unquote(e)
-        end
-      reraise e, stacktrace
-    end
-  end
-
   @doc """
-  Fetches the container's value for the given key.
+  Accesses the given key in the container.
   """
-  @spec fetch(t, term) :: {:ok, term} | :error
-  def fetch(container, key)
-
-  def fetch(%{__struct__: struct} = container, key) do
-    struct.fetch(container, key)
-  rescue
-    e in UndefinedFunctionError ->
-      raise_undefined_behaviour e, struct, {^struct, :fetch, [^container, ^key], _}
-  end
-
-  def fetch(%{} = map, key) do
-    :maps.find(key, map)
-  end
-
-  def fetch(list, key) when is_list(list) and is_atom(key) do
-    case :lists.keyfind(key, 1, list) do
-      {^key, value} -> {:ok, value}
-      false -> :error
-    end
-  end
-
-  def fetch(list, key) when is_list(list) do
-    raise ArgumentError,
-      "the Access calls for keywords expect the key to be an atom, got: " <> inspect(key)
-  end
-
-  def fetch(nil, _key) do
-    :error
-  end
+  @spec get(t, term) :: t
+  def get(container, key)
 
   @doc """
-  Gets the container's value for the given key.
+  Gets a value and updates the given `key` in one pass.
+
+  The function must receive the value for the given `key`
+  (or `nil` if the key doesn't exist in `container`) and
+  the function must return a tuple containing the `get`
+  value and the new value to be stored in the `container`.
   """
-  @spec get(t, term, term) :: term
-  def get(container, key, default \\ nil) do
-    case fetch(container, key) do
-      {:ok, value} -> value
-      :error -> default
-    end
-  end
-
-  @doc """
-  Gets and updates the container's value for the given key, in a single pass.
-
-  This `fun` argument receives the value of `key` (or `nil` if `key`
-  is not present) and must return a two-element tuple: the "get" value
-  (the retrieved value, which can be operated on before being returned)
-  and the new value to be stored under `key`. The `fun` may also
-  return `:pop`, implying the current value shall be removed
-  from the map and returned.
-
-  The returned value is a tuple with the "get" value returned by
-  `fun` and a new map with the updated value under `key`.
-  """
-  @spec get_and_update(t, key, (value -> {get, value})) :: {get, t} when get: var
+  @spec get_and_update(t, term, (term -> {get, term})) :: {get, t} when get: var
   def get_and_update(container, key, fun)
+end
 
-  def get_and_update(%{__struct__: struct} = container, key, fun) do
-    struct.get_and_update(container, key, fun)
-  rescue
-    e in UndefinedFunctionError ->
-      raise_undefined_behaviour e, struct, {^struct, :get_and_update, [^container, ^key, ^fun], _}
+defimpl Access, for: List do
+  def get(dict, key) when is_atom(key) do
+    case :lists.keyfind(key, 1, dict) do
+      {^key, value} -> value
+      false -> nil
+    end
   end
 
-  def get_and_update(%{} = map, key, fun) do
-    Map.get_and_update(map, key, fun)
+  def get(_dict, key) do
+    raise ArgumentError,
+      "the access protocol for lists expect the key to be an atom, got: #{inspect key}"
   end
 
-  def get_and_update(list, key, fun) when is_list(list) do
-    Keyword.get_and_update(list, key, fun)
+  def get_and_update(dict, key, fun) when is_atom(key) do
+    get_and_update(dict, [], key, fun)
+  end
+
+  defp get_and_update([{key, value}|t], acc, key, fun) do
+    {get, update} = fun.(value)
+    {get, :lists.reverse(acc, [{key, update}|t])}
+  end
+
+  defp get_and_update([h|t], acc, key, fun) do
+    get_and_update(t, [h|acc], key, fun)
+  end
+
+  defp get_and_update([], acc, key, fun) do
+    {get, update} = fun.(nil)
+    {get, [{key, update}|:lists.reverse(acc)]}
+  end
+end
+
+defimpl Access, for: Map do
+  def get(map, key) do
+    case :maps.find(key, map) do
+      {:ok, value} -> value
+      :error -> nil
+    end
+  end
+
+  def get_and_update(map, key, fun) do
+    value =
+      case :maps.find(key, map) do
+        {:ok, value} -> value
+        :error -> nil
+      end
+
+    {get, update} = fun.(value)
+    {get, :maps.put(key, update, map)}
+  end
+
+  def get!(%{} = map, key) do
+    case :maps.find(key, map) do
+      {:ok, value} -> value
+      :error -> raise KeyError, key: key, term: map
+    end
+  end
+
+  def get!(other, key) do
+    raise ArgumentError,
+      "could not get key #{inspect key}. Expected map/struct, got: #{inspect other}"
+  end
+
+  def get_and_update!(%{} = map, key, fun) do
+    case :maps.find(key, map) do
+      {:ok, value} ->
+        {get, update} = fun.(value)
+        {get, :maps.put(key, update, map)}
+      :error ->
+        raise KeyError, key: key, term: map
+    end
+  end
+
+  def get_and_update!(other, key, _fun) do
+    raise ArgumentError,
+      "could not put/update key #{inspect key}. Expected map/struct, got: #{inspect other}"
+  end
+end
+
+defimpl Access, for: Atom do
+  def get(nil, _) do
+    nil
+  end
+
+  def get(atom, _) do
+    undefined(atom)
   end
 
   def get_and_update(nil, key, _fun) do
@@ -218,281 +137,14 @@ defmodule Access do
       "could not put/update key #{inspect key} on a nil value"
   end
 
-  def pop(%{__struct__: struct} = container, key) do
-    struct.pop(container, key)
-  rescue
-    e in UndefinedFunctionError ->
-      raise_undefined_behaviour e, struct, {^struct, :pop, [^container, ^key], _}
-  end
-  def pop(list, key) when is_list(list), do: Keyword.pop(list, key)
-  def pop(map, key) when is_map(map) do
-    case map do
-      %{^key => value} -> {value, :maps.remove(key, map)}
-      %{} -> {nil, map}
-    end
-  end
-  def pop(nil, key) do
-    raise ArgumentError,
-      "could not pop key #{inspect key} on a nil value"
+  def get_and_update(atom, _key, _fun) do
+    undefined(atom)
   end
 
-  ## Accessors
-
-  @doc """
-  Accesses the given key in a map/struct.
-
-  Uses the default value if the key does not exist
-  or if the value being accessed is `nil`.
-
-  ## Examples
-
-      iex> get_in(%{}, [Access.key(:unknown), Access.key(:name)])
-      nil
-      iex> get_in(%{}, [Access.key(:unknown, %{name: "john"}), Access.key(:name)])
-      "john"
-      iex> get_in(%{}, [Access.key(:unknown), Access.key(:name, "john")])
-      "john"
-
-      iex> map = %{user: %{name: "john"}}
-      iex> get_in(map, [Access.key(:unknown), Access.key(:name, "john")])
-      "john"
-      iex> get_and_update_in(map, [Access.key(:user), Access.key(:name)], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {"john", %{user: %{name: "JOHN"}}}
-      iex> pop_in(map, [Access.key(:user), Access.key(:name)])
-      {"john", %{user: %{}}}
-
-  An error is raised if the accessed structure is not a map/struct/nil:
-
-      iex> get_in([], [Access.key(:foo)])
-      ** (RuntimeError) Access.key/1 expected a map/struct or nil, got: []
-
-  """
-  def key(key, default \\ nil) do
-    fn
-      :get, data, next ->
-        next.(Map.get(to_map(data), key, default))
-      :get_and_update, data, next ->
-        value = Map.get(to_map(data), key, default)
-        case next.(value) do
-          {get, update} -> {get, Map.put(data, key, update)}
-          :pop -> {value, Map.delete(data, key)}
-        end
-    end
-  end
-
-  defp to_map(nil), do: %{}
-  defp to_map(%{} = map), do: map
-  defp to_map(data), do: raise "Access.key/1 expected a map/struct or nil, got: #{inspect data}"
-
-  @doc """
-  Accesses the given key in a map/struct.
-
-  Raises if the key does not exist.
-
-  ## Examples
-
-      iex> map = %{user: %{name: "john"}}
-      iex> get_in(map, [Access.key!(:user), Access.key!(:name)])
-      "john"
-      iex> get_and_update_in(map, [Access.key!(:user), Access.key!(:name)], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {"john", %{user: %{name: "JOHN"}}}
-      iex> pop_in(map, [Access.key!(:user), Access.key!(:name)])
-      {"john", %{user: %{}}}
-      iex> get_in(map, [Access.key!(:user), Access.key!(:unknown)])
-      ** (KeyError) key :unknown not found in: %{name: \"john\"}
-
-  An error is raised if the accessed structure is not a map/struct:
-
-      iex> get_in([], [Access.key!(:foo)])
-      ** (RuntimeError) Access.key!/1 expected a map/struct, got: []
-
-  """
-  def key!(key) do
-    fn
-      :get, %{} = data, next ->
-        next.(Map.fetch!(data, key))
-      :get_and_update, %{} = data, next ->
-        value = Map.fetch!(data, key)
-        case next.(value) do
-          {get, update} -> {get, Map.put(data, key, update)}
-          :pop -> {value, Map.delete(data, key)}
-        end
-      _op, data, _next ->
-        raise "Access.key!/1 expected a map/struct, got: #{inspect data}"
-    end
-  end
-
-  @doc ~S"""
-  Accesses the element at the given index in a tuple.
-
-  Raises if the index is out of bounds.
-
-  ## Examples
-
-      iex> map = %{user: {"john", 27}}
-      iex> get_in(map, [:user, Access.elem(0)])
-      "john"
-      iex> get_and_update_in(map, [:user, Access.elem(0)], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {"john", %{user: {"JOHN", 27}}}
-      iex> pop_in(map, [:user, Access.elem(0)])
-      ** (RuntimeError) cannot pop data from a tuple
-
-  An error is raised if the accessed structure is not a tuple:
-
-      iex> get_in(%{}, [Access.elem(0)])
-      ** (RuntimeError) Access.elem/1 expected a tuple, got: %{}
-
-  """
-  def elem(index) when is_integer(index) do
-    pos = index + 1
-
-    fn
-      :get, data, next when is_tuple(data) ->
-        next.(:erlang.element(pos, data))
-      :get_and_update, data, next when is_tuple(data) ->
-        value = :erlang.element(pos, data)
-        case next.(value) do
-          {get, update} -> {get, :erlang.setelement(pos, data, update)}
-          :pop -> raise "cannot pop data from a tuple"
-        end
-      _op, data, _next ->
-        raise "Access.elem/1 expected a tuple, got: #{inspect data}"
-    end
-  end
-
-  @doc ~S"""
-  Accesses all the elements in a list.
-
-  ## Examples
-
-      iex> list = [%{name: "john"}, %{name: "mary"}]
-      iex> get_in(list, [Access.all(), :name])
-      ["john", "mary"]
-      iex> get_and_update_in(list, [Access.all(), :name], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {["john", "mary"], [%{name: "JOHN"}, %{name: "MARY"}]}
-      iex> pop_in(list, [Access.all(), :name])
-      {["john", "mary"], [%{}, %{}]}
-
-  Here is an example that traverses the list dropping even
-  numbers and multipling odd numbers by 2:
-
-      iex> require Integer
-      iex> get_and_update_in([1, 2, 3, 4, 5], [Access.all], fn
-      ...>   num -> if Integer.is_even(num), do: :pop, else: {num, num * 2}
-      ...> end)
-      {[1, 2, 3, 4, 5], [2, 6, 10]}
-
-  An error is raised if the accessed structure is not a list:
-
-      iex> get_in(%{}, [Access.all()])
-      ** (RuntimeError) Access.all/0 expected a list, got: %{}
-
-  """
-  def all() do
-    &all/3
-  end
-
-  defp all(:get, data, next) when is_list(data) do
-    Enum.map(data, next)
-  end
-
-  defp all(:get_and_update, data, next) when is_list(data) do
-    all(data, next, [], [])
-  end
-
-  defp all(_op, data, _next) do
-    raise "Access.all/0 expected a list, got: #{inspect data}"
-  end
-
-  defp all([head | rest], next, gets, updates) do
-    case next.(head) do
-      {get, update} -> all(rest, next, [get | gets], [update | updates])
-      :pop -> all(rest, next, [head | gets], updates)
-    end
-  end
-
-  defp all([], _next, gets, updates) do
-    {:lists.reverse(gets), :lists.reverse(updates)}
-  end
-
-  @doc ~S"""
-  Accesses the element at `index` (zero based) of a list.
-
-  ## Examples
-
-      iex> list = [%{name: "john"}, %{name: "mary"}]
-      iex> get_in(list, [Access.at(1), :name])
-      "mary"
-      iex> get_and_update_in(list, [Access.at(0), :name], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {"john", [%{name: "JOHN"}, %{name: "mary"}]}
-
-  `at/1` can also be used to pop elements out of a list or
-  a key inside of a list:
-
-      iex> list = [%{name: "john"}, %{name: "mary"}]
-      iex> pop_in(list, [Access.at(0)])
-      {%{name: "john"}, [%{name: "mary"}]}
-      iex> pop_in(list, [Access.at(0), :name])
-      {"john", [%{}, %{name: "mary"}]}
-
-  When the index is out of bounds, `nil` is returned and the update function is never called:
-
-      iex> list = [%{name: "john"}, %{name: "mary"}]
-      iex> get_in(list, [Access.at(10), :name])
-      nil
-      iex> get_and_update_in(list, [Access.at(10), :name], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {nil, [%{name: "john"}, %{name: "mary"}]}
-
-  An error is raised for negative indexes:
-
-      iex> get_in([], [Access.at(-1)])
-      ** (FunctionClauseError) no function clause matching in Access.at/1
-
-  An error is raised if the accessed structure is not a list:
-
-      iex> get_in(%{}, [Access.at(1)])
-      ** (RuntimeError) Access.at/1 expected a list, got: %{}
-  """
-  def at(index) when index >= 0 do
-    fn(op, data, next) -> at(op, data, index, next) end
-  end
-
-  defp at(:get, data, index, next) when is_list(data) do
-    data |> Enum.at(index) |> next.()
-  end
-
-  defp at(:get_and_update, data, index, next) when is_list(data) do
-    get_and_update_at(data, index, next, [])
-  end
-
-  defp at(_op, data, _index, _next) do
-    raise "Access.at/1 expected a list, got: #{inspect data}"
-  end
-
-  defp get_and_update_at([head | rest], 0, next, updates) do
-    case next.(head) do
-      {get, update} -> {get, :lists.reverse([update | updates], rest)}
-      :pop -> {head, :lists.reverse(updates, rest)}
-    end
-  end
-
-  defp get_and_update_at([head | rest], index, next, updates) do
-    get_and_update_at(rest, index - 1, next, [head | updates])
-  end
-
-  defp get_and_update_at([], _index, _next, updates) do
-    {nil, :lists.reverse(updates)}
+  defp undefined(atom) do
+    raise Protocol.UndefinedError,
+      protocol: @protocol,
+      value: atom,
+      description: "only the nil atom is supported"
   end
 end

lib/elixir/lib/agent.ex

@@ -17,7 +17,7 @@ defmodule Agent do
 
       defmodule Mix.TasksServer do
         def start_link do
-          Agent.start_link(fn -> MapSet.new end, name: __MODULE__)
+          Agent.start_link(fn -> HashSet.new end, name: __MODULE__)
         end
 
         @doc "Checks if the task has already executed"
@@ -31,14 +31,7 @@ defmodule Agent do
         @doc "Marks a task as executed"
         def put_task(task, project) do
           item = {task, project}
-          Agent.update(__MODULE__, &MapSet.put(&1, item))
-        end
-
-        @doc "Resets the executed tasks and returns the previous list of tasks"
-        def take_all() do
-          Agent.get_and_update(__MODULE__, fn set ->
-            {Enum.into(set, []), MapSet.new}
-          end)
+          Agent.update(__MODULE__, &Set.put(&1, item))
         end
       end
 
@@ -61,11 +54,11 @@ defmodule Agent do
         Agent.get(agent, &(&1)) |> do_something_expensive()
       end
 
-  The first function blocks the agent. The second function copies
-  all the state to the client and then executes the operation in the
-  client. The difference is whether the data is large enough to require
-  processing in the server, at least initially, or small enough to be
-  sent to the client cheaply.
+  The first one blocks the agent while the second one copies
+  all the state to the client and executes the operation in the client.
+  The trade-off here is exactly if the data is small enough to be
+  sent to the client cheaply or large enough to require processing on
+  the server (or at least some initial processing).
 
   ## Name Registration
 
@@ -75,8 +68,8 @@ defmodule Agent do
   ## A word on distributed agents
 
   It is important to consider the limitations of distributed agents. Agents
-  provide two APIs, one that works with anonymous functions and another
-  that expects an explicit module, function, and arguments.
+  provides two APIs, one that works with anonymous functions and another
+  that expects explicit module, function and arguments.
 
   In a distributed setup with multiple nodes, the API that accepts anonymous
   functions only works if the caller (client) and the agent have the same
@@ -89,13 +82,13 @@ defmodule Agent do
   In this setup, part of your environment will have one version of a given
   module and the other part another version (the newer one) of the same module.
 
-  The best solution is to simply use the explicit module, function, and arguments
+  The best solution is to simply use the explicit module, function and arguments
   APIs when working with distributed agents.
 
   ## Hot code swapping
 
   An agent can have its code hot swapped live by simply passing a module,
-  function, and args tuple to the update instruction. For example, imagine
+  function and args tuple to the update instruction. For example, imagine
   you have an agent named `:sample` and you want to convert its inner state
   from some dict structure to a map. It can be done with the following
   instruction:
@@ -144,8 +137,8 @@ defmodule Agent do
   ## Return values
 
   If the server is successfully created and initialized, the function returns
-  `{:ok, pid}`, where `pid` is the pid of the server. If an agent with the
-  specified name already exists, the function returns
+  `{:ok, pid}`, where `pid` is the pid of the server. If there already exists
+  an agent with the specified name, the function returns
   `{:error, {:already_started, pid}}` with the pid of that process.
 
   If the given function callback fails with `reason`, the function returns
@@ -295,18 +288,12 @@ defmodule Agent do
   end
 
   @doc """
-  Stops the agent with the given `reason`.
+  Stops the agent.
 
-  It returns `:ok` if the server terminates with the given
-  reason, if it terminates with another reason, the call will
-  exit.
-
-  This function keeps OTP semantics regarding error reporting.
-  If the reason is any other than `:normal`, `:shutdown` or
-  `{:shutdown, _}`, an error report will be logged.
+  Returns `:ok` if the agent is stopped within the given `timeout`.
   """
-  @spec stop(agent, reason :: term, timeout) :: :ok
-  def stop(agent, reason \\ :normal, timeout \\ :infinity) do
-    :gen.stop(agent, reason, timeout)
+  @spec stop(agent, timeout) :: :ok
+  def stop(agent, timeout \\ 5000) do
+    GenServer.call(agent, :stop, timeout)
   end
 end

lib/elixir/lib/agent/server.ex

@@ -4,7 +4,6 @@ defmodule Agent.Server do
   use GenServer
 
   def init(fun) do
-    _ = initial_call(fun)
     {:ok, run(fun, [])}
   end
 
@@ -13,16 +12,18 @@ defmodule Agent.Server do
   end
 
   def handle_call({:get_and_update, fun}, _from, state) do
-    case run(fun, [state]) do
-      {reply, state} -> {:reply, reply, state}
-      other          -> {:stop, {:bad_return_value, other}, state}
-    end
+    {reply, state} = run(fun, [state])
+    {:reply, reply, state}
   end
 
   def handle_call({:update, fun}, _from, state) do
     {:reply, :ok, run(fun, [state])}
   end
 
+  def handle_call(:stop, _from, state) do
+    {:stop, :normal, :ok, state}
+  end
+
   def handle_call(msg, from, state) do
     super(msg, from, state)
   end
@@ -39,21 +40,17 @@ defmodule Agent.Server do
     {:ok, run(fun, [state])}
   end
 
-  defp initial_call(mfa) do
-    _ = Process.put(:"$initial_call", get_initial_call(mfa))
+  def terminate(_reason, _state) do
+    # There is a race condition if the agent is
+    # restarted too fast and it is registered.
+    try do
+      self |> :erlang.process_info(:registered_name) |> elem(1) |> Process.unregister
+    rescue
+      _ -> :ok
+    end
     :ok
   end
 
-  defp get_initial_call(fun) when is_function(fun, 0) do
-    {:module, module} = :erlang.fun_info(fun, :module)
-    {:name, name} = :erlang.fun_info(fun, :name)
-    {module, name, 0}
-  end
-
-  defp get_initial_call({mod, fun, args}) do
-    {mod, fun, length(args)}
-  end
-
   defp run({m, f, a}, extra), do: apply(m, f, extra ++ a)
   defp run(fun, extra), do: apply(fun, extra)
 end

lib/elixir/lib/application.ex

@@ -4,29 +4,29 @@ defmodule Application do
 
   In Elixir (actually, in Erlang/OTP), an application is a component
   implementing some specific functionality, that can be started and stopped
-  as a unit, and which can be re-used in other systems.
+  as a unit, and which can be re-used in other systems as well.
 
   Applications are defined with an application file named `APP.app` where
-  `APP` is the application name, usually in `underscore_case`. The application
-  file must reside in the same `ebin` directory as the compiled modules of the
-  application.
+  `APP` is the APP name, usually in `underscore_case` convention. The
+  application file must reside in the same `ebin` directory as the
+  application's modules bytecode.
 
   In Elixir, Mix is responsible for compiling your source code and
   generating your application `.app` file. Furthermore, Mix is also
   responsible for configuring, starting and stopping your application
   and its dependencies. For this reason, this documentation will focus
-  on the remaining aspects of your application: the application environment
+  on the remaining aspects of your application: the application environment,
   and the application callback module.
 
-  You can learn more about Mix generation of `.app` files by typing
+  You can learn more about Mix compilation of `.app` files by typing
   `mix help compile.app`.
 
   ## Application environment
 
   Once an application is started, OTP provides an application environment
-  that can be used to configure the application.
+  that can be used to configure applications.
 
-  Assuming you are inside a Mix project, you can edit the `application`
+  Assuming you are inside a Mix project, you can edit your application
   function in the `mix.exs` file to the following:
 
       def application do
@@ -38,15 +38,18 @@ defmodule Application do
   can access the default value:
 
       Application.get_env(:APP_NAME, :hello)
-      #=> :world
+      #=> {:ok, :hello}
 
   It is also possible to put and delete values from the application value,
   including new values that are not defined in the environment file (although
-  this should be avoided).
+  those should be avoided).
+
+  In the future, we plan to support configuration files which allows
+  developers to configure the environment of their dependencies.
 
   Keep in mind that each application is responsible for its environment.
-  Do not use the functions in this module for directly accessing or modifying
-  the environment of other applications (as it may lead to inconsistent
+  Do not use the functions in this module for directly access or modify
+  the environment of other application (as it may lead to inconsistent
   data in the application environment).
 
   ## Application module callback
@@ -61,8 +64,8 @@ defmodule Application do
       end
 
   Our application now requires the `MyApp` module to provide an application
-  callback. This can be done by invoking `use Application` in that module and
-  defining a `start/2` callback, for example:
+  callback. This can be done by invoking `use Application` in that module
+  and defining a `start/2` callback, for example:
 
       defmodule MyApp do
         use Application
@@ -72,83 +75,27 @@ defmodule Application do
         end
       end
 
-  `start/2` typically returns `{:ok, pid}` or `{:ok, pid, state}` where
-  `pid` identifies the supervision tree and `state` is the application state.
-  `args` is the second element of the tuple given to the `:mod` option.
+  `start/2` most commonly returns `{:ok, pid}` or `{:ok, pid, state}` where
+  `pid` identifies the supervision tree and the state is the application state.
+  `args` is second element of the tuple given to the `:mod` option.
 
-  The `type` argument passed to `start/2` is usually `:normal` unless in a
-  distributed setup where application takeovers and failovers are configured.
-  This particular aspect of applications is explained in more detail in the
-  OTP documentation:
+  The `type` passed into `start/2` is usually `:normal` unless in a distributed
+  setup where applications takeover and failovers are configured. This particular
+  aspect of applications can be read with more detail in the OTP documentation:
 
-    * [`:application` module](http://www.erlang.org/doc/man/application.html)
-    * [Applications – OTP Design Principles](http://www.erlang.org/doc/design_principles/applications.html)
+    * http://www.erlang.org/doc/man/application.html
+    * http://www.erlang.org/doc/design_principles/applications.html
 
   A developer may also implement the `stop/1` callback (automatically defined
   by `use Application`) which does any application cleanup. It receives the
-  application state and can return any value. Note that shutting down the
-  supervisor is automatically handled by the VM.
+  application state and can return any value. Notice that shutting down the
+  supervisor is automatically handled by the VM;
   """
 
-  @doc """
-  Called when an application is started.
-
-  This function is called when an the application is started using
-  `Application.start/2` (and functions on top of that, such as
-  `Application.ensure_started/2`). This function should start the top-level
-  process of the application (which should be the top supervisor of the
-  application's supervision tree if the application follows the OTP design
-  principles around supervision).
-
-  `start_type` defines how the application is started:
-
-    * `:normal` - used if the startup is a normal startup or if the application
-      is distributed and is started on the current node because of a failover
-      from another mode and the application specification key `:start_phases`
-      is `:undefined`.
-    * `{:takeover, node}` - used if the application is distributed and is
-      started on the current node because of a failover on the node `node`.
-    * `{:failover, node}` - used if the application is distributed and is
-      started on the current node because of a failover on node `node`, and the
-      application specification key `:start_phases` is not `:undefined`.
-
-  `start_args` are the arguments passed to the application in the `:mod`
-  specification key (e.g., `mod: {MyApp, [:my_args]}`).
-
-  This function should either return `{:ok, pid}` or `{:ok, pid, state}` if
-  startup is successful. `pid` should be the pid of the top supervisor. `state`
-  can be an arbitrary term, and if omitted will default to `[]`; if the
-  application is later stopped, `state` is passed to the `stop/1` callback (see
-  the documentation for the `stop/2` callback for more information).
-
-  `use Application` provides no default implementation for the `start/2`
-  callback.
-  """
-  @callback start(start_type, start_args :: term) ::
-    {:ok, pid} |
-    {:ok, pid, state} |
-    {:error, reason :: term}
-
-  @doc """
-  Called when an application is stopped.
-
-  This function is called when an application has stopped, i.e., when its
-  supervision tree has been stopped. It should do the opposite of what the
-  `start/2` callback did, and should perform any necessary cleanup. The return
-  value of this callback is ignored.
-
-  `state` is the return value of the `start/2` callback or the return value of
-  the `prep_stop/1` function if the application module defines such a function.
-
-  `use Application` defines a default implementation of this function which does
-  nothing and just returns `:ok`.
-  """
-  @callback stop(state) :: term
-
   @doc false
   defmacro __using__(_) do
     quote location: :keep do
-      @behaviour Application
+      @behaviour :application
 
       @doc false
       def stop(_state) do
@@ -162,64 +109,12 @@ defmodule Application do
   @type app :: atom
   @type key :: atom
   @type value :: term
-  @type state :: term
   @type start_type :: :permanent | :transient | :temporary
 
-  @application_keys [:description, :id, :vsn, :modules, :maxP, :maxT, :registered,
-                     :included_applications, :applications, :mod, :start_phases]
-
-  @doc """
-  Returns the spec for `app`.
-
-  The following keys are returned:
-
-    * #{Enum.map_join @application_keys, "\n  * ", &inspect/1}
-
-  Note the environment is not returned as it can be accessed via
-  `fetch_env/2`. Returns `nil` if the application is not loaded.
-  """
-  @spec spec(app) :: [{key, value}] | nil
-  def spec(app) do
-    case :application.get_all_key(app) do
-      {:ok, info} -> :lists.keydelete(:env, 1, info)
-      :undefined  -> nil
-    end
-  end
-
-  @doc """
-  Returns the value for `key` in `app`'s specification.
-
-  See `spec/1` for the supported keys. If the given
-  specification parameter does not exist, this function
-  will raise. Returns `nil` if the application is not loaded.
-  """
-  @spec spec(app, key) :: value | nil
-  def spec(app, key) when key in @application_keys do
-    case :application.get_key(app, key) do
-      {:ok, value} -> value
-      :undefined -> nil
-    end
-  end
-
-  @doc """
-  Gets the application for the given module.
-
-  The application is located by analyzing the spec
-  of all loaded applications. Returns `nil` if
-  the module is not listed in any application spec.
-  """
-  @spec get_application(atom) :: atom | nil
-  def get_application(module) when is_atom(module) do
-    case :application.get_application(module) do
-      {:ok, app} -> app
-      :undefined -> nil
-    end
-  end
-
   @doc """
   Returns all key-value pairs for `app`.
   """
-  @spec get_all_env(app) :: [{key, value}]
+  @spec get_all_env(app) :: [{key,value}]
   def get_all_env(app) do
     :application.get_all_env(app)
   end
@@ -227,18 +122,22 @@ defmodule Application do
   @doc """
   Returns the value for `key` in `app`'s environment.
 
-  If the configuration parameter does not exist, the function returns the
-  `default` value.
+  If the specified application is not loaded, or the configuration parameter
+  does not exist, the function returns the `default` value.
   """
   @spec get_env(app, key, value) :: value
   def get_env(app, key, default \\ nil) do
-    :application.get_env(app, key, default)
+    case :application.get_env(app, key) do
+      {:ok, value} -> value
+      :undefined -> default
+    end
   end
 
   @doc """
   Returns the value for `key` in `app`'s environment in a tuple.
 
-  If the configuration parameter does not exist, the function returns `:error`.
+  If the specified application is not loaded, or the configuration parameter
+  does not exist, the function returns `:error`.
   """
   @spec fetch_env(app, key) :: {:ok, value} | :error
   def fetch_env(app, key) do
@@ -248,22 +147,6 @@ defmodule Application do
     end
   end
 
-  @doc """
-  Returns the value for `key` in `app`'s environment.
-
-  If the configuration parameter does not exist, raises `ArgumentError`.
-  """
-  @spec fetch_env!(app, key) :: value | no_return
-  def fetch_env!(app, key) do
-    case fetch_env(app, key) do
-      {:ok, value} -> value
-      :error ->
-        raise ArgumentError,
-          "application #{inspect app} is not loaded, " <>
-          "or the configuration parameter #{inspect key} is not set"
-    end
-  end
-
   @doc """
   Puts the `value` in `key` for the given `app`.
 
@@ -276,7 +159,7 @@ defmodule Application do
   environment values specified in the `.app` file will override the ones
   previously set.
 
-  The persistent option can be set to `true` when there is a need to guarantee
+  The persistent option can be set to true when there is a need to guarantee
   parameters set with this function will not be overridden by the ones defined
   in the application resource file on load. This means persistent values will
   stick after the application is loaded and also on application reload.
@@ -432,29 +315,10 @@ defmodule Application do
   @doc """
   Returns the given path inside `app_dir/1`.
   """
-  @spec app_dir(app, String.t | [String.t]) :: String.t
+  @spec app_dir(app, String.t) :: String.t
   def app_dir(app, path) when is_binary(path) do
     Path.join(app_dir(app), path)
   end
-  def app_dir(app, path) when is_list(path) do
-    Path.join([app_dir(app) | path])
-  end
-
-  @doc """
-  Returns a list with information about the applications which are currently running.
-  """
-  @spec started_applications(timeout) :: [tuple]
-  def started_applications(timeout \\ 5000) do
-    :application.which_applications(timeout)
-  end
-
-  @doc """
-  Returns a list with information about the applications which have been loaded.
-  """
-  @spec loaded_applications :: [tuple]
-  def loaded_applications do
-    :application.loaded_applications
-  end
 
   @doc """
   Formats the error reason returned by `start/2`,
@@ -464,7 +328,7 @@ defmodule Application do
   @spec format_error(any) :: String.t
   def format_error(reason) do
     try do
-      do_format_error(reason)
+      impl_format_error(reason)
     catch
       # A user could create an error that looks like a builtin one
       # causing an error.
@@ -474,68 +338,68 @@ defmodule Application do
   end
 
   # exit(:normal) call is special cased, undo the special case.
-  defp do_format_error({{:EXIT, :normal}, {mod, :start, args}}) do
+  defp impl_format_error({{:EXIT, :normal}, {mod, :start, args}}) do
     Exception.format_exit({:normal, {mod, :start, args}})
   end
 
   # {:error, reason} return value
-  defp do_format_error({reason, {mod, :start, args}}) do
+  defp impl_format_error({reason, {mod, :start, args}}) do
     Exception.format_mfa(mod, :start, args) <> " returned an error: " <>
       Exception.format_exit(reason)
   end
 
   # error or exit(reason) call, use exit reason as reason.
-  defp do_format_error({:bad_return, {{mod, :start, args}, {:EXIT, reason}}}) do
+  defp impl_format_error({:bad_return, {{mod, :start, args}, {:EXIT, reason}}}) do
     Exception.format_exit({reason, {mod, :start, args}})
   end
 
   # bad return value
-  defp do_format_error({:bad_return, {{mod, :start, args}, return}}) do
+  defp impl_format_error({:bad_return, {{mod, :start, args}, return}}) do
     Exception.format_mfa(mod, :start, args) <>
       " returned a bad value: " <> inspect(return)
   end
 
-  defp do_format_error({:already_started, app}) when is_atom(app) do
+  defp impl_format_error({:already_started, app}) when is_atom(app) do
     "already started application #{app}"
   end
 
-  defp do_format_error({:not_started, app}) when is_atom(app) do
+  defp impl_format_error({:not_started, app}) when is_atom(app) do
     "not started application #{app}"
   end
 
-  defp do_format_error({:bad_application, app}) do
+  defp impl_format_error({:bad_application, app}) do
     "bad application: #{inspect(app)}"
   end
 
-  defp do_format_error({:already_loaded, app}) when is_atom(app) do
+  defp impl_format_error({:already_loaded, app}) when is_atom(app) do
     "already loaded application #{app}"
   end
 
-  defp do_format_error({:not_loaded, app}) when is_atom(app) do
+  defp impl_format_error({:not_loaded, app}) when is_atom(app) do
     "not loaded application #{app}"
   end
 
-  defp do_format_error({:invalid_restart_type, restart}) do
+  defp impl_format_error({:invalid_restart_type, restart}) do
     "invalid application restart type: #{inspect(restart)}"
   end
 
-  defp do_format_error({:invalid_name, name}) do
+  defp impl_format_error({:invalid_name, name}) do
     "invalid application name: #{inspect(name)}"
   end
 
-  defp do_format_error({:invalid_options, opts}) do
+  defp impl_format_error({:invalid_options, opts}) do
     "invalid application options: #{inspect(opts)}"
   end
 
-  defp do_format_error({:badstartspec, spec}) do
+  defp impl_format_error({:badstartspec, spec}) do
     "bad application start specs: #{inspect(spec)}"
   end
 
-  defp do_format_error({'no such file or directory', file}) do
+  defp impl_format_error({'no such file or directory', file}) do
     "could not find application file: #{file}"
   end
 
-  defp do_format_error(reason) do
+  defp impl_format_error(reason) do
     Exception.format_exit(reason)
   end
 end

lib/elixir/lib/atom.ex

@@ -1,20 +1,12 @@
 defmodule Atom do
-  @moduledoc """
+  @doc """
   Convenience functions for working with atoms.
-
-  See also `Kernel.is_atom/1`.
   """
 
   @doc """
-  Converts an atom to a string.
+  Converts an atom to string.
 
   Inlined by the compiler.
-
-  ## Examples
-
-      iex> Atom.to_string(:foo)
-      "foo"
-
   """
   @spec to_string(atom) :: String.t
   def to_string(atom) do
@@ -22,23 +14,12 @@ defmodule Atom do
   end
 
   @doc """
-  Converts an atom to a charlist.
+  Converts an atom to a char list.
 
   Inlined by the compiler.
-
-  ## Examples
-
-      iex> Atom.to_charlist(:"An atom")
-      'An atom'
-
   """
-  @spec to_charlist(atom) :: charlist
-  def to_charlist(atom) do
+  @spec to_char_list(atom) :: char_list
+  def to_char_list(atom) do
     :erlang.atom_to_list(atom)
   end
-
-  # TODO: Deprecate by v1.5
-  @doc false
-  @spec to_char_list(atom) :: charlist
-  def to_char_list(atom), do: Atom.to_charlist(atom)
 end

lib/elixir/lib/base.ex

@@ -98,68 +98,54 @@ defmodule Base do
   b32_alphabet    = Enum.with_index 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'
   b32hex_alphabet = Enum.with_index '0123456789ABCDEFGHIJKLMNOPQRSTUV'
 
-  Enum.each [{:enc16,    :dec16,    b16_alphabet},
-             {:enc32,    :dec32,    b32_alphabet},
-             {:enc64,    :dec64,    b64_alphabet},
-             {:enc64url, :dec64url, b64url_alphabet},
-             {:enc32hex, :dec32hex, b32hex_alphabet}], fn({enc, dec, alphabet}) ->
+  Enum.each [ {:enc16,    :dec16,    b16_alphabet},
+              {:enc64,    :dec64,    b64_alphabet},
+              {:enc32,    :dec32,    b32_alphabet},
+              {:enc64url, :dec64url, b64url_alphabet},
+              {:enc32hex, :dec32hex, b32hex_alphabet} ], fn({enc, dec, alphabet}) ->
     for {encoding, value} <- alphabet do
       defp unquote(enc)(unquote(value)), do: unquote(encoding)
       defp unquote(dec)(unquote(encoding)), do: unquote(value)
     end
     defp unquote(dec)(c) do
-      raise ArgumentError, "non-alphabet digit found: #{inspect <<c>>, binaries: :as_strings} (byte #{c})"
+      raise ArgumentError, "non-alphabet digit found: #{<<c>>}"
     end
   end
 
-  @compile {:inline, from_upper: 1, from_lower: 1, from_mixed: 1,
-                     to_lower: 1, to_upper: 1, enc16: 1, dec16: 1,
-                     enc32: 1, dec32: 1, enc32hex: 1, dec32hex: 1,
-                     enc64: 1, dec64: 1, enc64url: 1, dec64url: 1}
+  defp encode_case(:upper, func),
+    do: func
+  defp encode_case(:lower, func),
+    do: &to_lower(func.(&1))
+
+  defp decode_case(:upper, func),
+    do: func
+  defp decode_case(:lower, func),
+    do: &func.(from_lower(&1))
+  defp decode_case(:mixed, func),
+    do: &func.(from_mixed(&1))
 
   defp to_lower(char) when char in ?A..?Z,
     do: char + (?a - ?A)
   defp to_lower(char),
     do: char
 
-  defp to_upper(char), do: char
-
-  defp from_upper(char), do: char
-
   defp from_lower(char) when char in ?a..?z,
     do: char - (?a - ?A)
   defp from_lower(char) when not char in ?A..?Z,
     do: char
   defp from_lower(char),
-    do: raise(ArgumentError, "non-alphabet digit found: \"#{<<char>>}\" (byte #{char})")
+    do: raise(ArgumentError, "non-alphabet digit found: #{<<char>>}")
 
   defp from_mixed(char) when char in ?a..?z,
     do: char - (?a - ?A)
   defp from_mixed(char),
     do: char
 
-  defp maybe_pad(subject, false, _, _),
-    do: subject
-  defp maybe_pad(subject, _, group_size, pad) do
-    case rem(byte_size(subject), group_size) do
-      0 -> subject
-      x -> subject <> String.duplicate(pad, group_size - x)
-    end
-  end
-
   @doc """
   Encodes a binary string into a base 16 encoded string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to use when encoding
-
-  The values for `:case` can be:
-
-    * `:upper` - use upper case characters (default)
-    * `:lower` - use lower case characters
+  Accepts an atom `:upper` (default) for encoding to upper case characters or
+  `:lower` for lower case characters.
 
   ## Examples
 
@@ -174,23 +160,16 @@ defmodule Base do
   @spec encode16(binary, Keyword.t) :: binary
   def encode16(data, opts \\ []) when is_binary(data) do
     case = Keyword.get(opts, :case, :upper)
-    do_encode16(case, data)
+    do_encode16(data, encode_case(case, &enc16/1))
   end
 
+
   @doc """
   Decodes a base 16 encoded string into a binary string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to accept when decoding
-
-  The values for `:case` can be:
-
-    * `:upper` - only allow upper case characters (default)
-    * `:lower` - only allow lower case characters
-    * `:mixed` - allow mixed case characters
+  Accepts an atom `:upper` (default) for decoding from upper case characters or
+  `:lower` for lower case characters. `:mixed` can be given for mixed case
+  characters.
 
   ## Examples
 
@@ -206,8 +185,9 @@ defmodule Base do
   """
   @spec decode16(binary) :: {:ok, binary} | :error
   @spec decode16(binary, Keyword.t) :: {:ok, binary} | :error
-  def decode16(string, opts \\ []) do
-    {:ok, decode16!(string, opts)}
+  def decode16(string, opts \\ []) when is_binary(string) do
+    case = Keyword.get(opts, :case, :upper)
+    {:ok, do_decode16(string, decode_case(case, &dec16/1))}
   rescue
     ArgumentError -> :error
   end
@@ -215,17 +195,9 @@ defmodule Base do
   @doc """
   Decodes a base 16 encoded string into a binary string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to accept when decoding
-
-  The values for `:case` can be:
-
-    * `:upper` - only allow upper case characters (default)
-    * `:lower` - only allow lower case characters
-    * `:mixed` - allow mixed case characters
+  Accepts an atom `:upper` (default) for decoding from upper case characters or
+  `:lower` for lower case characters. `:mixed` can be given for mixed case
+  characters.
 
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
@@ -244,70 +216,37 @@ defmodule Base do
   """
   @spec decode16!(binary) :: binary
   @spec decode16!(binary, Keyword.t) :: binary
-  def decode16!(string, opts \\ [])
-
-  def decode16!(string, opts) when is_binary(string) and rem(byte_size(string), 2) == 0 do
+  def decode16!(string, opts \\ []) when is_binary(string) do
     case = Keyword.get(opts, :case, :upper)
-    do_decode16(case, string)
-  end
-
-  def decode16!(string, _opts) when is_binary(string) do
-    raise ArgumentError, "odd-length string"
+    do_decode16(string, decode_case(case, &dec16/1))
   end
 
   @doc """
   Encodes a binary string into a base 64 encoded string.
 
-  Accepts `padding: false` option which will omit padding from
-  the output string.
-
   ## Examples
 
       iex> Base.encode64("foobar")
       "Zm9vYmFy"
 
-      iex> Base.encode64("foob")
-      "Zm9vYg=="
-
-      iex> Base.encode64("foob", padding: false)
-      "Zm9vYg"
-
   """
   @spec encode64(binary) :: binary
-  @spec encode64(binary, Keyword.t) :: binary
-  def encode64(data, opts \\ []) when is_binary(data) do
-    pad? = Keyword.get(opts, :padding, true)
-    do_encode64(data, pad?)
+  def encode64(data) when is_binary(data) do
+    do_encode64(data, &enc64/1)
   end
 
   @doc """
   Decodes a base 64 encoded string into a binary string.
 
-  Accepts `ignore: :whitespace` option which will ignore all the
-  whitespace characters in the input string.
-
-  Accepts `padding: false` option which will ignore padding from
-  the input string.
-
   ## Examples
 
       iex> Base.decode64("Zm9vYmFy")
       {:ok, "foobar"}
 
-      iex> Base.decode64("Zm9vYmFy\\n", ignore: :whitespace)
-      {:ok, "foobar"}
-
-      iex> Base.decode64("Zm9vYg==")
-      {:ok, "foob"}
-
-      iex> Base.decode64("Zm9vYg", padding: false)
-      {:ok, "foob"}
-
   """
   @spec decode64(binary) :: {:ok, binary} | :error
-  @spec decode64(binary, Keyword.t) :: {:ok, binary} | :error
-  def decode64(string, opts \\ []) when is_binary(string) do
-    {:ok, decode64!(string, opts)}
+  def decode64(string) when is_binary(string) do
+    {:ok, do_decode64(string, &dec64/1)}
   rescue
     ArgumentError -> :error
   end
@@ -315,11 +254,7 @@ defmodule Base do
   @doc """
   Decodes a base 64 encoded string into a binary string.
 
-  Accepts `ignore: :whitespace` option which will ignore all the
-  whitespace characters in the input string.
-
-  Accepts `padding: false` option which will ignore padding from
-  the input string.
+  The following alphabet is used both for encoding and decoding:
 
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
@@ -329,72 +264,40 @@ defmodule Base do
       iex> Base.decode64!("Zm9vYmFy")
       "foobar"
 
-      iex> Base.decode64!("Zm9vYmFy\\n", ignore: :whitespace)
-      "foobar"
-
-      iex> Base.decode64!("Zm9vYg==")
-      "foob"
-
-      iex> Base.decode64!("Zm9vYg", padding: false)
-      "foob"
-
   """
   @spec decode64!(binary) :: binary
-  @spec decode64!(binary, Keyword.t) :: binary
-  def decode64!(string, opts \\ []) when is_binary(string) do
-    pad? = Keyword.get(opts, :padding, true)
-    string |> remove_ignored(opts[:ignore]) |> do_decode64(pad?)
+  def decode64!(string) when is_binary(string) do
+    do_decode64(string, &dec64/1)
   end
 
   @doc """
   Encodes a binary string into a base 64 encoded string with URL and filename
   safe alphabet.
 
-  Accepts `padding: false` option which will omit padding from
-  the output string.
-
   ## Examples
 
-      iex> Base.url_encode64(<<255, 127, 254, 252>>)
+      iex> Base.url_encode64(<<255,127,254,252>>)
       "_3_-_A=="
 
-      iex> Base.url_encode64(<<255, 127, 254, 252>>, padding: false)
-      "_3_-_A"
-
   """
   @spec url_encode64(binary) :: binary
-  @spec url_encode64(binary, Keyword.t) :: binary
-  def url_encode64(data, opts \\ []) when is_binary(data) do
-    pad? = Keyword.get(opts, :padding, true)
-    do_encode64url(data, pad?)
+  def url_encode64(data) when is_binary(data) do
+    do_encode64(data, &enc64url/1)
   end
 
   @doc """
   Decodes a base 64 encoded string with URL and filename safe alphabet
   into a binary string.
 
-  Accepts `ignore: :whitespace` option which will ignore all the
-  whitespace characters in the input string.
-
-  Accepts `padding: false` option which will ignore padding from
-  the input string.
-
   ## Examples
 
       iex> Base.url_decode64("_3_-_A==")
-      {:ok, <<255, 127, 254, 252>>}
-
-      iex> Base.url_decode64("_3_-_A==\\n", ignore: :whitespace)
-      {:ok, <<255, 127, 254, 252>>}
-
-      iex> Base.url_decode64("_3_-_A", padding: false)
-      {:ok, <<255, 127, 254, 252>>}
+      {:ok, <<255,127,254,252>>}
 
   """
   @spec url_decode64(binary) :: {:ok, binary} | :error
-  @spec url_decode64(binary, Keyword.t) :: {:ok, binary} | :error
-  def url_decode64(string, opts \\ []) when is_binary(string) do
-    {:ok, url_decode64!(string, opts)}
+  def url_decode64(string) when is_binary(string) do
+    {:ok, do_decode64(string, &dec64url/1)}
   rescue
     ArgumentError -> :error
   end
@@ -403,53 +306,25 @@ defmodule Base do
   Decodes a base 64 encoded string with URL and filename safe alphabet
   into a binary string.
 
-  Accepts `ignore: :whitespace` option which will ignore all the
-  whitespace characters in the input string.
-
-  Accepts `padding: false` option which will ignore padding from
-  the input string.
-
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
 
   ## Examples
 
       iex> Base.url_decode64!("_3_-_A==")
-      <<255, 127, 254, 252>>
-
-      iex> Base.url_decode64!("_3_-_A==\\n", ignore: :whitespace)
-      <<255, 127, 254, 252>>
-
-      iex> Base.url_decode64!("_3_-_A", padding: false)
-      <<255, 127, 254, 252>>
+      <<255,127,254,252>>
 
   """
   @spec url_decode64!(binary) :: binary
-  @spec url_decode64!(binary, Keyword.t) :: binary
-  def url_decode64!(string, opts \\ []) when is_binary(string)  do
-    pad? = Keyword.get(opts, :padding, true)
-    string |> remove_ignored(opts[:ignore]) |> do_decode64url(pad?)
+  def url_decode64!(string) when is_binary(string) do
+    do_decode64(string, &dec64url/1)
   end
 
   @doc """
   Encodes a binary string into a base 32 encoded string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to use when encoding
-    * `:padding` - specifies whether to apply padding
-
-  The values for `:case` can be:
-
-    * `:upper` - use upper case characters (default)
-    * `:lower` - use lower case characters
-
-  The values for `:padding` can be:
-
-    * `true` - pad the output string to the nearest multiple of 8 (default)
-    * `false` - omit padding from the output string
+  Accepts an atom `:upper` (default) for encoding to upper case characters or
+  `:lower` for lower case characters.
 
   ## Examples
 
@@ -459,38 +334,20 @@ defmodule Base do
       iex> Base.encode32("foobar", case: :lower)
       "mzxw6ytboi======"
 
-      iex> Base.encode32("foobar", padding: false)
-      "MZXW6YTBOI"
-
   """
   @spec encode32(binary) :: binary
   @spec encode32(binary, Keyword.t) :: binary
   def encode32(data, opts \\ []) when is_binary(data) do
     case = Keyword.get(opts, :case, :upper)
-    pad? = Keyword.get(opts, :padding, true)
-    do_encode32(case, data, pad?)
+    do_encode32(data, encode_case(case, &enc32/1))
   end
 
   @doc """
   Decodes a base 32 encoded string into a binary string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to accept when decoding
-    * `:padding` - specifies whether to require padding
-
-  The values for `:case` can be:
-
-    * `:upper` - only allow  upper case characters (default)
-    * `:lower` - only allow lower case characters
-    * `:mixed` - allow mixed case characters
-
-  The values for `:padding` can be:
-
-    * `true` - require the input string to be padded to the nearest multiple of 8 (default)
-    * `false` - ignore padding from the input string
+  Accepts an atom `:upper` (default) for decoding from upper case characters or
+  `:lower` for lower case characters. `:mixed` can be given for mixed case
+  characters.
 
   ## Examples
 
@@ -503,14 +360,12 @@ defmodule Base do
       iex> Base.decode32("mzXW6ytBOi======", case: :mixed)
       {:ok, "foobar"}
 
-      iex> Base.decode32("MZXW6YTBOI", padding: false)
-      {:ok, "foobar"}
-
   """
   @spec decode32(binary) :: {:ok, binary} | :error
   @spec decode32(binary, Keyword.t) :: {:ok, binary} | :error
   def decode32(string, opts \\ []) do
-    {:ok, decode32!(string, opts)}
+    case = Keyword.get(opts, :case, :upper)
+    {:ok, do_decode32(string, decode_case(case, &dec32/1))}
   rescue
     ArgumentError -> :error
   end
@@ -518,27 +373,13 @@ defmodule Base do
   @doc """
   Decodes a base 32 encoded string into a binary string.
 
+  Accepts an atom `:upper` (default) for decoding from upper case characters or
+  `:lower` for lower case characters. `:mixed` can be given for mixed case
+  characters.
+
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to accept when decoding
-    * `:padding` - specifies whether to require padding
-
-  The values for `:case` can be:
-
-    * `:upper` - only allow upper case characters (default)
-    * `:lower` - only allow lower case characters
-    * `:mixed` - allow mixed case characters
-
-  The values for `:padding` can be:
-
-    * `true` - require the input string to be padded to the nearest multiple of 8 (default)
-    * `false` - ignore padding from the input string
-
   ## Examples
 
       iex> Base.decode32!("MZXW6YTBOI======")
@@ -550,38 +391,20 @@ defmodule Base do
       iex> Base.decode32!("mzXW6ytBOi======", case: :mixed)
       "foobar"
 
-      iex> Base.decode32!("MZXW6YTBOI", padding: false)
-      "foobar"
-
   """
   @spec decode32!(binary) :: binary
   @spec decode32!(binary, Keyword.t) :: binary
-  def decode32!(string, opts \\ []) when is_binary(string) do
+  def decode32!(string, opts \\ []) do
     case = Keyword.get(opts, :case, :upper)
-    pad? = Keyword.get(opts, :padding, true)
-    do_decode32(case, string, pad?)
+    do_decode32(string, decode_case(case, &dec32/1))
   end
 
   @doc """
   Encodes a binary string into a base 32 encoded string with an
   extended hexadecimal alphabet.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to use when encoding
-    * `:padding` - specifies whether to apply padding
-
-  The values for `:case` can be:
-
-    * `:upper` - use upper case characters (default)
-    * `:lower` - use lower case characters
-
-  The values for `:padding` can be:
-
-    * `true` - pad the output string to the nearest multiple of 8 (default)
-    * `false` - omit padding from the output string
+  Accepts an atom `:upper` (default) for encoding to upper case characters or
+  `:lower` for lower case characters.
 
   ## Examples
 
@@ -591,39 +414,21 @@ defmodule Base do
       iex> Base.hex_encode32("foobar", case: :lower)
       "cpnmuoj1e8======"
 
-      iex> Base.hex_encode32("foobar", padding: false)
-      "CPNMUOJ1E8"
-
   """
   @spec hex_encode32(binary) :: binary
   @spec hex_encode32(binary, Keyword.t) :: binary
   def hex_encode32(data, opts \\ []) when is_binary(data) do
     case = Keyword.get(opts, :case, :upper)
-    pad? = Keyword.get(opts, :padding, true)
-    do_hex_encode32(case, data, pad?)
+    do_encode32(data, encode_case(case, &enc32hex/1))
   end
 
   @doc """
   Decodes a base 32 encoded string with extended hexadecimal alphabet
   into a binary string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to accept when decoding
-    * `:padding` - specifies whether to require padding
-
-  The values for `:case` can be:
-
-    * `:upper` - only allow upper case characters (default)
-    * `:lower` - only allow lower case characters
-    * `:mixed` - allow mixed case characters
-
-  The values for `:padding` can be:
-
-    * `true` - require the input string to be padded to the nearest multiple of 8 (default)
-    * `false` - ignore padding from the input string
+  Accepts an atom `:upper` (default) for decoding from upper case characters or
+  `:lower` for lower case characters. `:mixed` can be given for mixed case
+  characters.
 
   ## Examples
 
@@ -636,14 +441,12 @@ defmodule Base do
       iex> Base.hex_decode32("cpnMuOJ1E8======", case: :mixed)
       {:ok, "foobar"}
 
-      iex> Base.hex_decode32("CPNMUOJ1E8", padding: false)
-      {:ok, "foobar"}
-
   """
   @spec hex_decode32(binary) :: {:ok, binary} | :error
   @spec hex_decode32(binary, Keyword.t) :: {:ok, binary} | :error
-  def hex_decode32(string, opts \\ []) do
-    {:ok, hex_decode32!(string, opts)}
+  def hex_decode32(string, opts \\ []) when is_binary(string) do
+    case = Keyword.get(opts, :case, :upper)
+    {:ok, do_decode32(string, decode_case(case, &dec32hex/1))}
   rescue
     ArgumentError -> :error
   end
@@ -652,27 +455,13 @@ defmodule Base do
   Decodes a base 32 encoded string with extended hexadecimal alphabet
   into a binary string.
 
+  Accepts an atom `:upper` (default) for decoding from upper case characters or
+  `:lower` for lower case characters. `:mixed` can be given for mixed case
+  characters.
+
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to accept when decoding
-    * `:padding` - specifies whether to require padding
-
-  The values for `:case` can be:
-
-    * `:upper` - only allow upper case characters (default)
-    * `:lower` - only allow lower case characters
-    * `:mixed` - allow mixed case characters
-
-  The values for `:padding` can be:
-
-    * `true` - require the input string to be padded to the nearest multiple of 8 (default)
-    * `false` - ignore padding from the input string
-
   ## Examples
 
       iex> Base.hex_decode32!("CPNMUOJ1E8======")
@@ -684,261 +473,120 @@ defmodule Base do
       iex> Base.hex_decode32!("cpnMuOJ1E8======", case: :mixed)
       "foobar"
 
-      iex> Base.hex_decode32!("CPNMUOJ1E8", padding: false)
-      "foobar"
-
   """
   @spec hex_decode32!(binary) :: binary
   @spec hex_decode32!(binary, Keyword.t) :: binary
   def hex_decode32!(string, opts \\ []) when is_binary(string) do
     case = Keyword.get(opts, :case, :upper)
-    pad? = Keyword.get(opts, :padding, true)
-    do_hex_decode32(case, string, pad?)
+    do_decode32(string, decode_case(case, &dec32hex/1))
   end
 
-  defp remove_ignored(string, nil), do: string
-  defp remove_ignored(string, :whitespace) do
-    for <<c::8 <- string>>, not c in '\s\t\r\n', into: <<>>, do: <<c::8>>
+  defp do_encode16(<<>>, _), do: <<>>
+  defp do_encode16(data, enc) do
+    for <<c::4 <- data>>, into: <<>>, do: <<enc.(c)::8>>
   end
 
-  defp do_encode16(_, <<>>), do: <<>>
-  defp do_encode16(:upper, data) do
-    for <<c::4 <- data>>, into: <<>>, do: <<enc16(c)::8>>
-  end
-  defp do_encode16(:lower, data) do
-    for <<c::4 <- data>>, into: <<>>, do: <<to_lower(enc16(c))::8>>
-  end
-
-  defp do_decode16(_, <<>>), do: <<>>
-  defp do_decode16(:upper, string) when rem(byte_size(string), 2) == 0 do
-    for <<c1::8, c2::8 <- string>>, into: <<>> do
-      <<dec16(c1)::4, dec16(c2)::4>>
+  defp do_decode16(<<>>, _), do: <<>>
+  defp do_decode16(string, dec) when rem(byte_size(string), 2) == 0 do
+    for <<c1::8, c2::8 <- string>>, into: <<>>  do
+      <<dec.(c1)::4, dec.(c2)::4>>
     end
   end
-  defp do_decode16(:lower, string) when rem(byte_size(string), 2) == 0 do
-    for <<c1::8, c2::8 <- string>>, into: <<>> do
-      <<dec16(from_lower(c1))::4, dec16(from_lower(c2))::4>>
-    end
-  end
-  defp do_decode16(:mixed, string) when rem(byte_size(string), 2) == 0 do
-    for <<c1::8, c2::8 <- string>>, into: <<>> do
-      <<dec16(from_mixed(c1))::4, dec16(from_mixed(c2))::4>>
-    end
+  defp do_decode16(_, _) do
+    raise ArgumentError, "odd-length string"
   end
 
   defp do_encode64(<<>>, _), do: <<>>
-  defp do_encode64(data, pad?) do
+  defp do_encode64(data, enc) do
     split =  3 * div(byte_size(data), 3)
     <<main::size(split)-binary, rest::binary>> = data
-    main = for <<c::6 <- main>>, into: <<>>, do: <<enc64(c)::8>>
-    tail = case rest do
+    main = for <<c::6 <- main>>, into: <<>>, do: <<enc.(c)::8>>
+    case rest do
       <<c1::6, c2::6, c3::4>> ->
-        <<enc64(c1)::8, enc64(c2)::8, enc64(bsl(c3, 2))::8>>
+        <<main::binary, enc.(c1)::8, enc.(c2)::8, enc.(bsl(c3, 2))::8, ?=>>
       <<c1::6, c2::2>> ->
-        <<enc64(c1)::8, enc64(bsl(c2, 4))::8>>
+        <<main::binary, enc.(c1)::8, enc.(bsl(c2, 4))::8, ?=, ?=>>
       <<>> ->
-        <<>>
+        main
     end
-    main <> maybe_pad(tail, pad?, 4, "=")
   end
 
   defp do_decode64(<<>>, _), do: <<>>
-  defp do_decode64(string, false) do
-    maybe_pad(string, true, 4, "=") |> do_decode64(true)
-  end
-  defp do_decode64(string, _pad?) when rem(byte_size(string), 4) == 0 do
+  defp do_decode64(string, dec) when rem(byte_size(string), 4) == 0 do
     split = byte_size(string) - 4
     <<main::size(split)-binary, rest::binary>> = string
-    main = for <<c::8 <- main>>, into: <<>>, do: <<dec64(c)::6>>
-    tail = case rest do
+    main = for <<c::8 <- main>>, into: <<>>, do: <<dec.(c)::6>>
+    case rest do
       <<c1::8, c2::8, ?=, ?=>> ->
-        <<dec64(c1)::6, bsr(dec64(c2), 4)::2>>
+        <<main::binary, dec.(c1)::6, bsr(dec.(c2), 4)::2>>
       <<c1::8, c2::8, c3::8, ?=>> ->
-        <<dec64(c1)::6, dec64(c2)::6, bsr(dec64(c3), 2)::4>>
+        <<main::binary, dec.(c1)::6, dec.(c2)::6, bsr(dec.(c3), 2)::4>>
       <<c1::8, c2::8, c3::8, c4::8>> ->
-        <<dec64(c1)::6, dec64(c2)::6, dec64(c3)::6, dec64(c4)::6>>
+        <<main::binary, dec.(c1)::6, dec.(c2)::6, dec.(c3)::6, dec.(c4)::6>>
       <<>> ->
-        <<>>
+        main
     end
-    main <> tail
   end
   defp do_decode64(_, _) do
     raise ArgumentError, "incorrect padding"
   end
 
-  defp do_encode64url(<<>>, _), do: <<>>
-  defp do_encode64url(data, pad?) do
-    split =  3 * div(byte_size(data), 3)
+  defp do_encode32(<<>>, _), do: <<>>
+  defp do_encode32(data, enc) do
+    split =  5 * div(byte_size(data), 5)
     <<main::size(split)-binary, rest::binary>> = data
-    main = for <<c::6 <- main>>, into: <<>>, do: <<enc64url(c)::8>>
-    tail = case rest do
-      <<c1::6, c2::6, c3::4>> ->
-        <<enc64url(c1)::8, enc64url(c2)::8, enc64url(bsl(c3, 2))::8>>
-      <<c1::6, c2::2>> ->
-        <<enc64url(c1)::8, enc64url(bsl(c2, 4))::8>>
+    main = for <<c::5 <- main>>, into: <<>>, do: <<enc.(c)::8>>
+    case rest do
+      <<c1::5, c2::5, c3::5, c4::5, c5::5, c6::5, c7::2>> ->
+        <<main::binary,
+          enc.(c1)::8, enc.(c2)::8, enc.(c3)::8, enc.(c4)::8,
+          enc.(c5)::8, enc.(c6)::8, enc.(bsl(c7, 3))::8, ?=>>
+      <<c1::5, c2::5, c3::5, c4::5, c5::4>> ->
+        <<main::binary,
+          enc.(c1)::8, enc.(c2)::8, enc.(c3)::8, enc.(c4)::8,
+          enc.(bsl(c5, 1))::8, ?=,  ?=, ?=>>
+      <<c1::5, c2::5, c3::5, c4::1>> ->
+        <<main::binary,
+          enc.(c1)::8, enc.(c2)::8,  enc.(c3)::8, enc.(bsl(c4, 4))::8,
+          ?=, ?=,  ?=, ?=>>
+      <<c1::5, c2::3>> ->
+        <<main::binary,
+          enc.(c1)::8, enc.(bsl(c2, 2))::8, ?=, ?=,
+          ?=, ?=, ?=, ?=>>
       <<>> ->
-        <<>>
+        main
     end
-    main <> maybe_pad(tail, pad?, 4, "=")
   end
 
-  defp do_decode64url(<<>>, _), do: <<>>
-  defp do_decode64url(string, false) do
-    maybe_pad(string, true, 4, "=") |> do_decode64url(true)
-  end
-  defp do_decode64url(string, _pad?) when rem(byte_size(string), 4) == 0 do
-    split = byte_size(string) - 4
+  defp do_decode32(<<>>, _), do: <<>>
+  defp do_decode32(string, dec) when rem(byte_size(string), 8) == 0 do
+    split = byte_size(string) - 8
     <<main::size(split)-binary, rest::binary>> = string
-    main = for <<c::8 <- main>>, into: <<>>, do: <<dec64url(c)::6>>
-    tail = case rest do
-      <<c1::8, c2::8, ?=, ?=>> ->
-        <<dec64url(c1)::6, bsr(dec64url(c2), 4)::2>>
-      <<c1::8, c2::8, c3::8, ?=>> ->
-        <<dec64url(c1)::6, dec64url(c2)::6, bsr(dec64url(c3), 2)::4>>
-      <<c1::8, c2::8, c3::8, c4::8>> ->
-        <<dec64url(c1)::6, dec64url(c2)::6, dec64url(c3)::6, dec64url(c4)::6>>
+    main = for <<c::8 <- main>>, into: <<>>, do: <<dec.(c)::5>>
+    case rest do
+      <<c1::8, c2::8, ?=, ?=, ?=, ?=, ?=, ?=>> ->
+        <<main::binary, dec.(c1)::5, bsr(dec.(c2), 2)::3>>
+      <<c1::8, c2::8, c3::8, c4::8, ?=, ?=, ?=, ?=>> ->
+        <<main::binary,
+          dec.(c1)::5, dec.(c2)::5, dec.(c3)::5, bsr(dec.(c4), 4)::1>>
+      <<c1::8, c2::8, c3::8, c4::8, c5::8, ?=, ?=, ?=>> ->
+        <<main::binary,
+          dec.(c1)::5, dec.(c2)::5, dec.(c3)::5, dec.(c4)::5,
+          bsr(dec.(c5), 1)::4>>
+      <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, ?=>> ->
+        <<main::binary,
+          dec.(c1)::5, dec.(c2)::5, dec.(c3)::5, dec.(c4)::5,
+          dec.(c5)::5, dec.(c6)::5,  bsr(dec.(c7), 3)::2>>
+      <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8>> ->
+        <<main::binary,
+          dec.(c1)::5, dec.(c2)::5, dec.(c3)::5, dec.(c4)::5,
+          dec.(c5)::5, dec.(c6)::5, dec.(c7)::5, dec.(c8)::5>>
       <<>> ->
-        <<>>
+        main
     end
-    main <> tail
   end
-  defp do_decode64url(_, _) do
+  defp do_decode32(_, _) do
     raise ArgumentError, "incorrect padding"
   end
 
-  defp do_encode32(_, <<>>, _), do: <<>>
-
-  for {case, fun} <- [upper: :to_upper, lower: :to_lower] do
-    defp do_encode32(unquote(case), data, pad?) do
-      split =  5 * div(byte_size(data), 5)
-      <<main::size(split)-binary, rest::binary>> = data
-      main = for <<c::5 <- main>>, into: <<>>, do: <<unquote(fun)(enc32(c))::8>>
-      tail = case rest do
-        <<c1::5, c2::5, c3::5, c4::5, c5::5, c6::5, c7::2>> ->
-          <<unquote(fun)(enc32(c1))::8, unquote(fun)(enc32(c2))::8,
-            unquote(fun)(enc32(c3))::8, unquote(fun)(enc32(c4))::8,
-            unquote(fun)(enc32(c5))::8, unquote(fun)(enc32(c6))::8,
-            unquote(fun)(enc32(bsl(c7, 3)))::8>>
-        <<c1::5, c2::5, c3::5, c4::5, c5::4>> ->
-          <<unquote(fun)(enc32(c1))::8, unquote(fun)(enc32(c2))::8,
-            unquote(fun)(enc32(c3))::8, unquote(fun)(enc32(c4))::8,
-            unquote(fun)(enc32(bsl(c5, 1)))::8>>
-        <<c1::5, c2::5, c3::5, c4::1>> ->
-          <<unquote(fun)(enc32(c1))::8, unquote(fun)(enc32(c2))::8,
-            unquote(fun)(enc32(c3))::8, unquote(fun)(enc32(bsl(c4, 4)))::8>>
-        <<c1::5, c2::3>> ->
-          <<unquote(fun)(enc32(c1))::8, unquote(fun)(enc32(bsl(c2, 2)))::8>>
-        <<>> ->
-          <<>>
-      end
-      main <> maybe_pad(tail, pad?, 8, "=")
-    end
-  end
-
-  defp do_decode32(_, <<>>, _), do: <<>>
-  defp do_decode32(case, string, false),
-    do: do_decode32(case, maybe_pad(string, true, 8, "="), true)
-
-  for {case, fun} <- [upper: :from_upper, lower: :from_lower, mixed: :from_mixed] do
-    defp do_decode32(unquote(case), string, _pad?) when rem(byte_size(string), 8) == 0 do
-      split = byte_size(string) - 8
-      <<main::size(split)-binary, rest::binary>> = string
-      main = for <<c::8 <- main>>, into: <<>>, do: <<dec32(unquote(fun)(c))::5>>
-      tail = case rest do
-        <<c1::8, c2::8, ?=, ?=, ?=, ?=, ?=, ?=>> ->
-          <<dec32(unquote(fun)(c1))::5, bsr(dec32(unquote(fun)(c2)), 2)::3>>
-        <<c1::8, c2::8, c3::8, c4::8, ?=, ?=, ?=, ?=>> ->
-          <<dec32(unquote(fun)(c1))::5, dec32(unquote(fun)(c2))::5,
-            dec32(unquote(fun)(c3))::5, bsr(dec32(unquote(fun)(c4)), 4)::1>>
-        <<c1::8, c2::8, c3::8, c4::8, c5::8, ?=, ?=, ?=>> ->
-          <<dec32(unquote(fun)(c1))::5, dec32(unquote(fun)(c2))::5,
-            dec32(unquote(fun)(c3))::5, dec32(unquote(fun)(c4))::5,
-            bsr(dec32(unquote(fun)(c5)), 1)::4>>
-        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, ?=>> ->
-          <<dec32(unquote(fun)(c1))::5, dec32(unquote(fun)(c2))::5,
-            dec32(unquote(fun)(c3))::5, dec32(unquote(fun)(c4))::5,
-            dec32(unquote(fun)(c5))::5, dec32(unquote(fun)(c6))::5,
-            bsr(dec32(unquote(fun)(c7)), 3)::2>>
-        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8>> ->
-          <<dec32(unquote(fun)(c1))::5, dec32(unquote(fun)(c2))::5,
-            dec32(unquote(fun)(c3))::5, dec32(unquote(fun)(c4))::5,
-            dec32(unquote(fun)(c5))::5, dec32(unquote(fun)(c6))::5,
-            dec32(unquote(fun)(c7))::5, dec32(unquote(fun)(c8))::5>>
-        <<>> ->
-          <<>>
-      end
-      main <> tail
-    end
-  end
-
-  defp do_decode32(_, _, _),
-    do: raise ArgumentError, "incorrect padding"
-
-  defp do_hex_encode32(_, <<>>, _), do: <<>>
-
-  for {case, fun} <- [upper: :to_upper, lower: :to_lower] do
-    defp do_hex_encode32(unquote(case), data, pad?) do
-      split =  5 * div(byte_size(data), 5)
-      <<main::size(split)-binary, rest::binary>> = data
-      main = for <<c::5 <- main>>, into: <<>>, do: <<unquote(fun)(enc32hex(c))::8>>
-      tail = case rest do
-        <<c1::5, c2::5, c3::5, c4::5, c5::5, c6::5, c7::2>> ->
-          <<unquote(fun)(enc32hex(c1))::8, unquote(fun)(enc32hex(c2))::8,
-            unquote(fun)(enc32hex(c3))::8, unquote(fun)(enc32hex(c4))::8,
-            unquote(fun)(enc32hex(c5))::8, unquote(fun)(enc32hex(c6))::8,
-            unquote(fun)(enc32hex(bsl(c7, 3)))::8>>
-        <<c1::5, c2::5, c3::5, c4::5, c5::4>> ->
-          <<unquote(fun)(enc32hex(c1))::8, unquote(fun)(enc32hex(c2))::8,
-            unquote(fun)(enc32hex(c3))::8, unquote(fun)(enc32hex(c4))::8,
-            unquote(fun)(enc32hex(bsl(c5, 1)))::8>>
-        <<c1::5, c2::5, c3::5, c4::1>> ->
-          <<unquote(fun)(enc32hex(c1))::8, unquote(fun)(enc32hex(c2))::8,
-            unquote(fun)(enc32hex(c3))::8, unquote(fun)(enc32hex(bsl(c4, 4)))::8>>
-        <<c1::5, c2::3>> ->
-          <<unquote(fun)(enc32hex(c1))::8, unquote(fun)(enc32hex(bsl(c2, 2)))::8>>
-        <<>> ->
-          <<>>
-      end
-      main <> maybe_pad(tail, pad?, 8, "=")
-    end
-  end
-
-  defp do_hex_decode32(_, <<>>, _), do: <<>>
-  defp do_hex_decode32(case, string, false),
-    do: do_hex_decode32(case, maybe_pad(string, true, 8, "="), true)
-
-  for {case, fun} <- [upper: :from_upper, lower: :from_lower, mixed: :from_mixed] do
-    defp do_hex_decode32(unquote(case), string, _pad?) when rem(byte_size(string), 8) == 0 do
-      split = byte_size(string) - 8
-      <<main::size(split)-binary, rest::binary>> = string
-      main = for <<c::8 <- main>>, into: <<>>, do: <<dec32hex(unquote(fun)(c))::5>>
-      tail = case rest do
-        <<c1::8, c2::8, ?=, ?=, ?=, ?=, ?=, ?=>> ->
-          <<dec32hex(unquote(fun)(c1))::5, bsr(dec32hex(unquote(fun)(c2)), 2)::3>>
-        <<c1::8, c2::8, c3::8, c4::8, ?=, ?=, ?=, ?=>> ->
-          <<dec32hex(unquote(fun)(c1))::5, dec32hex(unquote(fun)(c2))::5,
-            dec32hex(unquote(fun)(c3))::5, bsr(dec32hex(unquote(fun)(c4)), 4)::1>>
-        <<c1::8, c2::8, c3::8, c4::8, c5::8, ?=, ?=, ?=>> ->
-          <<dec32hex(unquote(fun)(c1))::5, dec32hex(unquote(fun)(c2))::5,
-            dec32hex(unquote(fun)(c3))::5, dec32hex(unquote(fun)(c4))::5,
-            bsr(dec32hex(unquote(fun)(c5)), 1)::4>>
-        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, ?=>> ->
-          <<dec32hex(unquote(fun)(c1))::5, dec32hex(unquote(fun)(c2))::5,
-            dec32hex(unquote(fun)(c3))::5, dec32hex(unquote(fun)(c4))::5,
-            dec32hex(unquote(fun)(c5))::5, dec32hex(unquote(fun)(c6))::5,
-            bsr(dec32hex(unquote(fun)(c7)), 3)::2>>
-        <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8>> ->
-          <<dec32hex(unquote(fun)(c1))::5, dec32hex(unquote(fun)(c2))::5,
-            dec32hex(unquote(fun)(c3))::5, dec32hex(unquote(fun)(c4))::5,
-            dec32hex(unquote(fun)(c5))::5, dec32hex(unquote(fun)(c6))::5,
-            dec32hex(unquote(fun)(c7))::5, dec32hex(unquote(fun)(c8))::5>>
-        <<>> ->
-          <<>>
-      end
-      main <> tail
-    end
-  end
-
-  defp do_hex_decode32(_, _, _),
-    do: raise ArgumentError, "incorrect padding"
 end

lib/elixir/lib/behaviour.ex

@@ -1,26 +1,60 @@
 defmodule Behaviour do
   @moduledoc """
-  This module has been deprecated.
+  Utilities for defining behaviour interfaces.
 
-  Instead of `defcallback`, one can simply use `@callback`.
-  Instead of `defmacrocallback`, one can simply use `@macrocallback`.
-  Instead of `__behaviour__(:callbacks)`, one can simply use `behaviour_info(:callbacks)`.
+  Behaviours can be referenced by other modules
+  to ensure they implement required callbacks.
+
+  For example, you can specify the `URI.Parser`
+  behaviour as follows:
+
+      defmodule URI.Parser do
+        use Behaviour
+
+        @doc "Parses the given URL"
+        defcallback parse(uri_info :: URI.t) :: URI.t
+
+        @doc "Defines a default port"
+        defcallback default_port() :: integer
+      end
+
+  And then a module may use it as:
+
+      defmodule URI.HTTP do
+        @behaviour URI.Parser
+        def default_port(), do: 80
+        def parse(info), do: info
+      end
+
+  If the behaviour changes or `URI.HTTP` does
+  not implement one of the callbacks, a warning
+  will be raised.
+
+  ## Implementation
+
+  Since Erlang R15, behaviours must be defined via
+  `@callback` attributes. `defcallback` is a simple
+  mechanism that defines the `@callback` attribute
+  according to the given type specification. `defcallback` allows
+  documentation to be created for the callback and defines
+  a custom function signature.
+
+  The callbacks and their documentation can be retrieved
+  via the `__behaviour__` callback function.
   """
 
-  # TODO: Deprecate by 1.4
-
   @doc """
-  Defines a function callback according to the given type specification.
+  Define a function callback according to the given type specification.
   """
   defmacro defcallback(spec) do
-    do_defcallback(:def, split_spec(spec, quote(do: term)))
+    do_defcallback(split_spec(spec, quote(do: term)), __CALLER__)
   end
 
   @doc """
-  Defines a macro callback according to the given type specification.
+  Define a macro callback according to the given type specification.
   """
   defmacro defmacrocallback(spec) do
-    do_defcallback(:defmacro, split_spec(spec, quote(do: Macro.t)))
+    do_defmacrocallback(split_spec(spec, quote(do: Macro.t)), __CALLER__)
   end
 
   defp split_spec({:when, _, [{:::, _, [spec, return]}, guard]}, _default) do
@@ -39,17 +73,27 @@ defmodule Behaviour do
     {spec, default, []}
   end
 
-  defp do_defcallback(kind, {spec, return, guards}) do
+  defp do_defcallback({spec, return, guards}, caller) do
     case Macro.decompose_call(spec) do
       {name, args} ->
-        do_callback(kind, name, args, return, guards)
+        do_callback(:def, name, args, name, length(args), args, return, guards, caller)
       _ ->
-        raise ArgumentError, "invalid syntax in #{kind}callback #{Macro.to_string(spec)}"
+        raise ArgumentError, "invalid syntax in defcallback #{Macro.to_string(spec)}"
     end
   end
 
-  defp do_callback(kind, name, args, return, guards) do
-    :lists.foreach fn
+  defp do_defmacrocallback({spec, return, guards}, caller) do
+    case Macro.decompose_call(spec) do
+      {name, args} ->
+        do_callback(:defmacro, :"MACRO-#{name}", [quote(do: env :: Macro.Env.t)|args],
+                    name, length(args), args, return, guards, caller)
+      _ ->
+        raise ArgumentError, "invalid syntax in defmacrocallback #{Macro.to_string(spec)}"
+    end
+  end
+
+  defp do_callback(kind, name, args, docs_name, docs_arity, _docs_args, return, guards, caller) do
+    Enum.each args, fn
       {:::, _, [left, right]} ->
         ensure_not_default(left)
         ensure_not_default(right)
@@ -57,16 +101,12 @@ defmodule Behaviour do
       other ->
         ensure_not_default(other)
         other
-    end, args
+    end
 
-    spec =
-      quote do
-        unquote(name)(unquote_splicing(args)) :: unquote(return) when unquote(guards)
-      end
-
-    case kind do
-      :def -> quote(do: @callback unquote(spec))
-      :defmacro -> quote(do: @macrocallback unquote(spec))
+    quote do
+      @callback unquote(name)(unquote_splicing(args)) :: unquote(return) when unquote(guards)
+      Behaviour.store_docs(__MODULE__, unquote(caller.line), unquote(kind),
+                           unquote(docs_name), unquote(docs_arity))
     end
   end
 
@@ -76,8 +116,28 @@ defmodule Behaviour do
 
   defp ensure_not_default(_), do: :ok
 
+  @doc false
+  def store_docs(module, line, kind, name, arity) do
+    doc = Module.get_attribute module, :doc
+    Module.delete_attribute module, :doc
+    Module.put_attribute module, :behaviour_docs, {{name, arity}, line, kind, 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__(env) do
+    docs = if Code.compiler_options[:docs] do
+      Enum.reverse Module.get_attribute(env.module, :behaviour_docs)
+    end
+
     quote do
       @doc false
       def __behaviour__(:callbacks) do
@@ -85,15 +145,8 @@ defmodule Behaviour do
       end
 
       def __behaviour__(:docs) do
-        for {tuple, line, kind, docs} <- Code.get_docs(__MODULE__, :callback_docs) do
-          case kind do
-            :callback -> {tuple, line, :def, docs}
-            :macrocallback -> {tuple, line, :defmacro, docs}
-          end
-        end
+        unquote(Macro.escape(docs))
       end
-
-      import unquote(__MODULE__)
     end
   end
 end

lib/elixir/lib/bitwise.ex

@@ -1,49 +1,40 @@
 defmodule Bitwise do
   @moduledoc """
-  A set of macros that perform calculations on bits.
+  This module provides macros and operators for bitwise operators.
+  These macros can be used in guards.
 
-  The macros in this module come in two flavors: named or
-  operators. For example:
+  The easiest way to use is to simply import them into
+  your module:
 
       iex> use Bitwise
-      iex> bnot 1   # named
+      iex> bnot 1
       -2
-      iex> 1 &&& 1  # operator
+      iex> 1 &&& 1
       1
 
-  If you prefer to use only operators or skip them, you can
-  pass the following options:
-
-    * `:only_operators` - include only operators
-    * `:skip_operators` - skip operators
-
-  For example:
+  You can select to include only or skip operators by passing options:
 
       iex> use Bitwise, only_operators: true
       iex> 1 &&& 1
       1
 
-  When invoked with no options, `use Bitwise` is equivalent
-  to `import Bitwise`.
-
-  All bitwise macros can be used in guards:
-
-      iex> use Bitwise
-      iex> odd? = fn int when band(int, 1) == 1 -> true; _ -> false end
-      iex> odd?.(1)
-      true
-
   """
 
-  @doc false
+  @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 ->
-        []
+      true -> []
     end
 
     quote do
@@ -52,160 +43,84 @@ defmodule Bitwise do
   end
 
   @doc """
-  Calculates the bitwise NOT of its argument.
-
-      iex> bnot(2)
-      -3
-      iex> bnot(2) &&& 3
-      1
-
+  Bitwise not.
   """
   defmacro bnot(expr) do
     quote do: :erlang.bnot(unquote(expr))
   end
 
   @doc """
-  Prefix (unary) operator; calculates the bitwise NOT of its argument.
-
-      iex> ~~~2
-      -3
-      iex> ~~~2 &&& 3
-      1
-
+  Bitwise not as operator.
   """
   defmacro ~~~expr do
     quote do: :erlang.bnot(unquote(expr))
   end
 
   @doc """
-  Calculates the bitwise AND of its arguments.
-
-      iex> band(9, 3)
-      1
-
+  Bitwise and.
   """
   defmacro band(left, right) do
     quote do: :erlang.band(unquote(left), unquote(right))
   end
 
   @doc """
-  Infix operator; calculates the bitwise AND of its arguments.
-
-      iex> 9 &&& 3
-      1
-
+  Bitwise and as operator.
   """
   defmacro left &&& right do
     quote do: :erlang.band(unquote(left), unquote(right))
   end
 
   @doc """
-  Calculates the bitwise OR of its arguments.
-
-      iex> bor(9, 3)
-      11
-
+  Bitwise or.
   """
   defmacro bor(left, right) do
     quote do: :erlang.bor(unquote(left), unquote(right))
   end
 
   @doc """
-  Infix operator; calculates the bitwise OR of its arguments.
-
-      iex> 9 ||| 3
-      11
-
+  Bitwise or as operator.
   """
   defmacro left ||| right do
     quote do: :erlang.bor(unquote(left), unquote(right))
   end
 
   @doc """
-  Calculates the bitwise XOR of its arguments.
-
-      iex> bxor(9, 3)
-      10
-
+  Bitwise xor.
   """
   defmacro bxor(left, right) do
     quote do: :erlang.bxor(unquote(left), unquote(right))
   end
 
   @doc """
-  Infix operator; calculates the bitwise XOR of its arguments.
-
-      iex> 9 ^^^ 3
-      10
-
+  Bitwise xor as operator.
   """
   defmacro left ^^^ right do
     quote do: :erlang.bxor(unquote(left), unquote(right))
   end
 
   @doc """
-  Calculates the result of an arithmetic left bitshift.
-
-      iex> bsl(1, 2)
-      4
-      iex> bsl(1, -2)
-      0
-      iex> bsl(-1, 2)
-      -4
-      iex> bsl(-1, -2)
-      -1
-
+  Arithmetic bitshift left.
   """
   defmacro bsl(left, right) do
     quote do: :erlang.bsl(unquote(left), unquote(right))
   end
 
   @doc """
-  Infix operator; calculates the result of an arithmetic left bitshift.
-
-      iex> 1 <<< 2
-      4
-      iex> 1 <<< -2
-      0
-      iex> -1 <<< 2
-      -4
-      iex> -1 <<< -2
-      -1
-
+  Arithmetic bitshift left as operator.
   """
   defmacro left <<< right do
     quote do: :erlang.bsl(unquote(left), unquote(right))
   end
 
   @doc """
-  Calculates the result of an arithmetic right bitshift.
-
-      iex> bsr(1, 2)
-      0
-      iex> bsr(1, -2)
-      4
-      iex> bsr(-1, 2)
-      -1
-      iex> bsr(-1, -2)
-      -4
-
+  Arithmetic bitshift right.
   """
   defmacro bsr(left, right) do
     quote do: :erlang.bsr(unquote(left), unquote(right))
   end
 
   @doc """
-  Infix operator; calculates the result of an arithmetic right bitshift.
-
-      iex> 1 >>> 2
-      0
-      iex> 1 >>> -2
-      4
-      iex> -1 >>> 2
-      -1
-      iex> -1 >>> -2
-      -4
-
+  Arithmetic bitshift right as operator.
   """
   defmacro left >>> right do
     quote do: :erlang.bsr(unquote(left), unquote(right))

lib/elixir/lib/calendar/iso.ex

@@ -1,189 +0,0 @@
-defmodule Calendar.ISO do
-  @moduledoc """
-  A calendar implementation that follows to ISO8601.
-
-  This calendar implements the proleptic Gregorian calendar and
-  is therefore compatible with the calendar used in most countries
-  today. The proleptic means the Gregorian rules for leap years are
-  applied for all time, consequently the dates give different results
-  before the year 1583 from when the Gregorian calendar was adopted.
-  """
-
-  @behaviour Calendar
-
-  @doc """
-  Builds and validates an ISO date.
-
-  ## Examples
-
-      iex> Calendar.ISO.date(2000, 1, 1)
-      {:ok, ~D[2000-01-01]}
-      iex> Calendar.ISO.date(2000, 13, 1)
-      {:error, :invalid_date}
-      iex> Calendar.ISO.date(2000, 2, 29)
-      {:ok, ~D[2000-02-29]}
-
-      iex> Calendar.ISO.date(2000, 2, 30)
-      {:error, :invalid_date}
-      iex> Calendar.ISO.date(2001, 2, 29)
-      {:error, :invalid_date}
-
-  """
-  def date(year, month, day) when is_integer(year) and is_integer(month) and is_integer(day) do
-    if :calendar.valid_date(year, month, day) and year <= 9999 do
-      {:ok, %Date{year: year, month: month, day: day}}
-    else
-      {:error, :invalid_date}
-    end
-  end
-
-  @doc """
-  Returns if the given year is a leap year.
-
-  ## Examples
-
-      iex> Calendar.ISO.leap_year?(2000)
-      true
-      iex> Calendar.ISO.leap_year?(2001)
-      false
-      iex> Calendar.ISO.leap_year?(2004)
-      true
-      iex> Calendar.ISO.leap_year?(1900)
-      false
-
-  """
-  def leap_year?(year) when is_integer(year) and year >= 0 do
-    rem(year, 4) === 0 and (rem(year, 100) > 0 or rem(year, 400) === 0)
-  end
-
-  @doc """
-  Converts the given structure into a string.
-
-  It uses the ISO8601 standard except for DateTime where the
-  timezone information is added between brackets.
-  """
-  def to_string(%Date{year: year, month: month, day: day}) do
-    date_to_string(year, month, day)
-  end
-
-  def to_string(%Time{hour: hour, minute: minute, second: second, microsecond: microsecond}) do
-    time_to_string(hour, minute, second, microsecond)
-  end
-
-  def to_string(%NaiveDateTime{year: year, month: month, day: day,
-                               hour: hour, minute: minute, second: second, microsecond: microsecond}) do
-    date_to_string(year, month, day) <> " " <> time_to_string(hour, minute, second, microsecond)
-  end
-
-  def to_string(%DateTime{year: year, month: month, day: day, zone_abbr: zone_abbr,
-                          hour: hour, minute: minute, second: second, microsecond: microsecond,
-                          utc_offset: utc_offset, std_offset: std_offset, time_zone: time_zone}) do
-    date_to_string(year, month, day) <> " " <>
-      time_to_string(hour, minute, second, microsecond) <>
-      offset_to_string(utc_offset, std_offset, time_zone) <>
-      zone_to_string(utc_offset, std_offset, zone_abbr, time_zone)
-  end
-
-  defp date_to_string(year, month, day) do
-    zero_pad(year, 4) <> "-" <> zero_pad(month, 2) <> "-" <> zero_pad(day, 2)
-  end
-
-  defp time_to_string(hour, minute, second, 0) do
-    zero_pad(hour, 2) <> ":" <> zero_pad(minute, 2) <> ":" <> zero_pad(second, 2)
-  end
-  defp time_to_string(hour, minute, second, {_, 0}) do
-    time_to_string(hour, minute, second, 0)
-  end
-  defp time_to_string(hour, minute, second, {microsecond, precision}) do
-    time_to_string(hour, minute, second, 0) <> "." <>
-      (microsecond |> zero_pad(6) |> binary_part(0, precision))
-  end
-
-  defp offset_to_string(0, 0, "Etc/UTC"), do: "Z"
-  defp offset_to_string(utc, std, _zone) do
-    total  = utc + std
-    second = abs(total)
-    minute = second |> rem(3600) |> div(60)
-    hour   = second |> div(3600)
-    sign(total) <> zero_pad(hour, 2) <> ":" <> zero_pad(minute, 2)
-  end
-
-  defp zone_to_string(0, 0, _abbr, "Etc/UTC"), do: ""
-  defp zone_to_string(_, _, abbr, zone), do: " " <> abbr <> " " <> zone
-
-  defp sign(total) when total < 0, do: "-"
-  defp sign(_), do: "+"
-
-  defp zero_pad(val, count) do
-    num = Integer.to_string(val)
-    :binary.copy("0", count - byte_size(num)) <> num
-  end
-
-  ## Helpers
-
-  @doc false
-  def to_iso8601(%Date{year: year, month: month, day: day}) do
-    date_to_string(year, month, day)
-  end
-
-  def to_iso8601(%Time{hour: hour, minute: minute, second: second, microsecond: microsecond}) do
-    time_to_string(hour, minute, second, microsecond)
-  end
-
-  def to_iso8601(%NaiveDateTime{year: year, month: month, day: day,
-                                hour: hour, minute: minute, second: second, microsecond: microsecond}) do
-    date_to_string(year, month, day) <> "T" <> time_to_string(hour, minute, second, microsecond)
-  end
-
-  def to_iso8601(%DateTime{year: year, month: month, day: day,
-                           hour: hour, minute: minute, second: second, microsecond: microsecond,
-                           utc_offset: utc_offset, std_offset: std_offset, time_zone: time_zone}) do
-    date_to_string(year, month, day) <> "T" <>
-      time_to_string(hour, minute, second, microsecond) <>
-      offset_to_string(utc_offset, std_offset, time_zone)
-  end
-
-  @doc false
-  def parse_microsecond("." <> rest) do
-    case parse_microsecond(rest, 0, "") do
-      {"", 0, _} ->
-        :error
-      {microsecond, precision, rest} when precision in 1..6 ->
-        pad = String.duplicate("0", 6 - byte_size(microsecond))
-        {{String.to_integer(microsecond <> pad), precision}, rest}
-      {microsecond, _precision, rest} ->
-        {{String.to_integer(binary_part(microsecond, 0, 6)), 6}, rest}
-    end
-  end
-  def parse_microsecond(rest) do
-    {{0, 0}, rest}
-  end
-
-  defp parse_microsecond(<<h, t::binary>>, precision, acc) when h in ?0..?9,
-    do: parse_microsecond(t, precision + 1, <<acc::binary, h>>)
-  defp parse_microsecond(rest, precision, acc),
-    do: {acc, precision, rest}
-
-  @doc false
-  def parse_offset(""),
-    do: {nil, ""}
-  def parse_offset("Z"),
-    do: {0, ""}
-  def parse_offset("-00:00"),
-    do: :error
-  def parse_offset(<<?+, hour::2-bytes, ?:, min::2-bytes, rest::binary>>),
-    do: parse_offset(1, hour, min, rest)
-  def parse_offset(<<?-, hour::2-bytes, ?:, min::2-bytes, rest::binary>>),
-    do: parse_offset(-1, hour, min, rest)
-  def parse_offset(_),
-    do: :error
-
-  defp parse_offset(sign, hour, min, rest) do
-    with {hour, ""} when hour < 24 <- Integer.parse(hour),
-         {min, ""} when min < 60 <- Integer.parse(min) do
-      {((hour * 60) + min) * 60 * sign, rest}
-    else
-      _ -> :error
-    end
-  end
-end

lib/elixir/lib/code.ex

@@ -2,112 +2,84 @@ defmodule Code do
   @moduledoc """
   Utilities for managing code compilation, code evaluation and code loading.
 
-  This module complements Erlang's [`:code` module](http://www.erlang.org/doc/man/code.html)
-  to add behaviour which is specific to Elixir. Almost all of the functions in this module
-  have global side effects on the behaviour of Elixir.
+  This module complements [Erlang's code module](http://www.erlang.org/doc/man/code.html)
+  to add behaviour which is specific to Elixir.
   """
 
   @doc """
-  Lists all loaded files.
-
-  ## Examples
-
-      Code.require_file("../eex/test/eex_test.exs")
-      List.first(Code.loaded_files) =~ "eex_test.exs" #=> true
-
+  List all loaded files.
   """
   def loaded_files do
     :elixir_code_server.call :loaded
   end
 
   @doc """
-  Removes files from the loaded files list.
+  Remove files from the loaded files list.
 
   The modules defined in the file are not removed;
   calling this function only removes them from the list,
   allowing them to be required again.
-
-  ## Examples
-
-      # Load EEx test code, unload file, check for functions still available
-      Code.load_file("../eex/test/eex_test.exs")
-      Code.unload_files(Code.loaded_files)
-      function_exported?(EExTest.Compiled, :before_compile, 0) #=> true
-
   """
   def unload_files(files) do
     :elixir_code_server.cast {:unload_files, files}
   end
 
   @doc """
-  Appends a path to the end of the Erlang VM code path list.
-
-  This is the list of directories the Erlang VM uses for
-  finding module code.
+  Append a path to the Erlang VM code path.
 
   The path is expanded with `Path.expand/1` before being appended.
-  If this path does not exist, an error is returned.
-
-  ## Examples
-
-      Code.append_path(".") #=> true
-
-      Code.append_path("/does_not_exist") #=> {:error, :bad_directory}
-
   """
   def append_path(path) do
-    :code.add_pathz(to_charlist(Path.expand path))
+    :code.add_pathz(to_char_list(Path.expand path))
   end
 
   @doc """
-  Prepends a path to the beginning of the Erlang VM code path list.
-
-  This is the list of directories the Erlang VM uses for finding
-  module code.
+  Prepend a path to the Erlang VM code path.
 
   The path is expanded with `Path.expand/1` before being prepended.
-  If this path does not exist, an error is returned.
-
-  ## Examples
-
-      Code.prepend_path(".") #=> true
-
-      Code.prepend_path("/does_not_exist") #=> {:error, :bad_directory}
-
   """
   def prepend_path(path) do
-    :code.add_patha(to_charlist(Path.expand path))
+    :code.add_patha(to_char_list(Path.expand path))
   end
 
   @doc """
-  Deletes a path from the Erlang VM code path list. This is the list of
-  directories the Erlang VM uses for finding module code.
-
-  The path is expanded with `Path.expand/1` before being deleted. If the
-  path does not exist it returns `false`.
-
-  ## Examples
-
-      Code.prepend_path(".")
-      Code.delete_path(".") #=> true
-
-      Code.delete_path("/does_not_exist") #=> false
+  Delete a path from the Erlang VM code path.
 
+  The path is expanded with `Path.expand/1` before being deleted.
   """
   def delete_path(path) do
-    :code.del_path(to_charlist(Path.expand path))
+    :code.del_path(to_char_list(Path.expand path))
   end
 
   @doc """
-  Evaluates the contents given by `string`.
+  Re-add paths given to the command line to keep their position
+  on the overall code path.
+
+  Some tools may change the code path by prepending new items but
+  still want the paths given by the user to have higher priority.
+  Calling this function guarantees the paths are re-added on
+  top of the user given ones.
+  """
+  @spec readd_paths() :: :ok
+  def readd_paths() do
+    {pa, pz} = :elixir_code_server.call(:paths)
+    :code.add_pathsa(pa)
+    :code.add_pathsz(pz)
+    :ok
+  end
+
+  @doc """
+  Evaluate the contents given by `string`.
 
   The `binding` argument is a keyword list of variable bindings.
   The `opts` argument is a keyword list of environment options.
 
   Those options can be:
 
-    * `:file` - the file to be considered in the evaluation
-    * `:line` - the line on which the script starts
+    * `:file`               - the file to be considered in the evaluation
+    * `:line`               - the line on which the script starts
+    * `:delegate_locals_to` - delegate local calls to the given module,
+                              the default is to not delegate
 
   Additionally, the following scope values can be configured:
 
@@ -126,7 +98,7 @@ defmodule Code do
   Notice that setting any of the values above overrides Elixir's default
   values. For example, setting `:requires` to `[]`, will no longer
   automatically require the `Kernel` module; in the same way setting
-  `:macros` will no longer auto-import `Kernel` macros like `if/2`, `case/2`,
+  `:macros` will no longer auto-import `Kernel` macros like `if`, `case`,
   etc.
 
   Returns a tuple of the form `{value, binding}`,
@@ -159,18 +131,18 @@ defmodule Code do
   def eval_string(string, binding \\ [], opts \\ [])
 
   def eval_string(string, binding, %Macro.Env{} = env) do
-    {value, binding, _env, _scope} = :elixir.eval to_charlist(string), binding, Map.to_list(env)
+    {value, binding, _env, _scope} = :elixir.eval to_char_list(string), binding, Map.to_list(env)
     {value, binding}
   end
 
   def eval_string(string, binding, opts) when is_list(opts) do
     validate_eval_opts(opts)
-    {value, binding, _env, _scope} = :elixir.eval to_charlist(string), binding, opts
+    {value, binding, _env, _scope} = :elixir.eval to_char_list(string), binding, opts
     {value, binding}
   end
 
   @doc """
-  Evaluates the quoted contents.
+  Evaluate the quoted contents.
 
   See `eval_string/3` for a description of arguments and return values.
 
@@ -239,7 +211,7 @@ defmodule Code do
   end
 
   @doc """
-  Converts the given string to its quoted form.
+  Convert the given string to its quoted form.
 
   Returns `{:ok, quoted_form}`
   if it succeeds, `{:error, {line, error, token}}` otherwise.
@@ -263,11 +235,11 @@ defmodule Code do
   def string_to_quoted(string, opts \\ []) when is_list(opts) do
     file = Keyword.get opts, :file, "nofile"
     line = Keyword.get opts, :line, 1
-    :elixir.string_to_quoted(to_charlist(string), line, file, opts)
+    :elixir.string_to_quoted(to_char_list(string), line, file, opts)
   end
 
   @doc """
-  Converts the given string to its quoted form.
+  Convert the given string to its quoted form.
 
   It returns the ast if it succeeds,
   raises an exception otherwise. The exception is a `TokenMissingError`
@@ -279,7 +251,7 @@ defmodule Code do
   def string_to_quoted!(string, opts \\ []) when is_list(opts) do
     file = Keyword.get opts, :file, "nofile"
     line = Keyword.get opts, :line, 1
-    :elixir.string_to_quoted!(to_charlist(string), line, file, opts)
+    :elixir.string_to_quoted!(to_char_list(string), line, file, opts)
   end
 
   @doc """
@@ -297,7 +269,7 @@ defmodule Code do
   end
 
   @doc """
-  Loads the given file.
+  Load 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.
@@ -308,12 +280,6 @@ defmodule Code do
   Notice that if `load_file` is invoked by different processes concurrently,
   the target file will be loaded concurrently many times. Check `require_file/2`
   if you don't want a file to be loaded concurrently.
-
-  ## Examples
-
-      Code.load_file("eex_test.exs", "../eex/test") |> List.first
-      #=> {EExTest.Compiled, <<70, 79, 82, 49, ...>>}
-
   """
   def load_file(file, relative_to \\ nil) when is_binary(file) do
     file = find_file(file, relative_to)
@@ -336,20 +302,7 @@ defmodule Code do
   N times with a given file, it will be loaded only once. The first process to
   call `require_file` will get the list of loaded modules, others will get `nil`.
 
-  Check `load_file/2` if you want a file to be loaded multiple times. See also
-  `unload_files/1`
-
-  ## Examples
-
-  If the code is already loaded, it returns `nil`:
-
-      Code.require_file("eex_test.exs", "../eex/test") #=> nil
-
-  If the code is not loaded yet, it returns the same as `load_file/2`:
-
-      Code.require_file("eex_test.exs", "../eex/test") |> List.first
-      #=> {EExTest.Compiled, <<70, 79, 82, 49, ...>>}
-
+  Check `load_file/2` if you want a file to be loaded multiple times.
   """
   def require_file(file, relative_to \\ nil) when is_binary(file) do
     file = find_file(file, relative_to)
@@ -370,28 +323,15 @@ defmodule Code do
   Gets the compilation options from the code server.
 
   Check `compiler_options/1` for more information.
-
-  ## Examples
-
-      Code.compiler_options
-      #=> %{debug_info: true, docs: true,
-            warnings_as_errors: false, ignore_module_conflict: false}
-
   """
   def compiler_options do
-    :elixir_config.get :compiler_options
+    :elixir_code_server.call :compiler_options
   end
 
   @doc """
   Returns a list with the available compiler options.
 
   See `Code.compiler_options/1` for more info.
-
-  ## Examples
-
-      iex> Code.available_compiler_options
-      [:docs, :debug_info, :ignore_module_conflict, :warnings_as_errors]
-
   """
   def available_compiler_options do
     [:docs, :debug_info, :ignore_module_conflict, :warnings_as_errors]
@@ -417,23 +357,14 @@ defmodule Code do
     * `:warnings_as_errors` - cause compilation to fail when warnings are
       generated
 
-  It returns the new list of compiler options.
-
-  ## Examples
-
-      Code.compiler_options(debug_info: true)
-      #=> %{debug_info: true, docs: true,
-            warnings_as_errors: false, ignore_module_conflict: false}
-
   """
   def compiler_options(opts) do
-    available = available_compiler_options()
-
-    for {k, _} <- opts,
-        not k in available,
-        do: raise "unknown compiler options: #{k}"
-
-    :elixir_config.update :compiler_options, &Enum.into(opts, &1)
+    {opts, bad} = Keyword.split(opts, available_compiler_options)
+    if bad != [] do
+      bad = bad |> Keyword.keys |> Enum.join(", ")
+      raise ArgumentError, message: "unknown compiler options: #{bad}"
+    end
+    :elixir_code_server.cast {:compiler_options, opts}
   end
 
   @doc """
@@ -445,7 +376,7 @@ defmodule Code do
   For compiling many files at once, check `Kernel.ParallelCompiler.files/2`.
   """
   def compile_string(string, file \\ "nofile") when is_binary(file) do
-    :elixir_compiler.string to_charlist(string), file
+    :elixir_compiler.string to_char_list(string), file
   end
 
   @doc """
@@ -480,7 +411,7 @@ defmodule Code do
   module uses this function to check if a specific parser exists for a given
   URI scheme.
 
-  ## Code.ensure_compiled/1
+  ## `Code.ensure_compiled/1`
 
   Elixir also contains an `ensure_compiled/1` function that is a
   superset of `ensure_loaded/1`.
@@ -495,15 +426,6 @@ defmodule Code do
   In most cases, `ensure_loaded/1` is enough. `ensure_compiled/1`
   must be used in rare cases, usually involving macros that need to
   invoke a module for callback information.
-
-  ## Examples
-
-      iex> Code.ensure_loaded(Atom)
-      {:module, Atom}
-
-      iex> Code.ensure_loaded(DoesNotExist)
-      {:error, :nofile}
-
   """
   def ensure_loaded(module) when is_atom(module) do
     :code.ensure_loaded(module)
@@ -515,12 +437,6 @@ defmodule Code do
   Similar to `ensure_loaded/1`, but returns `true` if the module
   is already loaded or was successfully loaded. Returns `false`
   otherwise.
-
-  ## Examples
-
-      iex> Code.ensure_loaded?(Atom)
-      true
-
   """
   def ensure_loaded?(module) do
     match?({:module, ^module}, ensure_loaded(module))
@@ -542,11 +458,15 @@ defmodule Code do
   def ensure_compiled(module) when is_atom(module) do
     case :code.ensure_loaded(module) do
       {:error, :nofile} = error ->
-        if is_pid(:erlang.get(:elixir_compiler_pid)) and
-           Kernel.ErrorHandler.ensure_compiled(module, :module) do
-          {:module, module}
-        else
-          error
+        case :erlang.get(:elixir_ensure_compiled) do
+          :undefined -> error
+          _ ->
+            try do
+              module.__info__(:module)
+              {:module, module}
+            rescue
+              UndefinedFunctionError -> error
+            end
         end
       other -> other
     end
@@ -563,7 +483,7 @@ defmodule Code do
     match?({:module, ^module}, ensure_compiled(module))
   end
 
-  @doc ~S"""
+  @doc """
   Returns the docs for the given module.
 
   When given a module name, it finds its BEAM code and reads the docs from it.
@@ -580,32 +500,10 @@ defmodule Code do
       which module definition starts and `doc` is the string
       attached to the module using the `@moduledoc` attribute
 
-    * `:callback_docs` - list of all docstrings attached to
-      `@callbacks` using the `@doc` attribute
-
-    * `:type_docs` - list of all docstrings attached to
-      `@type` callbacks using the `@typedoc` attribute
-
-    * `:all` - a keyword list with `:docs` and `:moduledoc`, `:callback_docs`,
-      and `:type_docs`.
-
-  If the module cannot be found, it returns `nil`.
-
-  ## Examples
-
-      # Get the module documentation
-      iex> {_line, text} = Code.get_docs(Atom, :moduledoc)
-      iex> String.split(text, "\n") |> Enum.at(0)
-      "Convenience functions for working with atoms."
-
-      # Module doesn't exist
-      iex> Code.get_docs(ModuleNotGood, :all)
-      nil
+    * `:all` - a keyword list with both `:docs` and `:moduledoc`
 
   """
-  @doc_kinds [:docs, :moduledoc, :callback_docs, :type_docs, :all]
-
-  def get_docs(module, kind) when is_atom(module) and kind in @doc_kinds do
+  def get_docs(module, kind) when is_atom(module) do
     case :code.get_object_code(module) do
       {_module, bin, _beam_path} ->
         do_get_docs(bin, kind)
@@ -614,8 +512,8 @@ defmodule Code do
     end
   end
 
-  def get_docs(binpath, kind) when is_binary(binpath) and kind in @doc_kinds do
-    do_get_docs(String.to_charlist(binpath), kind)
+  def get_docs(binpath, kind) when is_binary(binpath) do
+    do_get_docs(String.to_char_list(binpath), kind)
   end
 
   @docs_chunk 'ExDc'
@@ -636,7 +534,7 @@ defmodule Code do
   defp lookup_docs(_, _), do: nil
 
   defp do_lookup_docs(docs, :all), do: docs
-  defp do_lookup_docs(docs, kind),
+  defp do_lookup_docs(docs, kind) when kind in [:docs, :moduledoc],
     do: Keyword.get(docs, kind)
 
   ## Helpers

lib/elixir/lib/collectable.ex

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

lib/elixir/lib/dict.ex

@@ -1,27 +1,139 @@
 defmodule Dict do
   @moduledoc ~S"""
-  WARNING: this module is deprecated.
+  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.
 
-  If you need a general dictionary, use the `Map` module.
-  If you need to manipulate keyword lists, use `Keyword`.
+  To create a new dict, use the `new` functions defined
+  by each dict type:
+
+      HashDict.new  #=> creates an empty HashDict
+
+  In the examples below, `dict_impl` means a specific
+  `Dict` implementation, for example `HashDict` or `Map`.
+
+  ## Protocols
+
+  Besides implementing the functions in this module, all
+  dictionaries are required to implement the `Access`
+  protocol:
+
+      iex> dict = dict_impl.new
+      iex> dict = Dict.put(dict, :hello, :world)
+      iex> dict[:hello]
+      :world
+
+  As well as the `Enumerable` and `Collectable` protocols.
+
+  ## Match
+
+  Dictionaries are required to implement all operations
+  using the match (`===`) operator.
+
+  ## Default implementation
+
+  Default implementations for some functions in the `Dict` module
+  are provided via `use Dict`.
+
+  For example:
+
+      defmodule MyDict do
+        use Dict
+
+        # implement required functions (see below)
+        # override default implementations if optimization
+        # is needed
+      end
+
+  The client module must contain the following functions:
+
+    * `delete/2`
+    * `fetch/2`
+    * `put/3`
+    * `reduce/3`
+    * `size/1`
+
+  All functions, except `reduce/3`, are required by the Dict behaviour.
+  `reduce/3` must be implemtented as per the Enumerable protocol.
+
+  Based on these functions, `Dict` generates default implementations
+  for the following functions:
+
+    * `drop/2`
+    * `equal?/2`
+    * `fetch!/2`
+    * `get/2`
+    * `get/3`
+    * `has_key?/2`
+    * `keys/1`
+    * `merge/2`
+    * `merge/3`
+    * `pop/2`
+    * `pop/3`
+    * `put_new/3`
+    * `split/2`
+    * `take/2`
+    * `to_list/1`
+    * `update/4`
+    * `update!/3`
+    * `values/1`
+
+  All of these functions are defined as overridable, so you can provide
+  your own implementation if needed.
+
+  Note you can also test your custom module via `Dict`'s doctests:
+
+      defmodule MyDict do
+        # ...
+      end
+
+      defmodule MyTests do
+        use ExUnit.Case
+        doctest Dict
+        defp dict_impl, do: MyDict
+      end
 
-  To convert maps into keywords and vice-versa, use the
-  `new` function in the respective modules.
   """
 
+  use Behaviour
+
   @type key :: any
   @type value :: any
   @type t :: list | map
 
-  # TODO: Deprecate every function by 1.4
+  defcallback new :: t
+  defcallback delete(t, key) :: t
+  defcallback drop(t, Enum.t) :: t
+  defcallback equal?(t, t) :: boolean
+  defcallback get(t, key) :: value
+  defcallback get(t, key, value) :: value
+  defcallback fetch(t, key) :: {:ok, value} | :error
+  defcallback fetch!(t, key) :: value | no_return
+  defcallback has_key?(t, key) :: boolean
+  defcallback keys(t) :: [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, Enum.t) :: {t, t}
+  defcallback take(t, Enum.t) :: t
+  defcallback to_list(t) :: list()
+  defcallback update(t, key, value, (value -> value)) :: t
+  defcallback update!(t, key, (value -> value)) :: t | no_return
+  defcallback values(t) :: list(value)
+
   defmacro __using__(_) do
     # Use this import to guarantee proper code expansion
     import Kernel, except: [size: 1]
 
-    %{file: file, line: line} = __CALLER__
-    :elixir_errors.warn(line, file, "the Dict module is deprecated")
-
     quote do
+      @behaviour Dict
+
       def get(dict, key, default \\ nil) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -29,19 +141,6 @@ defmodule Dict do
         end
       end
 
-      def get_lazy(dict, key, fun) when is_function(fun, 0) do
-        case fetch(dict, key) do
-          {:ok, value} -> value
-          :error -> fun.()
-        end
-      end
-
-      def get_and_update(dict, key, fun) do
-        current_value = get(dict, key)
-        {get, new_value} = fun.(current_value)
-        {get, put(dict, key, new_value)}
-      end
-
       def fetch!(dict, key) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -60,13 +159,6 @@ defmodule Dict do
         end
       end
 
-      def put_new_lazy(dict, key, fun) when is_function(fun, 0) do
-        case has_key?(dict, key) do
-          true  -> dict
-          false -> put(dict, key, fun.())
-        end
-      end
-
       def drop(dict, keys) do
         Enum.reduce(keys, dict, &delete(&2, &1))
       end
@@ -82,19 +174,19 @@ defmodule Dict do
 
       def to_list(dict) do
         reduce(dict, {:cont, []}, fn
-          kv, acc -> {:cont, [kv | acc]}
+          kv, acc -> {:cont, [kv|acc]}
         end) |> elem(1) |> :lists.reverse
       end
 
       def keys(dict) do
         reduce(dict, {:cont, []}, fn
-          {k, _}, acc -> {:cont, [k | acc]}
+          {k, _}, acc -> {:cont, [k|acc]}
         end) |> elem(1) |> :lists.reverse
       end
 
       def values(dict) do
         reduce(dict, {:cont, []}, fn
-          {_, v}, acc -> {:cont, [v | acc]}
+          {_, v}, acc -> {:cont, [v|acc]}
         end) |> elem(1) |> :lists.reverse
       end
 
@@ -156,15 +248,6 @@ defmodule Dict do
         end
       end
 
-      def pop_lazy(dict, key, fun) when is_function(fun, 0) do
-        case fetch(dict, key) do
-          {:ok, value} ->
-            {value, delete(dict, key)}
-          :error ->
-            {fun.(), dict}
-        end
-      end
-
       def split(dict, keys) do
         Enum.reduce(keys, {new, dict}, fn key, {inc, exc} = acc ->
           case fetch(exc, key) do
@@ -179,11 +262,11 @@ defmodule Dict do
       defoverridable merge: 2, merge: 3, equal?: 2, to_list: 1, keys: 1,
                      values: 1, take: 2, drop: 2, get: 2, get: 3, fetch!: 2,
                      has_key?: 2, put_new: 3, pop: 2, pop: 3, split: 2,
-                     update: 4, update!: 3, get_and_update: 3, get_lazy: 3,
-                     pop_lazy: 3, put_new_lazy: 3
+                     update: 4, update!: 3
     end
   end
 
+
   defmacrop target(dict) do
     quote do
       case unquote(dict) do
@@ -199,141 +282,380 @@ defmodule Dict do
     end
   end
 
+  @doc """
+  Returns a list of all keys in `dict`.
+  The keys are not guaranteed to be in any order.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> Enum.sort(Dict.keys(dict))
+      [:a,:b]
+
+  """
   @spec keys(t) :: [key]
   def keys(dict) do
     target(dict).keys(dict)
   end
 
+  @doc """
+  Returns a list of all values in `dict`.
+  The values are not guaranteed to be in any order.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> Enum.sort(Dict.values(dict))
+      [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> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> Dict.size(dict)
+      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> dict = Enum.into([a: 1], dict_impl.new)
+      iex> Dict.has_key?(dict, :a)
+      true
+      iex> Dict.has_key?(dict, :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> dict = Enum.into([a: 1], dict_impl.new)
+      iex> Dict.get(dict, :a)
+      1
+      iex> Dict.get(dict, :b)
+      nil
+      iex> Dict.get(dict, :b, 3)
+      3
+  """
   @spec get(t, key, value) :: value
   def get(dict, key, default \\ nil) do
     target(dict).get(dict, key, default)
   end
 
-  @spec get_lazy(t, key, (() -> value)) :: value
-  def get_lazy(dict, key, fun) do
-    target(dict).get_lazy(dict, key, fun)
-  end
+  @doc """
+  Returns `{:ok, value}` associated with `key` in `dict`.
+  If `dict` does not contain `key`, returns `:error`.
 
-  @spec get_and_update(t, key, (value -> {value, value})) :: {value, t}
-  def get_and_update(dict, key, fun) do
-    target(dict).get_and_update(dict, key, fun)
-  end
+  ## Examples
 
+      iex> dict = Enum.into([a: 1], dict_impl.new)
+      iex> Dict.fetch(dict, :a)
+      {:ok, 1}
+      iex> Dict.fetch(dict, :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> dict = Enum.into([a: 1], dict_impl.new)
+      iex> Dict.fetch!(dict, :a)
+      1
+
+  """
   @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> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.put(dict, :a, 3)
+      iex> Dict.get(dict, :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> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.put_new(dict, :a, 3)
+      iex> Dict.get(dict, :a)
+      1
+
+  """
   @spec put_new(t, key, value) :: t
   def put_new(dict, key, val) do
     target(dict).put_new(dict, key, val)
   end
 
-  @spec put_new_lazy(t, key, (() -> value)) :: t
-  def put_new_lazy(dict, key, fun) do
-    target(dict).put_new_lazy(dict, key, fun)
-  end
+  @doc """
+  Removes the entry stored under the given `key` from `dict`.
+  If `dict` does not contain `key`, returns the dictionary unchanged.
 
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.delete(dict, :a)
+      iex> Dict.get(dict, :a)
+      nil
+
+      iex> dict = Enum.into([b: 2], dict_impl.new)
+      iex> Dict.delete(dict, :a) == dict
+      true
+
+  """
   @spec delete(t, key) :: t
   def delete(dict, key) do
     target(dict).delete(dict, key)
   end
 
-  @spec merge(t, t) :: t
-  def merge(dict1, dict2) do
-    target1 = target(dict1)
-    target2 = target(dict2)
+  @doc """
+  Merges the dict `dict2` into dict `dict1`.
 
-    if target1 == target2 do
-      target1.merge(dict1, dict2)
-    else
-      do_merge(target1, dict1, dict2, fn(_k, _v1, v2) -> v2 end)
-    end
-  end
+  If one of the `dict2` entries already exists in `dict1`, the
+  functions in entries in `dict2` have higher precedence unless a
+  function is given to resolve conflicts.
 
+  Notice this function is polymorphic as it merges dicts of any
+  type. Each dict implementation also provides a `merge` function,
+  but they can only merge dicts of the same type.
+
+  ## Examples
+
+      iex> dict1 = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict2 = Enum.into([a: 3, d: 4], dict_impl.new)
+      iex> dict = Dict.merge(dict1, dict2)
+      iex> [a: Dict.get(dict, :a), b: Dict.get(dict, :b), d: Dict.get(dict, :d)]
+      [a: 3, b: 2, d: 4]
+
+      iex> dict1 = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict2 = Enum.into([a: 3, d: 4], dict_impl.new)
+      iex> dict = Dict.merge(dict1, dict2, fn(_k, v1, v2) ->
+      ...>   v1 + v2
+      ...> end)
+      iex> [a: Dict.get(dict, :a), b: Dict.get(dict, :b), d: Dict.get(dict, :d)]
+      [a: 4, b: 2, d: 4]
+
+  """
   @spec merge(t, t, (key, value, value -> value)) :: t
-  def merge(dict1, dict2, fun) do
+  def merge(dict1, dict2, fun \\ fn(_k, _v1, v2) -> v2 end) do
     target1 = target(dict1)
     target2 = target(dict2)
 
     if target1 == target2 do
       target1.merge(dict1, dict2, fun)
     else
-      do_merge(target1, dict1, dict2, fun)
+      Enumerable.reduce(dict2, {:cont, dict1}, fn({k, v}, acc) ->
+        {:cont, target1.update(acc, k, v, fn(other) -> fun.(k, other, v) end)}
+      end) |> elem(1)
     end
   end
 
-  defp do_merge(target1, dict1, dict2, fun) do
-    Enumerable.reduce(dict2, {:cont, dict1}, fn({k, v}, acc) ->
-      {:cont, target1.update(acc, k, v, fn(other) -> fun.(k, other, v) end)}
-    end) |> elem(1)
-  end
+  @doc """
+  Returns the value associated with `key` in `dict` as
+  well as the `dict` without `key`.
 
+  ## Examples
+
+      iex> dict = Enum.into([a: 1], dict_impl.new)
+      iex> {v, dict} = Dict.pop dict, :a
+      iex> {v, Enum.sort(dict)}
+      {1,[]}
+
+      iex> dict = Enum.into([a: 1], dict_impl.new)
+      iex> {v, dict} = Dict.pop dict, :b
+      iex> {v, Enum.sort(dict)}
+      {nil,[a: 1]}
+
+      iex> dict = Enum.into([a: 1], dict_impl.new)
+      iex> {v, dict} = Dict.pop dict, :b, 3
+      iex> {v, Enum.sort(dict)}
+      {3,[a: 1]}
+
+  """
   @spec pop(t, key, value) :: {value, t}
   def pop(dict, key, default \\ nil) do
     target(dict).pop(dict, key, default)
   end
 
-  @spec pop_lazy(t, key, (() -> value)) :: {value, t}
-  def pop_lazy(dict, key, fun) do
-    target(dict).pop_lazy(dict, key, fun)
-  end
+  @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> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.update!(dict, :a, fn(val) -> -val end)
+      iex> Dict.get(dict, :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> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.update(dict, :c, 3, fn(val) -> -val end)
+      iex> Dict.get(dict, :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> dict = Enum.into([a: 1, b: 2, c: 3, d: 4], dict_impl.new)
+      iex> {dict1, dict2} = Dict.split(dict, [:a, :c, :e])
+      iex> {Dict.to_list(dict1) |> Enum.sort, Dict.to_list(dict2) |> Enum.sort}
+      {[a: 1, c: 3], [b: 2, d: 4]}
+
+      iex> dict = Enum.into([], dict_impl.new)
+      iex> {dict1, dict2} = Dict.split(dict, [:a, :c])
+      iex> {Dict.to_list(dict1), Dict.to_list(dict2)}
+      {[], []}
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> {dict1, dict2} = Dict.split(dict, [:a, :b, :c])
+      iex> {Dict.to_list(dict1) |> Enum.sort, Dict.to_list(dict2)}
+      {[a: 1, b: 2], []}
+
+  """
   @spec split(t, [key]) :: {t, t}
   def split(dict, keys) do
     target(dict).split(dict, keys)
   end
 
+  @doc """
+  Returns a new dict where the given `keys` are removed from `dict`.
+  Any non-member keys are ignored.
+
+  ## Examples
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.drop(dict, [:a, :c, :d])
+      iex> Dict.to_list(dict)
+      [b: 2]
+
+      iex> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.drop(dict, [:c, :d])
+      iex> Dict.to_list(dict) |> Enum.sort
+      [a: 1, b: 2]
+
+  """
   @spec drop(t, [key]) :: 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> dict = Enum.into([a: 1, b: 2], dict_impl.new)
+      iex> dict = Dict.take(dict, [:a, :c, :d])
+      iex> Dict.to_list(dict)
+      [a: 1]
+      iex> dict = Dict.take(dict, [:c, :d])
+      iex> Dict.to_list(dict)
+      []
+
+  """
   @spec take(t, [key]) :: t
   def take(dict, keys) do
     target(dict).take(dict, keys)
   end
 
+  @doc false
   @spec empty(t) :: t
   def empty(dict) do
     target(dict).empty(dict)
   end
 
+  @doc """
+  Check if two dicts are equal using `===`.
+
+  Notice this function is polymorphic as it compares dicts of any
+  type. Each dict implementation also provides an `equal?` function,
+  but they can only compare dicts of the same type.
+
+  ## Examples
+
+      iex> dict1 = Enum.into([a: 2, b: 3, f: 5, c: 123], dict_impl.new)
+      iex> dict2 = [a: 2, b: 3, f: 5, c: 123]
+      iex> Dict.equal?(dict1, dict2)
+      true
+
+      iex> dict1 = Enum.into([a: 2, b: 3, f: 5, c: 123], dict_impl.new)
+      iex> dict2 = []
+      iex> Dict.equal?(dict1, dict2)
+      false
+
+  """
   @spec equal?(t, t) :: boolean
   def equal?(dict1, dict2) do
     target1 = target(dict1)
@@ -347,7 +669,7 @@ defmodule Dict do
         Enumerable.reduce(dict2, {:cont, true}, fn({k, v}, _acc) ->
           case target1.fetch(dict1, k) do
             {:ok, ^v} -> {:cont, true}
-            _         -> {:halt, false}
+            _           -> {:halt, false}
           end
         end) |> elem(1)
 
@@ -356,12 +678,15 @@ defmodule Dict do
     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
 
-  @spec unsupported_dict(t) :: no_return
   defp unsupported_dict(dict) do
     raise ArgumentError, "unsupported dict: #{inspect dict}"
   end

lib/elixir/lib/exception.ex

@@ -4,7 +4,7 @@ defmodule Exception do
 
   Note that stacktraces in Elixir are updated on throw,
   errors and exits. For example, at any given moment,
-  `System.stacktrace/0` will return the stacktrace for the
+  `System.stacktrace` will return the stacktrace for the
   last throw/error/exit that occurred in the current process.
 
   Do not rely on the particular format returned by the `format`
@@ -15,19 +15,15 @@ defmodule Exception do
   """
 
   @typedoc "The exception type"
-  @type t :: %{
-    required(:__struct__) => module,
-    required(:__exception__) => true,
-    atom => any
-  }
+  @type t :: %{__struct__: module, __exception__: true}
 
   @typedoc "The kind handled by formatting functions"
   @type kind :: :error | :exit | :throw | {:EXIT, pid}
 
   @type stacktrace :: [stacktrace_entry]
   @type stacktrace_entry ::
-        {module, atom, arity_or_args, location} |
-        {(... -> any), arity_or_args, location}
+        {module, function, arity_or_args, location} |
+        {function, arity_or_args, location}
 
   @typep arity_or_args :: non_neg_integer | list
   @typep location :: Keyword.t
@@ -36,31 +32,22 @@ defmodule Exception do
   @callback message(t) :: String.t
 
   @doc """
-  Returns `true` if the given `term` is an exception.
+  Returns true if the given argument is an exception.
   """
-  def exception?(term)
-
-  def exception?(%{__struct__: struct, __exception__: true}) when is_atom(struct),
-    do: true
-
+  def exception?(%{__struct__: struct, __exception__: true}) when is_atom(struct), do: true
   def exception?(_), do: false
 
   @doc """
-  Gets the message for an `exception`.
+  Gets the message for an exception.
   """
   def message(%{__struct__: module, __exception__: true} = exception) when is_atom(module) do
     try do
       module.message(exception)
     rescue
       e ->
-        "got #{inspect e.__struct__} with message #{inspect message(e)} " <>
-        "while retrieving Exception.message/1 for #{inspect(exception)}"
-    else
-      x when is_binary(x) -> x
-      x ->
-        "got #{inspect(x)} " <>
-        "while retrieving Exception.message/1 for #{inspect(exception)} " <>
-        "(expected a string)"
+        raise ArgumentError,
+          "Got #{inspect e.__struct__} with message " <>
+          "\"#{message(e)}\" while retrieving message for #{inspect(exception)}"
     end
   end
 
@@ -99,7 +86,7 @@ defmodule Exception do
   end
 
   @doc """
-  Normalizes and formats any throw/error/exit.
+  Normalizes and formats any throw, error and exit.
 
   The message is formatted and displayed in the same
   format as used by Elixir's CLI.
@@ -132,7 +119,7 @@ defmodule Exception do
   end
 
   @doc """
-  Normalizes and formats throw/errors/exits and stacktraces.
+  Normalizes and formats throw/errors/exits and stacktrace.
 
   It relies on `format_banner/3` and `format_stacktrace/1`
   to generate the final format.
@@ -159,7 +146,7 @@ defmodule Exception do
   end
 
   @doc """
-  Formats an exit. It returns a string.
+  Formats an exit, returns a string.
 
   Often there are errors/exceptions inside exits. Exits are often
   wrapped by the caller and provide stacktraces too. This function
@@ -234,7 +221,6 @@ defmodule Exception do
     "shutdown: #{inspect(reason)}"
   end
 
-  defp format_exit_reason(:calling_self), do: "process attempted to call itself"
   defp format_exit_reason(:timeout), do: "time out"
   defp format_exit_reason(:killed), do: "killed"
   defp format_exit_reason(:noconnection), do: "no connection"
@@ -267,7 +253,7 @@ defmodule Exception do
 
   # :supervisor.start_link error reasons
 
-  # If value is a list will be formatted by mfa exit in format_exit/1
+  # If value is a list will be be formatted by mfa exit in format_exit/1
   defp format_exit_reason({:bad_return, {mod, :init, value}})
       when is_atom(mod) do
     format_mfa(mod, :init, 1) <> " returned a bad value: " <> inspect(value)
@@ -370,10 +356,9 @@ defmodule Exception do
   end
 
   defp format_application(module) do
-    # We cannot use Application due to bootstrap issues
     case :application.get_application(module) do
       {:ok, app} -> "(" <> Atom.to_string(app) <> ") "
-      :undefined -> ""
+      :undefined   -> ""
     end
   end
 
@@ -390,7 +375,7 @@ defmodule Exception do
 
     case trace do
       [] -> "\n"
-      _ -> "    " <> Enum.map_join(trace, "\n    ", &format_stacktrace_entry(&1)) <> "\n"
+      s  -> "    " <> Enum.map_join(s, "\n    ", &format_stacktrace_entry(&1)) <> "\n"
     end
   end
 
@@ -400,7 +385,7 @@ defmodule Exception do
 
   ## Examples
 
-      Exception.format_fa(fn -> nil end, 1)
+      Exception.format_fa(fn -> end, 1)
       #=> "#Function<...>/1"
 
   """
@@ -453,8 +438,8 @@ defmodule Exception do
   end
 
   @doc """
-  Formats the given `file` and `line` as shown in stacktraces.
-  If any of the values are `nil`, they are omitted.
+  Formats the given file and line as shown in stacktraces.
+  If any of the values are nil, they are omitted.
 
   ## Examples
 
@@ -468,7 +453,11 @@ defmodule Exception do
       ""
 
   """
-  def format_file_line(file, line, suffix \\ "") do
+  def format_file_line(file, line) do
+    format_file_line(file, line, "")
+  end
+
+  defp format_file_line(file, line, suffix) do
     if file do
       if line && line != 0 do
         "#{file}:#{line}:#{suffix}"
@@ -485,21 +474,43 @@ defmodule Exception do
   end
 end
 
-# Some exceptions implement "message/1" instead of "exception/1" mostly
+# Some exceptions implement `message/1` instead of `exception/1` mostly
 # for bootstrap reasons. It is recommended for applications to implement
-# "exception/1" instead of "message/1" as described in "defexception/1"
+# `exception/1` instead of `message/1` as described in `defexception/1`
 # docs.
 
 defmodule RuntimeError do
   defexception message: "runtime error"
+
+  @spec exception(String.t) :: Exception.t
+  def exception(msg) when is_binary(msg) do
+    %RuntimeError{message: msg}
+  end
+
+  def exception(arg) do
+    super(arg)
+  end
 end
 
 defmodule ArgumentError do
   defexception message: "argument error"
+
+  @spec exception(String.t) :: Exception.t
+  def exception(msg) when is_binary(msg) do
+    %ArgumentError{message: msg}
+  end
+
+  def exception(arg) do
+    super(arg)
+  end
 end
 
 defmodule ArithmeticError do
-  defexception message: "bad argument in arithmetic expression"
+  defexception []
+
+  def message(_) do
+    "bad argument in arithmetic expression"
+  end
 end
 
 defmodule SystemLimitError do
@@ -522,18 +533,18 @@ end
 defmodule TokenMissingError do
   defexception [file: nil, line: nil, description: "expression is incomplete"]
 
-  def message(%{file: file, line: line, description: description}) do
-    Exception.format_file_line(file && Path.relative_to_cwd(file), line) <>
-      " " <> description
+  def message(exception) do
+    Exception.format_file_line(Path.relative_to_cwd(exception.file), exception.line) <>
+      " " <> exception.description
   end
 end
 
 defmodule CompileError do
   defexception [file: nil, line: nil, description: "compile error"]
 
-  def message(%{file: file, line: line, description: description}) do
-    Exception.format_file_line(file && Path.relative_to_cwd(file), line) <>
-      " " <> description
+  def message(exception) do
+    Exception.format_file_line(Path.relative_to_cwd(exception.file), exception.line) <>
+      " " <> exception.description
   end
 end
 
@@ -553,14 +564,6 @@ defmodule BadStructError do
   end
 end
 
-defmodule BadMapError do
-  defexception [term: nil]
-
-  def message(exception) do
-    "expected a map, got: #{inspect(exception.term)}"
-  end
-end
-
 defmodule MatchError do
   defexception [term: nil]
 
@@ -577,14 +580,6 @@ defmodule CaseClauseError do
   end
 end
 
-defmodule WithClauseError do
-  defexception [term: nil]
-
-  def message(exception) do
-    "no with clause matching: #{inspect(exception.term)}"
-  end
-end
-
 defmodule CondClauseError do
   defexception []
 
@@ -618,80 +613,20 @@ defmodule BadArityError do
 end
 
 defmodule UndefinedFunctionError do
-  defexception [module: nil, function: nil, arity: nil, reason: nil]
+  defexception [module: nil, function: nil, arity: nil, self: false]
 
-  def message(%{reason: nil, module: module, function: function, arity: arity} = e) do
-    cond do
-      is_nil(function) or is_nil(arity) ->
-        "undefined function"
-      not is_nil(module) and :code.is_loaded(module) === false ->
-        message(%{e | reason: :"module could not be loaded"})
-      true ->
-        message(%{e | reason: :"function not exported"})
-    end
-  end
-
-  def message(%{reason: :"module could not be loaded", module: module, function: function, arity: arity}) do
-    "function " <> Exception.format_mfa(module, function, arity) <>
-      " is undefined (module #{inspect module} is not available)"
-  end
-
-  def message(%{reason: :"function not exported",  module: module, function: function, arity: arity}) do
-    "function " <> Exception.format_mfa(module, function, arity) <>
-    " is undefined or private" <> did_you_mean(module, function, arity)
-  end
-
-  def message(%{reason: :"function not available", module: module, function: function, arity: arity}) do
-    "nil." <> fa = Exception.format_mfa(nil, function, arity)
-    "function " <> Exception.format_mfa(module, function, arity) <>
-    " is undefined (function #{fa} is not available)"
-  end
-
-  def message(%{reason: reason,  module: module, function: function, arity: arity}) do
-    "function " <> Exception.format_mfa(module, function, arity) <> " is undefined (#{reason})"
-  end
-
-  @function_threshold 0.77
-  @max_suggestions 5
-
-  defp did_you_mean(module, function, _arity) do
-    exports = exports_for(module)
-
-    result =
-      case Keyword.take(exports, [function]) do
-        [] ->
-          base = Atom.to_string(function)
-          for {key, val} <- exports,
-              dist = String.jaro_distance(base, Atom.to_string(key)),
-              dist >= @function_threshold,
-            do: {dist, key, val}
-        arities ->
-          for {key, val} <- arities, do: {1.0, key, val}
+  def message(%{function: function, module: module, arity: arity, self: self}) do
+    if function do
+      formatted = Exception.format_mfa module, function, arity
+      suffix = if self or is_nil(module) or :code.is_loaded(module) do
+        ""
+      else
+        " (module #{inspect module} is not available)"
       end
-      |> Enum.sort(&elem(&1, 0) >= elem(&2, 0))
-      |> Enum.take(@max_suggestions)
-      |> Enum.sort(&elem(&1, 1) <= elem(&2, 1))
-
-    case result do
-      []          -> ""
-      suggestions -> ". Did you mean one of:\n\n#{Enum.map(suggestions, &format_fa/1)}"
-    end
-  end
-
-  defp format_fa({_dist, fun, arity}) do
-    fun = with ":" <> fun <- inspect(fun), do: fun
-    "      * " <> fun <> "/" <> Integer.to_string(arity) <> "\n"
-  end
-
-  defp exports_for(module) do
-    if function_exported?(module, :__info__, 1) do
-      module.__info__(:macros) ++ module.__info__(:functions)
+      "undefined function: #{formatted}" <> suffix
     else
-      module.module_info(:exports)
+      "undefined function"
     end
-  rescue
-    # In case the module was removed while we are computing this
-    UndefinedFunctionError -> []
   end
 end
 
@@ -718,13 +653,14 @@ defmodule Code.LoadError do
 end
 
 defmodule Protocol.UndefinedError do
-  defexception [protocol: nil, value: nil, description: ""]
+  defexception [protocol: nil, value: nil, description: nil]
 
   def message(exception) do
     msg = "protocol #{inspect exception.protocol} not implemented for #{inspect exception.value}"
-    case exception.description do
-      "" -> msg
-      descr -> msg <> ", " <> descr
+    if exception.description do
+      msg <> ", " <> exception.description
+    else
+      msg
     end
   end
 end
@@ -733,12 +669,7 @@ defmodule KeyError do
   defexception key: nil, term: nil
 
   def message(exception) do
-    msg = "key #{inspect exception.key} not found"
-    if exception.term != nil do
-      msg <> " in: #{inspect exception.term}"
-    else
-      msg
-    end
+    "key #{inspect exception.key} not found in: #{inspect exception.term}"
   end
 end
 
@@ -756,21 +687,25 @@ defmodule UnicodeConversionError do
     "encoding starting at #{inspect rest}"
   end
 
-  defp detail([h | _]) when is_integer(h) do
+  defp detail([h|_]) do
     "code point #{h}"
   end
-
-  defp detail([h | _]) do
-    detail(h)
-  end
 end
 
 defmodule Enum.OutOfBoundsError do
-  defexception message: "out of bounds error"
+  defexception []
+
+  def message(_) do
+    "out of bounds error"
+  end
 end
 
 defmodule Enum.EmptyError do
-  defexception message: "empty error"
+  defexception []
+
+  def message(_) do
+    "empty error"
+  end
 end
 
 defmodule File.Error do
@@ -778,25 +713,18 @@ defmodule File.Error do
 
   def message(exception) do
     formatted = IO.iodata_to_binary(:file.format_error(exception.reason))
-    "could not #{exception.action} #{inspect(exception.path)}: #{formatted}"
+    "could not #{exception.action} #{exception.path}: #{formatted}"
   end
 end
 
 defmodule File.CopyError do
-  defexception [reason: nil, source: nil, destination: nil, on: "", action: ""]
+  defexception [reason: nil, action: "", source: nil, destination: nil, on: nil]
 
   def message(exception) do
-    formatted =
-      IO.iodata_to_binary(:file.format_error(exception.reason))
-
-    location =
-      case exception.on do
-        "" -> ""
-        on -> ". #{on}"
-      end
-
-    "could not #{exception.action} from #{inspect(exception.source)} to " <>
-      "#{inspect(exception.destination)}#{location}: #{formatted}"
+    formatted = IO.iodata_to_binary(:file.format_error(exception.reason))
+    location  = if on = exception.on, do: ". #{on}", else: ""
+    "could not #{exception.action} from #{exception.source} to " <>
+      "#{exception.destination}#{location}: #{formatted}"
   end
 end
 
@@ -840,34 +768,10 @@ defmodule ErlangError do
     %MatchError{term: term}
   end
 
-  def normalize({:badmap, term}, _stacktrace) do
-    %BadMapError{term: term}
-  end
-
-  def normalize({:badkey, key}, stacktrace) do
-    term =
-      case stacktrace || :erlang.get_stacktrace do
-        [{Map, :get_and_update!, [map, _, _], _} | _] -> map
-        [{Map, :update!, [map, _, _], _} | _] -> map
-        [{:maps, :update, [_, _, map], _} | _] -> map
-        [{:maps, :get, [_, map], _} | _] -> map
-        _ -> nil
-      end
-    %KeyError{key: key, term: term}
-  end
-
-  def normalize({:badkey, key, map}, _stacktrace) do
-    %KeyError{key: key, term: map}
-  end
-
   def normalize({:case_clause, term}, _stacktrace) do
     %CaseClauseError{term: term}
   end
 
-  def normalize({:with_clause, term}, _stacktrace) do
-    %WithClauseError{term: term}
-  end
-
   def normalize({:try_clause, term}, _stacktrace) do
     %TryClauseError{term: term}
   end
@@ -875,7 +779,7 @@ defmodule ErlangError do
   def normalize(:undef, stacktrace) do
     stacktrace = stacktrace || :erlang.get_stacktrace
     {mod, fun, arity} = from_stacktrace(stacktrace)
-    %UndefinedFunctionError{module: mod, function: fun, arity: arity}
+    %UndefinedFunctionError{module: mod, function: fun, arity: arity, self: from_self(stacktrace)}
   end
 
   def normalize(:function_clause, stacktrace) do
@@ -891,15 +795,18 @@ defmodule ErlangError do
     %ErlangError{original: other}
   end
 
-  defp from_stacktrace([{module, function, args, _} | _]) when is_list(args) do
+  defp from_stacktrace([{module, function, args, _}|_]) when is_list(args) do
     {module, function, length(args)}
   end
 
-  defp from_stacktrace([{module, function, arity, _} | _]) do
+  defp from_stacktrace([{module, function, arity, _}|_]) do
     {module, function, arity}
   end
 
   defp from_stacktrace(_) do
     {nil, nil, nil}
   end
+
+  defp from_self([{module, _, _, _}, {module, _, _, _}|_]), do: true
+  defp from_self(_), do: false
 end

lib/elixir/lib/file.ex

@@ -3,35 +3,35 @@ defmodule File do
   This module contains functions to manipulate files.
 
   Some of those functions are low-level, allowing the user
-  to interact with files or IO devices, like `open/2`,
+  to interact with the file or IO devices, like `open/2`,
   `copy/3` and others. This module also provides higher
   level functions that work with filenames and have their naming
   based on UNIX variants. For example, one can copy a file
   via `cp/3` and remove files and directories recursively
-  via `rm_rf/1`.
+  via `rm_rf/1`
 
   ## Encoding
 
   In order to write and read files, one must use the functions
-  in the `IO` module. By default, a file is opened in binary mode,
+  in the `IO` module. By default, a file is opened in binary mode
   which requires the functions `IO.binread/2` and `IO.binwrite/2`
   to interact with the file. A developer may pass `:utf8` as an
   option when opening the file, then the slower `IO.read/2` and
   `IO.write/2` functions must be used as they are responsible for
-  doing the proper conversions and providing the proper data guarantees.
+  doing the proper conversions and data guarantees.
 
-  Note that filenames when given as charlists in Elixir are
+  Note that filenames when given as char lists in Elixir are
   always treated as UTF-8. In particular, we expect that the
-  shell and the operating system are configured to use UTF-8
-  encoding. Binary filenames are considered raw and passed
+  shell and the operating system are configured to use UTF8
+  encoding. Binary filenames are considering raw and passed
   to the OS as is.
 
   ## API
 
   Most of the functions in this module return `:ok` or
   `{:ok, result}` in case of success, `{:error, reason}`
-  otherwise. Those functions also have a variant
-  that ends with `!` which returns the result (instead of the
+  otherwise. Those function are also followed by a variant
+  that ends with `!` which returns the result (without the
   `{:ok, result}` tuple) in case of success or raises an
   exception in case it fails. For example:
 
@@ -47,15 +47,15 @@ defmodule File do
       File.read!("invalid.txt")
       #=> raises File.Error
 
-  In general, a developer should use the former in case they want
+  In general, a developer should use the former in case he wants
   to react if the file does not exist. The latter should be used
-  when the developer expects their software to fail in case the
+  when the developer expects his software to fail in case the
   file cannot be read (i.e. it is literally an exception).
 
   ## Processes and raw files
 
   Every time a file is opened, Elixir spawns a new process. Writing
-  to a file is equivalent to sending messages to the process that
+  to a file is equivalent to sending messages to that process that
   writes to the file descriptor.
 
   This means files can be passed between nodes and message passing
@@ -63,10 +63,10 @@ defmodule File do
 
   However, you may not always want to pay the price for this abstraction.
   In such cases, a file can be opened in `:raw` mode. The options `:read_ahead`
-  and `:delayed_write` are also useful when operating on large files or
+  and `:delayed_write` are also useful when operating large files or
   working with files in tight loops.
 
-  Check [`:file.open/2`](http://www.erlang.org/doc/man/file.html#open-2) for more information
+  Check http://www.erlang.org/doc/man/file.html#open-2 for more information
   about such options and other performance considerations.
   """
 
@@ -75,9 +75,9 @@ defmodule File do
   @type posix :: :file.posix()
   @type io_device :: :file.io_device()
   @type stat_options :: [time: :local | :universal | :posix]
-  @type mode :: :append | :binary | :charlist | :compressed | :delayed_write | :exclusive |
-    :raw | :read | :read_ahead | :sync | :utf8 | :write |
-    {:encoding, :latin1 | :unicode | :utf8 | :utf16 | :utf32 |
+  @type mode :: :append | :binary | :compressed | :delayed_write | :exclusive |
+    :raw | :read | :read_ahead | :sync | :write |
+    {:encoding , :latin1 | :unicode | :utf16 | :utf32 | :utf8 |
       {:utf16, :big | :little} | {:utf32, :big | :little}} |
     {:read_ahead, pos_integer} |
     {:delayed_write, non_neg_integer, non_neg_integer}
@@ -132,12 +132,12 @@ defmodule File do
   Typical error reasons are:
 
     * `:eacces`  - missing search or write permissions for the parent
-      directories of `path`
+       directories of `path`
     * `:eexist`  - there is already a file or directory named `path`
     * `:enoent`  - a component of `path` does not exist
     * `:enospc`  - there is a no space left on the device
     * `:enotdir` - a component of `path` is not a directory;
-      on some platforms, `:enoent` is returned instead
+       on some platforms, `:enoent` is returned instead
   """
   @spec mkdir(Path.t) :: :ok | {:error, posix}
   def mkdir(path) do
@@ -149,11 +149,11 @@ defmodule File do
   """
   @spec mkdir!(Path.t) :: :ok | no_return
   def mkdir!(path) do
+    path = IO.chardata_to_string(path)
     case mkdir(path) do
       :ok -> :ok
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "make directory",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "make directory", path: path
     end
   end
 
@@ -164,7 +164,7 @@ defmodule File do
   Typical error reasons are:
 
     * `:eacces`  - missing search or write permissions for the parent
-      directories of `path`
+                   directories of `path`
     * `:enospc`  - there is a no space left on the device
     * `:enotdir` - a component of `path` is not a directory
   """
@@ -187,7 +187,7 @@ defmodule File do
         {:error, :einval}
       else
         _ = do_mkdir_p(parent)
-        case F.make_dir(path) do
+        case :file.make_dir(path) do
           {:error, :eexist} = error ->
             if dir?(path), do: :ok, else: error
           other ->
@@ -202,11 +202,11 @@ defmodule File do
   """
   @spec mkdir_p!(Path.t) :: :ok | no_return
   def mkdir_p!(path) do
+    path = IO.chardata_to_string(path)
     case mkdir_p(path) do
       :ok -> :ok
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "make directory (with -p)",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "make directory (with -p)", path: path
     end
   end
 
@@ -218,10 +218,10 @@ defmodule File do
 
     * `:enoent`  - the file does not exist
     * `:eacces`  - missing permission for reading the file,
-      or for searching one of the parent directories
+                   or for searching one of the parent directories
     * `:eisdir`  - the named file is a directory
     * `:enotdir` - a component of the file name is not a directory;
-      on some platforms, `:enoent` is returned instead
+                   on some platforms, `:enoent` is returned instead
     * `:enomem`  - there is not enough memory for the contents of the file
 
   You can use `:file.format_error/1` to get a descriptive string of the error.
@@ -232,17 +232,17 @@ defmodule File do
   end
 
   @doc """
-  Returns a binary with the contents of the given filename or raises
+  Returns binary with the contents of the given filename or raises
   `File.Error` if an error occurs.
   """
   @spec read!(Path.t) :: binary | no_return
   def read!(path) do
+    path = IO.chardata_to_string(path)
     case read(path) do
       {:ok, binary} ->
         binary
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "read file",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "read file", path: path
     end
   end
 
@@ -256,19 +256,11 @@ defmodule File do
 
   The accepted options are:
 
-    * `:time` - configures how the file timestamps are returned
-
-  The values for `:time` can be:
-
-    * `:universal` - returns a `{date, time}` tuple in UTC (default)
-    * `:local` - returns a `{date, time}` tuple using the same time zone as the
-      machine
-    * `:posix` - returns the time as integer seconds since epoch
+    * `:time` - `:local | :universal | :posix`; default: `:local`
 
   """
   @spec stat(Path.t, stat_options) :: {:ok, File.Stat.t} | {:error, posix}
   def stat(path, opts \\ []) do
-    opts = Keyword.put_new(opts, :time, :universal)
     case F.read_file_info(IO.chardata_to_string(path), opts) do
       {:ok, fileinfo} ->
         {:ok, File.Stat.from_record(fileinfo)}
@@ -283,56 +275,11 @@ defmodule File do
   """
   @spec stat!(Path.t, stat_options) :: File.Stat.t | no_return
   def stat!(path, opts \\ []) do
+    path = IO.chardata_to_string(path)
     case stat(path, opts) do
       {:ok, info}      -> info
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "read file stats",
-          path: IO.chardata_to_string(path)
-    end
-  end
-
-  @doc """
-  Returns information about the `path`. If the file is a symlink, sets
-  the `type` to `:symlink` and returns a `File.Stat` struct for the link. For any
-  other file, returns exactly the same values as `stat/2`.
-
-  For more details, see [`:file.read_link_info/2`](http://www.erlang.org/doc/man/file.html#read_link_info-2).
-
-  ## Options
-
-  The accepted options are:
-
-    * `:time` - configures how the file timestamps are returned
-
-  The values for `:time` can be:
-
-    * `:universal` - returns a `{date, time}` tuple in UTC (default)
-    * `:local` - returns a `{date, time}` tuple using the machine time
-    * `:posix` - returns the time as integer seconds since epoch
-
-  """
-  @spec lstat(Path.t, stat_options) :: {:ok, File.Stat.t} | {:error, posix}
-  def lstat(path, opts \\ []) do
-    opts = Keyword.put_new(opts, :time, :universal)
-    case F.read_link_info(IO.chardata_to_string(path), opts) do
-      {:ok, fileinfo} ->
-        {:ok, File.Stat.from_record(fileinfo)}
-      error ->
-        error
-    end
-  end
-
-  @doc """
-  Same as `lstat/2` but returns the `File.Stat` struct directly and
-  throws `File.Error` if an error is returned.
-  """
-  @spec lstat!(Path.t, stat_options) :: File.Stat.t | no_return
-  def lstat!(path, opts \\ []) do
-    case lstat(path, opts) do
-      {:ok, info}      -> info
-      {:error, reason} ->
-        raise File.Error, reason: reason, action: "read file stats",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "read file stats", path: path
     end
   end
 
@@ -342,7 +289,6 @@ defmodule File do
   """
   @spec write_stat(Path.t, File.Stat.t, stat_options) :: :ok | {:error, posix}
   def write_stat(path, stat, opts \\ []) do
-    opts = Keyword.put_new(opts, :time, :universal)
     F.write_file_info(IO.chardata_to_string(path), File.Stat.to_record(stat), opts)
   end
 
@@ -352,24 +298,22 @@ defmodule File do
   """
   @spec write_stat!(Path.t, File.Stat.t, stat_options) :: :ok | no_return
   def write_stat!(path, stat, opts \\ []) do
+    path = IO.chardata_to_string(path)
     case write_stat(path, stat, opts) do
       :ok -> :ok
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "write file stats",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "write file stats", path: path
     end
   end
 
   @doc """
   Updates modification time (mtime) and access time (atime) of
-  the given file.
-
-  The file is created if it doesn’t exist. Requires datetime in UTC.
+  the given file. File is created if it doesn’t exist.
   """
   @spec touch(Path.t, :calendar.datetime) :: :ok | {:error, posix}
-  def touch(path, time \\ :calendar.universal_time) do
+  def touch(path, time \\ :calendar.local_time) do
     path = IO.chardata_to_string(path)
-    case :elixir_utils.change_universal_time(path, time) do
+    case F.change_time(path, time) do
       {:error, :enoent} -> touch_new(path, time)
       other -> other
     end
@@ -377,23 +321,22 @@ defmodule File do
 
   defp touch_new(path, time) do
     case write(path, "", [:append]) do
-      :ok -> :elixir_utils.change_universal_time(path, time)
+      :ok -> F.change_time(path, time)
       {:error, _reason} = error -> error
     end
   end
 
   @doc """
   Same as `touch/2` but raises an exception if it fails.
-
-  Returns `:ok` otherwise. Requires datetime in UTC.
+  Returns `:ok` otherwise.
   """
   @spec touch!(Path.t, :calendar.datetime) :: :ok | no_return
-  def touch!(path, time \\ :calendar.universal_time) do
+  def touch!(path, time \\ :calendar.local_time) do
+    path = IO.chardata_to_string(path)
     case touch(path, time) do
       :ok -> :ok
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "touch",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "touch", path: path
     end
   end
 
@@ -411,7 +354,7 @@ defmodule File do
   @doc """
   Copies the contents of `source` to `destination`.
 
-  Both parameters can be a filename or an IO device opened
+  Both parameters can be a filename or an io device opened
   with `open/2`. `bytes_count` specifies the number of
   bytes to copy, the default being `:infinity`.
 
@@ -430,62 +373,38 @@ defmodule File do
   Typical error reasons are the same as in `open/2`,
   `read/1` and `write/3`.
   """
-  @spec copy(Path.t | io_device, Path.t | io_device, pos_integer | :infinity) :: {:ok, non_neg_integer} | {:error, posix}
+  @spec copy(Path.t, Path.t, pos_integer | :infinity) :: {:ok, non_neg_integer} | {:error, posix}
   def copy(source, destination, bytes_count \\ :infinity) do
-    F.copy(maybe_to_string(source), maybe_to_string(destination), bytes_count)
+    F.copy(IO.chardata_to_string(source), IO.chardata_to_string(destination), bytes_count)
   end
 
   @doc """
   The same as `copy/3` but raises an `File.CopyError` if it fails.
   Returns the `bytes_copied` otherwise.
   """
-  @spec copy!(Path.t | io_device, Path.t | io_device, pos_integer | :infinity) :: non_neg_integer | no_return
+  @spec copy!(Path.t, Path.t, pos_integer | :infinity) :: non_neg_integer | no_return
   def copy!(source, destination, bytes_count \\ :infinity) do
+    source = IO.chardata_to_string(source)
+    destination = IO.chardata_to_string(destination)
     case copy(source, destination, bytes_count) do
       {:ok, bytes_count} -> bytes_count
       {:error, reason} ->
         raise File.CopyError, reason: reason, action: "copy",
-          source: maybe_to_string(source),
-          destination: maybe_to_string(destination)
+          source: source, destination: destination
     end
   end
 
-  @doc """
-  Renames the `source` file to `destination` file.  It can be used to move files
-  (and directories) between directories.  If moving a file, you must fully
-  specify the `destination` filename, it is not sufficient to simply specify
-  its directory.
-
-  It returns `:ok` in case of success, returns `{:error, reason}` otherwise.
-
-  Note: The command `mv` in Unix systems behaves differently depending
-  if `source` is a file and the `destination` is an existing directory.
-  We have chosen to explicitly disallow this behaviour.
-
-  ## Examples
-
-      # Rename file "a.txt" to "b.txt"
-      File.rename "a.txt", "b.txt"
-
-      # Rename directory "samples" to "tmp"
-      File.rename "samples", "tmp"
-  """
-  @spec rename(Path.t, Path.t) :: :ok | {:error, posix}
-  def rename(source, destination) do
-    F.rename(source, destination)
-  end
-
   @doc """
   Copies the contents in `source` to `destination` preserving its mode.
 
   If a file already exists in the destination, it invokes a
   callback which should return `true` if the existing file
-  should be overwritten, `false` otherwise. The callback defaults to return `true`.
+  should be overwritten, `false` otherwise. It defaults to return `true`.
 
-  The function returns `:ok` in case of success, returns
+  It returns `:ok` in case of success, returns
   `{:error, reason}` otherwise.
 
-  If you want to copy contents from an IO device to another device
+  If you want to copy contents from an io device to another device
   or do a straight copy from a source to a destination without
   preserving modes, check `copy/3` instead.
 
@@ -505,24 +424,20 @@ defmodule File do
     end
   end
 
-  defp path_differs?(path, path),
-    do: false
-
-  defp path_differs?(p1, p2) do
-    Path.expand(p1) !== Path.expand(p2)
-  end
-
   @doc """
   The same as `cp/3`, but raises `File.CopyError` if it fails.
-  Returns `:ok` otherwise.
+  Returns the list of copied files otherwise.
   """
   @spec cp!(Path.t, Path.t, (Path.t, Path.t -> boolean)) :: :ok | no_return
   def cp!(source, destination, callback \\ fn(_, _) -> true end) do
+    source = IO.chardata_to_string(source)
+    destination = IO.chardata_to_string(destination)
+
     case cp(source, destination, callback) do
       :ok -> :ok
       {:error, reason} ->
-        raise File.CopyError, reason: reason, action: "copy",
-          source: IO.chardata_to_string(source), destination: IO.chardata_to_string(destination)
+        raise File.CopyError, reason: reason, action: "copy recursively",
+          source: source, destination: destination
     end
   end
 
@@ -536,20 +451,20 @@ defmodule File do
   If a file already exists in the destination,
   it invokes a callback which should return
   `true` if the existing file should be overwritten,
-  `false` otherwise. The callback defaults to return `true`.
+  `false` otherwise. It defaults to return `true`.
 
   If a directory already exists in the destination
-  where a file is meant to be (or vice versa), this
+  where a file is meant to be (or otherwise), this
   function will fail.
 
   This function may fail while copying files,
   in such cases, it will leave the destination
-  directory in a dirty state, where file which have already been copied
-  won't be removed.
+  directory in a dirty state, where already
+  copied files won't be removed.
 
-  The function returns `{:ok, files_and_directories}` in case of
-  success, `files_and_directories` lists all files and directories copied in no
-  specific order. It returns `{:error, reason, file}` otherwise.
+  It returns `{:ok, files_and_directories}` in case of
+  success with all files and directories copied in no
+  specific order, `{:error, reason, file}` otherwise.
 
   Note: The command `cp` in Unix systems behaves differently
   depending if `destination` is an existing directory or not.
@@ -557,15 +472,15 @@ defmodule File do
 
   ## Examples
 
-      # Copies file "a.txt" to "b.txt"
-      File.cp_r "a.txt", "b.txt"
+      # Copies "a.txt" to "tmp"
+      File.cp_r "a.txt", "tmp.txt"
 
       # Copies all files in "samples" to "tmp"
       File.cp_r "samples", "tmp"
 
       # Same as before, but asks the user how to proceed in case of conflicts
       File.cp_r "samples", "tmp", fn(source, destination) ->
-        IO.gets("Overwriting #{destination} by #{source}. Type y to confirm. ") == "y\n"
+        IO.gets("Overwriting #{destination} by #{source}. Type y to confirm.") == "y"
       end
 
   """
@@ -586,11 +501,14 @@ defmodule File do
   """
   @spec cp_r!(Path.t, Path.t, (Path.t, Path.t -> boolean)) :: [binary] | no_return
   def cp_r!(source, destination, callback \\ fn(_, _) -> true end) do
+    source = IO.chardata_to_string(source)
+    destination = IO.chardata_to_string(destination)
+
     case cp_r(source, destination, callback) do
       {:ok, files} -> files
       {:error, reason, file} ->
-        raise File.CopyError, reason: reason, action: "copy recursively", on: file,
-          source: IO.chardata_to_string(source), destination: IO.chardata_to_string(destination)
+        raise File.CopyError, reason: reason, action: "copy recursively",
+          source: source, destination: destination, on: file
     end
   end
 
@@ -610,7 +528,7 @@ defmodule File do
           {:ok, files} ->
             case mkdir(dest) do
               success when success in [:ok, {:error, :eexist}] ->
-                Enum.reduce(files, [dest | acc], fn(x, acc) ->
+                Enum.reduce(files, [dest|acc], fn(x, acc) ->
                   do_cp_r(Path.join(src, x), Path.join(dest, x), callback, acc)
                 end)
               {:error, reason} -> {:error, reason, dest}
@@ -637,13 +555,15 @@ defmodule File do
     case F.copy(src, {dest, [:exclusive]}) do
       {:ok, _} ->
         copy_file_mode!(src, dest)
-        [dest | acc]
+        [dest|acc]
       {:error, :eexist} ->
-        if path_differs?(src, dest) and callback.(src, dest) do
+        if callback.(src, dest) do
+          # If rm/1 fails, copy/2 will fail
+          _ = rm(dest)
           case copy(src, dest) do
             {:ok, _} ->
               copy_file_mode!(src, dest)
-              [dest | acc]
+              [dest|acc]
             {:error, reason} -> {:error, reason, src}
           end
         else
@@ -657,13 +577,13 @@ defmodule File do
   defp do_cp_link(link, src, dest, callback, acc) do
     case F.make_symlink(link, dest) do
       :ok ->
-        [dest | acc]
+        [dest|acc]
       {:error, :eexist} ->
-        if path_differs?(src, dest) and callback.(src, dest) do
-          # If rm/1 fails, F.make_symlink/2 will fail
+        if callback.(src, dest) do
+          # If rm/1 fails, iF.make_symlink/2 will fail
           _ = rm(dest)
           case F.make_symlink(link, dest) do
-            :ok -> [dest | acc]
+            :ok -> [dest|acc]
             {:error, reason} -> {:error, reason, src}
           end
         else
@@ -684,23 +604,22 @@ defmodule File do
   and a new process is spawned to write to the file. For this reason, if you are
   doing multiple writes in a loop, opening the file via `File.open/2` and using
   the functions in `IO` to write to the file will yield much better performance
-  than calling this function multiple times.
+  then calling this function multiple times.
 
   Typical error reasons are:
 
     * `:enoent`  - a component of the file name does not exist
     * `:enotdir` - a component of the file name is not a directory;
-      on some platforms, `:enoent` is returned instead
+                   on some platforms, enoent is returned instead
     * `:enospc`  - there is a no space left on the device
     * `:eacces`  - missing permission for writing the file or searching one of
-      the parent directories
+                   the parent directories
     * `:eisdir`  - the named file is a directory
 
   Check `File.open/2` for other available options.
   """
   @spec write(Path.t, iodata, [mode]) :: :ok | {:error, posix}
   def write(path, content, modes \\ []) do
-    modes = normalize_modes(modes, false)
     F.write_file(IO.chardata_to_string(path), content, modes)
   end
 
@@ -709,12 +628,11 @@ defmodule File do
   """
   @spec write!(Path.t, iodata, [mode]) :: :ok | no_return
   def write!(path, content, modes \\ []) do
-    modes = normalize_modes(modes, false)
+    path = IO.chardata_to_string(path)
     case F.write_file(path, content, modes) do
       :ok -> :ok
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "write to file",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "write to file", path: path
     end
   end
 
@@ -722,7 +640,6 @@ defmodule File do
   Tries to delete the file `path`.
 
   Returns `:ok` if successful, or `{:error, reason}` if an error occurs.
-
   Note the file is deleted even if in read-only mode.
 
   Typical error reasons are:
@@ -731,15 +648,15 @@ defmodule File do
     * `:eacces`  - missing permission for the file or one of its parents
     * `:eperm`   - the file is a directory and user is not super-user
     * `:enotdir` - a component of the file name is not a directory;
-      on some platforms, `:enoent` is returned instead
+                   on some platforms, enoent is returned instead
     * `:einval`  - filename had an improper type, such as tuple
 
   ## Examples
 
-      File.rm("file.txt")
+      File.rm('file.txt')
       #=> :ok
 
-      File.rm("tmp_dir/")
+      File.rm('tmp_dir/')
       #=> {:error, :eperm}
 
   """
@@ -758,7 +675,7 @@ defmodule File do
 
   defp change_mode_windows(path) do
     if match? {:win32, _}, :os.type do
-      case F.read_file_info(path) do
+      case F.read_file_info(IO.chardata_to_string(path)) do
         {:ok, file_info} when elem(file_info, 3) in [:read, :none] ->
           change_mode_windows(path, file_info)
         _ ->
@@ -768,7 +685,7 @@ defmodule File do
   end
 
   defp change_mode_windows(path, file_info) do
-    case chmod(path, (elem(file_info, 7) + 0o200)) do
+    case File.chmod(path, (elem(file_info, 7) + 0o200)) do
       :ok -> F.delete(path)
       {:error, _reason} = error -> error
     end
@@ -779,11 +696,11 @@ defmodule File do
   """
   @spec rm!(Path.t) :: :ok | no_return
   def rm!(path) do
+    path = IO.chardata_to_string(path)
     case rm(path) do
       :ok -> :ok
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "remove file",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "remove file", path: path
     end
   end
 
@@ -810,16 +727,16 @@ defmodule File do
   """
   @spec rmdir!(Path.t) :: :ok | {:error, posix}
   def rmdir!(path) do
+    path = IO.chardata_to_string(path)
     case rmdir(path) do
       :ok -> :ok
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "remove directory",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "remove directory", path: path
     end
   end
 
   @doc """
-  Removes files and directories recursively at the given `path`.
+  Remove files and directories recursively at the given `path`.
   Symlinks are not followed but simply removed, non-existing
   files are simply ignored (i.e. doesn't make this function fail).
 
@@ -852,7 +769,7 @@ defmodule File do
         case res do
           {:ok, acc} ->
             case rmdir(path) do
-              :ok -> {:ok, [path | acc]}
+              :ok -> {:ok, [path|acc]}
               {:error, :enoent} -> res
               {:error, reason} -> {:error, reason, path}
             end
@@ -872,19 +789,19 @@ defmodule File do
 
   defp do_rm_regular(path, {:ok, acc} = entry) do
     case rm(path) do
-      :ok -> {:ok, [path | acc]}
+      :ok -> {:ok, [path|acc]}
       {:error, :enoent} -> entry
       {:error, reason} -> {:error, reason, path}
     end
   end
 
-  # On Windows, symlinks are treated as directory and must be removed
+  # On windows, symlinks are treated as directory and must be removed
   # with rmdir/1. But on Unix, we remove them via rm/1. So we first try
   # to remove it as a directory and, if we get :enotdir, we fallback to
   # a file removal.
   defp do_rm_directory(path, {:ok, acc} = entry) do
     case rmdir(path) do
-      :ok -> {:ok, [path | acc]}
+      :ok -> {:ok, [path|acc]}
       {:error, :enotdir} -> do_rm_regular(path, entry)
       {:error, :enoent} -> entry
       {:error, reason} -> {:error, reason, path}
@@ -913,19 +830,20 @@ defmodule File do
   """
   @spec rm_rf!(Path.t) :: [binary] | no_return
   def rm_rf!(path) do
+    path = IO.chardata_to_string(path)
     case rm_rf(path) do
       {:ok, files} -> files
       {:error, reason, _} ->
-        raise File.Error, reason: reason, path: IO.chardata_to_string(path),
+        raise File.Error, reason: reason, path: path,
           action: "remove files and directories recursively from"
     end
   end
 
   @doc ~S"""
-  Opens the given `path` according to the given list of `modes`.
+  Opens the given `path` according to the given list of modes.
 
   In order to write and read files, one must use the functions
-  in the `IO` module. By default, a file is opened in `:binary` mode,
+  in the `IO` module. By default, a file is opened in binary mode
   which requires the functions `IO.binread/2` and `IO.binwrite/2`
   to interact with the file. A developer may pass `:utf8` as an
   option when opening the file and then all other functions from
@@ -933,9 +851,6 @@ defmodule File do
 
   The allowed modes:
 
-    * `:binary` - opens the file in binary mode, disabling special handling of unicode sequences
-      (default mode).
-
     * `:read` - the file, which must exist, is opened for reading.
 
     * `:write` - the file is opened for writing. It is created if it does not
@@ -951,8 +866,8 @@ defmodule File do
     * `:exclusive` - the file, when opened for writing, is created if it does
       not exist. If the file exists, open will return `{:error, :eexist}`.
 
-    * `:charlist` - when this term is given, read operations on the file will
-      return charlists rather than binaries.
+    * `:char_list` - when this term is given, read operations on the file will
+      return char lists rather than binaries.
 
     * `:compressed` - makes it possible to read or write gzip compressed files.
 
@@ -962,16 +877,15 @@ defmodule File do
 
     * `:utf8` - this option denotes how data is actually stored in the disk
       file and makes the file perform automatic translation of characters to
-      and from UTF-8.
+      and from utf-8.
 
       If data is sent to a file in a format that cannot be converted to the
-      UTF-8 or if data is read by a function that returns data in a format that
+      utf-8 or if data is read by a function that returns data in a format that
       cannot cope with the character range of the data, an error occurs and the
       file will be closed.
 
-    * `:delayed_write`, `:raw`, `:ram`, `:read_ahead`, `:sync`, `{:encoding, ...}`,
-      `{:read_ahead, pos_integer}`, `{:delayed_write, non_neg_integer, non_neg_integer}` -
-      for more information about these options see [`:file.open/2`](http://www.erlang.org/doc/man/file.html#open-2).
+  Check http://www.erlang.org/doc/man/file.html#open-2 for more information about
+  other options like `:read_ahead` and `:delayed_write`.
 
   This function returns:
 
@@ -999,7 +913,7 @@ defmodule File do
   def open(path, modes \\ [])
 
   def open(path, modes) when is_list(modes) do
-    F.open(IO.chardata_to_string(path), normalize_modes(modes, true))
+    F.open(IO.chardata_to_string(path), open_defaults(modes, true))
   end
 
   def open(path, function) when is_function(function) do
@@ -1007,9 +921,9 @@ defmodule File do
   end
 
   @doc """
-  Similar to `open/2` but expects a function as its last argument.
+  Similar to `open/2` but expects a function as last argument.
 
-  The file is opened, given to the function as an argument and
+  The file is opened, given to the function as argument and
   automatically closed after the function returns, regardless
   if there was an error when executing the function.
 
@@ -1048,10 +962,11 @@ defmodule File do
   """
   @spec open!(Path.t, [mode]) :: io_device | no_return
   def open!(path, modes \\ []) do
+    path = IO.chardata_to_string(path)
     case open(path, modes) do
       {:ok, device}    -> device
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "open", path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "open", path: path
     end
   end
 
@@ -1062,10 +977,11 @@ defmodule File do
   """
   @spec open!(Path.t, [mode | :ram], (io_device -> res)) :: res | no_return when res: var
   def open!(path, modes, function) do
+    path = IO.chardata_to_string(path)
     case open(path, modes, function) do
       {:ok, device}    -> device
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "open", path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "open", path: path
     end
   end
 
@@ -1073,7 +989,7 @@ defmodule File do
   Gets the current working directory.
 
   In rare circumstances, this function can fail on Unix. It may happen
-  if read permissions do not exist for the parent directories of the
+  if read permission does not exist for the parent directories of the
   current directory. For this reason, returns `{:ok, cwd}` in case
   of success, `{:error, reason}` otherwise.
   """
@@ -1102,7 +1018,7 @@ defmodule File do
     case cwd() do
       {:ok, cwd} -> cwd
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "get current working directory"
+          raise File.Error, reason: reason, action: "get current working directory"
     end
   end
 
@@ -1121,18 +1037,18 @@ defmodule File do
   """
   @spec cd!(Path.t) :: :ok | no_return
   def cd!(path) do
-    case cd(path) do
+    path = IO.chardata_to_string(path)
+    case F.set_cwd(path) do
       :ok -> :ok
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "set current working directory to",
-          path: IO.chardata_to_string(path)
+          raise File.Error, reason: reason, action: "set current working directory to", path: path
     end
   end
 
   @doc """
   Changes the current directory to the given `path`,
-  executes the given function and then reverts back
-  to the previous path regardless of whether there is an exception.
+  executes the given function and then revert back
+  to the previous path regardless if there is an exception.
 
   Raises an error if retrieving or changing the current
   directory fails.
@@ -1149,7 +1065,7 @@ defmodule File do
   end
 
   @doc """
-  Returns the list of files in the given directory.
+  Returns list of files in the given directory.
 
   It returns `{:ok, [files]}` in case of success,
   `{:error, reason}` otherwise.
@@ -1168,11 +1084,11 @@ defmodule File do
   """
   @spec ls!(Path.t) :: [binary] | no_return
   def ls!(path \\ ".") do
+    path = IO.chardata_to_string(path)
     case ls(path) do
       {:ok, value} -> value
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "list directory",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "list directory", path: path
     end
   end
 
@@ -1199,9 +1115,9 @@ defmodule File do
   streaming, by `:line` (default) or by a given number of bytes.
 
   Operating the stream can fail on open for the same reasons as
-  `File.open!/2`. Note that the file is automatically opened each time streaming
-  begins. There is no need to pass `:read` and `:write` modes, as those are
-  automatically set by Elixir.
+  `File.open!/2`. Note that the file is automatically opened only and
+  every time streaming begins. There is no need to pass `:read` and
+  `:write` modes, as those are automatically set by Elixir.
 
   ## Raw files
 
@@ -1209,52 +1125,20 @@ defmodule File do
   device cannot be shared and as such it is convenient to open the file
   in raw mode for performance reasons. Therefore, Elixir **will** open
   streams in `:raw` mode with the `:read_ahead` option unless an encoding
-  is specified. This means any data streamed into the file must be
-  converted to `iodata` type. If you pass `[:utf8]` in the modes parameter,
-  the underlying stream will use `IO.write/2` and the `String.Chars` protocol
-  to convert the data. See `IO.binwrite/2` and `IO.write/2` .
+  is specified.
 
   One may also consider passing the `:delayed_write` option if the stream
   is meant to be written to under a tight loop.
-
-  ## Examples
-
-      # Read in 2048 byte chunks rather than lines
-      File.stream!("./test/test.data", [], 2048)
-      #=>  %File.Stream{line_or_bytes: 2048, modes: [:raw, :read_ahead, :binary],
-      #=> path: "./test/test.data", raw: true}
-
-  See `Stream.run/1` for an example of streaming into a file.
-
   """
   def stream!(path, modes \\ [], line_or_bytes \\ :line) do
-    modes = normalize_modes(modes, true)
+    modes = open_defaults(modes, true)
     File.Stream.__build__(IO.chardata_to_string(path), modes, line_or_bytes)
   end
 
   @doc """
-  Changes the `mode` for a given `file`.
-
-  Returns `:ok` on success, or `{:error, reason}` on failure.
-
-  ## Permissions
-
-    * 0o400 - read permission: owner
-    * 0o200 - write permission: owner
-    * 0o100 - execute permission: owner
-
-    * 0o040 - read permission: group
-    * 0o020 - write permission: group
-    * 0o010 - execute permission: group
-
-    * 0o004 - read permission: other
-    * 0o002 - write permission: other
-    * 0o001 - execute permission: other
-
-  For example, setting the mode 0o755 gives it
-  write, read and execute permission to the owner
-  and both read and execute permission to group
-  and others.
+  Changes the unix file `mode` for a given `file`.
+  Returns `:ok` on success, or `{:error, reason}`
+  on failure.
   """
   @spec chmod(Path.t, non_neg_integer) :: :ok | {:error, posix}
   def chmod(path, mode) do
@@ -1266,16 +1150,16 @@ defmodule File do
   """
   @spec chmod!(Path.t, non_neg_integer) :: :ok | no_return
   def chmod!(path, mode) do
+    path = IO.chardata_to_string(path)
     case chmod(path, mode) do
       :ok -> :ok
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "change mode for",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "change mode for", path: path
     end
   end
 
   @doc """
-  Changes the group given by the group id `gid`
+  Changes the user group given by the group id `gid`
   for a given `file`. Returns `:ok` on success, or
   `{:error, reason}` on failure.
   """
@@ -1289,11 +1173,11 @@ defmodule File do
   """
   @spec chgrp!(Path.t, non_neg_integer) :: :ok | no_return
   def chgrp!(path, gid) do
+    path = IO.chardata_to_string(path)
     case chgrp(path, gid) do
       :ok -> :ok
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "change group for",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "change group for", path: path
     end
   end
 
@@ -1312,36 +1196,34 @@ defmodule File do
   """
   @spec chown!(Path.t, non_neg_integer) :: :ok | no_return
   def chown!(path, uid) do
+    path = IO.chardata_to_string(path)
     case chown(path, uid) do
       :ok -> :ok
       {:error, reason} ->
-        raise File.Error, reason: reason, action: "change owner for",
-          path: IO.chardata_to_string(path)
+        raise File.Error, reason: reason, action: "change owner for", path: path
     end
   end
 
   ## Helpers
 
-  @read_ahead_size 64 * 1024
+  @read_ahead 64*1024
 
-  defp normalize_modes([:utf8 | rest], binary?) do
-    [encoding: :utf8] ++ normalize_modes(rest, binary?)
+  defp open_defaults([:char_list|t], _add_binary) do
+    open_defaults(t, false)
   end
-  defp normalize_modes([:read_ahead | rest], binary?) do
-    [read_ahead: @read_ahead_size] ++ normalize_modes(rest, binary?)
-  end
-  # TODO: Deprecate :char_list mode by v1.5
-  defp normalize_modes([mode | rest], _binary?) when mode in [:charlist, :char_list] do
-    normalize_modes(rest, false)
-  end
-  defp normalize_modes([mode | rest], binary?) do
-    [mode | normalize_modes(rest, binary?)]
-  end
-  defp normalize_modes([], true), do: [:binary]
-  defp normalize_modes([], false), do: []
 
-  defp maybe_to_string(path) when is_pid(path),
-    do: path
-  defp maybe_to_string(path),
-    do: IO.chardata_to_string(path)
+  defp open_defaults([:utf8|t], add_binary) do
+    open_defaults([{:encoding, :utf8}|t], add_binary)
+  end
+
+  defp open_defaults([:read_ahead|t], add_binary) do
+    open_defaults([{:read_ahead, @read_ahead}|t], add_binary)
+  end
+
+  defp open_defaults([h|t], add_binary) do
+    [h|open_defaults(t, add_binary)]
+  end
+
+  defp open_defaults([], true),  do: [:binary]
+  defp open_defaults([], false), do: []
 end

lib/elixir/lib/file/stat.ex

@@ -2,11 +2,11 @@ require Record
 
 defmodule File.Stat do
   @moduledoc """
-  A struct that holds file information.
+  A struct responsible to hold file information.
 
   In Erlang, this struct is represented by a `:file_info` record.
   Therefore this module also provides functions for converting
-  between the Erlang record and the Elixir struct.
+  in between the Erlang record and the Elixir struct.
 
   Its fields are:
 
@@ -32,7 +32,7 @@ defmodule File.Stat do
       systems which have no concept of links.
 
     * `major_device` - identifies the file system where the file is located.
-      In Windows, the number indicates a drive as follows: 0 means A:, 1 means
+      In windows, the number indicates a drive as follows: 0 means A:, 1 means
       B:, and so on.
 
     * `minor_device` - only valid for character devices on Unix. In all other
@@ -41,15 +41,14 @@ defmodule File.Stat do
     * `inode` - gives the inode number. On non-Unix file systems, this field
       will be zero.
 
-    * `uid` - indicates the owner of the file. Will be zero for non-Unix file
-      systems.
+    * `uid` - indicates the owner of the file.
 
-    * `gid` - indicates the group that owns the file. Will be zero for
-      non-Unix file systems.
+    * `gid` - gives the group that the owner of the file belongs to. Will be
+      zero for non-Unix file systems.
 
   The time type returned in `atime`, `mtime`, and `ctime` is dependent on the
   time type set in options. `{:time, type}` where type can be `:local`,
-  `:universal`, or `:posix`. Default is `:universal`.
+  `:universal`, or `:posix`. Default is `:local`.
   """
 
   record = Record.extract(:file_info, from_lib: "kernel/include/file.hrl")
@@ -70,7 +69,6 @@ defmodule File.Stat do
   @doc """
   Converts a `:file_info` record into a `File.Stat`.
   """
-  def from_record(file_info)
   def from_record({:file_info, unquote_splicing(vals)}) do
     %File.Stat{unquote_splicing(pairs)}
   end

lib/elixir/lib/file/stream.ex

@@ -20,25 +20,28 @@ defmodule File.Stream do
     raw = :lists.keyfind(:encoding, 1, modes) == false
 
     modes =
-      case raw do
-        true ->
-          if :lists.keyfind(:read_ahead, 1, modes) == {:read_ahead, false} do
-            [:raw | modes]
-          else
-            [:raw, :read_ahead | modes]
-          end
-        false ->
-          modes
+      if raw do
+        if :lists.keyfind(:read_ahead, 1, modes) == {:read_ahead, false} do
+          [:raw|modes]
+        else
+          [:raw, :read_ahead|modes]
+        end
+      else
+        modes
       end
 
     %File.Stream{path: path, modes: modes, raw: raw, line_or_bytes: line_or_bytes}
   end
 
   defimpl Collectable do
+    def empty(stream) do
+      stream
+    end
+
     def into(%{path: path, modes: modes, raw: raw} = stream) do
       modes = for mode <- modes, not mode in [:read], do: mode
 
-      case :file.open(path, [:write | modes]) do
+      case :file.open(path, [:write|modes]) do
         {:ok, device} ->
           {:ok, into(device, stream, raw)}
         {:error, reason} ->

lib/elixir/lib/float.ex

@@ -8,26 +8,19 @@ defmodule Float do
   @doc """
   Parses a binary into a float.
 
-  If successful, returns a tuple in the form of `{float, remainder_of_binary}`;
-  when the binary cannot be coerced into a valid float, the atom `:error` is
-  returned.
-
-  If the size of float exceeds the maximum size of `1.7976931348623157e+308`,
-  the `ArgumentError` exception is raised.
-
-  If you want to convert a string-formatted float directly to a float,
-  `String.to_float/1` can be used instead.
+  If successful, returns a tuple of the form `{float, remainder_of_binary}`.
+  Otherwise `:error`.
 
   ## Examples
 
       iex> Float.parse("34")
-      {34.0, ""}
+      {34.0,""}
 
       iex> Float.parse("34.25")
-      {34.25, ""}
+      {34.25,""}
 
       iex> Float.parse("56.5xyz")
-      {56.5, "xyz"}
+      {56.5,"xyz"}
 
       iex> Float.parse("pi")
       :error
@@ -35,51 +28,83 @@ defmodule Float do
   """
   @spec parse(binary) :: {float, binary} | :error
   def parse("-" <> binary) do
-    case parse_unsigned(binary) do
+    case parse_unsign(binary) do
       :error -> :error
       {number, remainder} -> {-number, remainder}
     end
   end
 
-  def parse("+" <> binary) do
-    parse_unsigned(binary)
-  end
-
   def parse(binary) do
-    parse_unsigned(binary)
+    parse_unsign(binary)
   end
 
-  defp parse_unsigned(<<digit, rest::binary>>) when digit in ?0..?9, do:
-    parse_unsigned(rest, false, false, <<digit>>)
+  defp parse_unsign("-" <> _), do: :error
+  defp parse_unsign(binary) when is_binary(binary) do
+    case Integer.parse binary do
+      :error -> :error
+      {integer_part, after_integer} -> parse_unsign after_integer, integer_part
+    end
+  end
 
-  defp parse_unsigned(binary) when is_binary(binary), do:
-    :error
+  # Dot followed by digit is required afterwards or we are done
+  defp parse_unsign(<< ?., char, rest :: binary >>, int) when char in ?0..?9 do
+    parse_unsign(rest, char - ?0, 1, int)
+  end
 
-  defp parse_unsigned(<<digit, rest::binary>>, dot?, e?, acc) when digit in ?0..?9, do:
-    parse_unsigned(rest, dot?, e?, <<acc::binary, digit>>)
+  defp parse_unsign(rest, int) do
+    {:erlang.float(int), rest}
+  end
 
-  defp parse_unsigned(<<?., digit, rest::binary>>, false, false, acc) when digit in ?0..?9, do:
-    parse_unsigned(rest, true, false, <<acc::binary, ?., digit>>)
+  # Handle decimal points
+  defp parse_unsign(<< char, rest :: binary >>, float, decimal, int) when char in ?0..?9 do
+    parse_unsign rest, 10 * float + (char - ?0), decimal + 1, int
+  end
 
-  defp parse_unsigned(<<exp_marker, digit, rest::binary>>, dot?, false, acc) when exp_marker in 'eE' and  digit in ?0..?9, do:
-    parse_unsigned(rest, true, true, <<add_dot(acc, dot?)::binary, ?e, digit>>)
+  defp parse_unsign(<< ?e, after_e :: binary >>, float, decimal, int) do
+    case Integer.parse after_e do
+      :error ->
+        # Note we rebuild the binary here instead of breaking it apart at
+        # the function clause because the current approach copies a binary
+        # just on this branch. If we broke it apart in the function clause,
+        # the copy would happen when calling Integer.parse/1.
+        {floatify(int, float, decimal), << ?e, after_e :: binary >>}
+      {exponential, after_exponential} ->
+        {floatify(int, float, decimal, exponential), after_exponential}
+    end
+  end
 
-  defp parse_unsigned(<<exp_marker, sign, digit, rest::binary>>, dot?, false, acc) when exp_marker in 'eE' and sign in '-+' and digit in ?0..?9, do:
-    parse_unsigned(rest, true, true, <<add_dot(acc, dot?)::binary, ?e, sign, digit>>)
+  defp parse_unsign(bitstring, float, decimal, int) do
+    {floatify(int, float, decimal), bitstring}
+  end
 
-  defp parse_unsigned(rest, dot?, _e?, acc), do:
-    {:erlang.binary_to_float(add_dot(acc, dot?)), rest}
+  defp floatify(int, float, decimal, exponential \\ 0) do
+    multiplier = if int < 0, do: -1.0, else: 1.0
 
-  defp add_dot(acc, true),  do: acc
-  defp add_dot(acc, false), do: acc <> ".0"
+    # Try to ensure the minimum amount of rounding errors
+    result = multiplier * (abs(int) * :math.pow(10, decimal) + float) * :math.pow(10, exponential - decimal)
+
+    # Try avoiding stuff like this:
+    # iex(1)> 0.0001 * 75
+    # 0.007500000000000001
+    # Due to IEEE 754 floating point standard
+    # http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
+
+    final_decimal_places = decimal - exponential
+    if final_decimal_places > 0 do
+      decimal_power_round = :math.pow(10,  final_decimal_places)
+      trunc(result * decimal_power_round) / decimal_power_round
+    else
+      result
+    end
+  end
 
   @doc """
   Rounds a float to the largest integer less than or equal to `num`.
 
-  `floor/2` also accepts a precision to round a floating point value down
+  Floor also accepts a precision to round a floating point value down
   to an arbitrary number of fractional digits (between 0 and 15).
 
-  This function always returns a float. `Kernel.trunc/1` may be used instead to
+  This function always returns floats. One may use `Kernel.trunc/1` to
   truncate the result to an integer afterwards.
 
   ## Examples
@@ -90,7 +115,7 @@ defmodule Float do
       iex> Float.floor(-56.5)
       -57.0
 
-      iex> Float.floor(34.259, 2)
+      iex> Float.floor(34.253, 2)
       34.25
 
   """
@@ -104,12 +129,12 @@ defmodule Float do
   end
 
   @doc """
-  Rounds a float to the smallest integer greater than or equal to `num`.
+  Rounds a float to the largest integer greater than or equal to `num`.
 
-  `ceil/2` also accepts a precision to round a floating point value down
-  to an arbitrary number of fractional digits (between 0 and 15).
+  Ceil also accepts a precision to round a floating point value down to
+  an arbitrary number of fractional digits (between 0 and 15).
 
-  This function always returns floats. `Kernel.trunc/1` may be used instead to
+  This function always returns floats. One may use `Kernel.trunc/1` to
   truncate the result to an integer afterwards.
 
   ## Examples
@@ -120,7 +145,7 @@ defmodule Float do
       iex> Float.ceil(-56.5)
       -56.0
 
-      iex> Float.ceil(34.251, 2)
+      iex> Float.ceil(34.253, 2)
       34.26
 
   """
@@ -137,9 +162,9 @@ defmodule Float do
   Rounds a floating point value to an arbitrary number of fractional digits
   (between 0 and 15).
 
-  This function only accepts floats and always returns a float. Use
-  `Kernel.round/1` if you want a function that accepts both floats and integers
-  and always returns an integer.
+  This function only accepts floats and returns floats. Use `Kernel.round/1`
+  if you want a function that accepts both floats and integers and always
+  returns an integer.
 
   ## Examples
 
@@ -155,9 +180,6 @@ defmodule Float do
       iex> Float.round(-5.5675, 3)
       -5.568
 
-      iex> Float.round(-5.5675)
-      -6.0
-
   """
   @spec round(float, 0..15) :: float
   def round(number, precision \\ 0) when is_float(number) and precision in 0..15 do
@@ -171,63 +193,84 @@ defmodule Float do
   end
 
   @doc """
-  Returns a charlist which corresponds to the text representation
-  of the given float.
+  Returns a char list which corresponds to the text representation of the given float.
 
-  It uses the shortest representation according to algorithm described
-  in "Printing Floating-Point Numbers Quickly and Accurately" in
-  Proceedings of the SIGPLAN '96 Conference on Programming Language
-  Design and Implementation.
+  Inlined by the compiler.
 
   ## Examples
 
-      iex> Float.to_charlist(7.0)
-      '7.0'
+      iex> Float.to_char_list(7.0)
+      '7.00000000000000000000e+00'
 
   """
-  @spec to_charlist(float) :: charlist
-  def to_charlist(float) when is_float(float) do
-    :io_lib_format.fwrite_g(float)
+  @spec to_char_list(float) :: char_list
+  def to_char_list(number) do
+    :erlang.float_to_list(number)
   end
 
   @doc """
-  Returns a binary which corresponds to the text representation
-  of the given float.
+  Returns a list which corresponds to the text representation
+  of `float`.
 
-  It uses the shortest representation according to algorithm described
-  in "Printing Floating-Point Numbers Quickly and Accurately" in
-  Proceedings of the SIGPLAN '96 Conference on Programming Language
-  Design and Implementation.
+  ## Options
+
+    * `:decimals`   — number of decimal points to show
+    * `:scientific` — number of decimal points to show, in scientific format
+    * `:compact`    — when true, use the most compact representation (ignored
+                      with the `scientific` option)
 
   ## Examples
 
-      iex> Float.to_string(7.0)
-      "7.0"
+      iex> Float.to_char_list 7.1, [decimals: 2, compact: true]
+      '7.1'
 
   """
-  @spec to_string(float) :: String.t
-  def to_string(float) when is_float(float) do
-    IO.iodata_to_binary(:io_lib_format.fwrite_g(float))
-  end
-
-  # TODO: Deprecate by v1.5
-  @doc false
-  def to_char_list(float), do: Float.to_charlist(float)
-
-  # TODO: Deprecate by v1.4
-  @doc false
+  @spec to_char_list(float, list) :: char_list
   def to_char_list(float, options) do
     :erlang.float_to_list(float, expand_compact(options))
   end
 
-  # TODO: Deprecate by v1.4
-  @doc false
+  @doc """
+  Returns a binary which corresponds to the text representation
+  of `some_float`.
+
+  Inlined by the compiler.
+
+  ## Examples
+
+      iex> Float.to_string(7.0)
+      "7.00000000000000000000e+00"
+
+  """
+  @spec to_string(float) :: String.t
+  def to_string(some_float) do
+    :erlang.float_to_binary(some_float)
+  end
+
+  @doc """
+  Returns a binary which corresponds to the text representation
+  of `float`.
+
+  ## Options
+
+    * `:decimals`   — number of decimal points to show
+    * `:scientific` — number of decimal points to show, in scientific format
+    * `:compact`    — when true, use the most compact representation (ignored
+                      with the `scientific` option)
+
+  ## Examples
+
+      iex> Float.to_string 7.1, [decimals: 2, compact: true]
+      "7.1"
+
+  """
+  @spec to_string(float, list) :: String.t
   def to_string(float, options) do
     :erlang.float_to_binary(float, expand_compact(options))
   end
 
-  defp expand_compact([{:compact, false} | t]), do: expand_compact(t)
-  defp expand_compact([{:compact, true} | t]),  do: [:compact | expand_compact(t)]
-  defp expand_compact([h | t]),                 do: [h | expand_compact(t)]
-  defp expand_compact([]),                      do: []
+  defp expand_compact([{:compact, false}|t]), do: expand_compact(t)
+  defp expand_compact([{:compact, true}|t]),  do: [:compact|expand_compact(t)]
+  defp expand_compact([h|t]),                 do: [h|expand_compact(t)]
+  defp expand_compact([]),                    do: []
 end

lib/elixir/lib/gen_event.ex

@@ -8,13 +8,13 @@ defmodule GenEvent do
 
   An event manager implemented using this module will have a standard
   set of interface functions and include functionality for tracing and
-  error reporting. It will also fit into a supervision tree.
+  error reporting. It will also fit into an supervision tree.
 
   ## Example
 
   There are many use cases for event handlers. For example, a logging
   system can be built using event handlers where each log message is
-  an event and different event handlers can be attached to handle the
+  an event and different event handlers can be plugged to handle the
   log messages. One handler may print error messages on the terminal,
   another can write it to a file, while a third one can keep the
   messages in memory (like a buffer) until they are read.
@@ -22,14 +22,13 @@ defmodule GenEvent do
   As an example, let's have a GenEvent that accumulates messages until
   they are collected by an explicit call.
 
-      # Define an Event Handler
       defmodule LoggerHandler do
         use GenEvent
 
         # Callbacks
 
         def handle_event({:log, x}, messages) do
-          {:ok, [x | messages]}
+          {:ok, [x|messages]}
         end
 
         def handle_call(:messages, messages) do
@@ -37,40 +36,84 @@ defmodule GenEvent do
         end
       end
 
-      # Start a new event manager.
-      {:ok, pid} = GenEvent.start_link([])
+      {:ok, pid} = GenEvent.start_link()
 
-      # Attach an event handler to the event manager.
       GenEvent.add_handler(pid, LoggerHandler, [])
       #=> :ok
 
-      # Send some events to the event manager.
       GenEvent.notify(pid, {:log, 1})
       #=> :ok
 
       GenEvent.notify(pid, {:log, 2})
       #=> :ok
 
-      # Call functions on specific handlers in the manager.
       GenEvent.call(pid, LoggerHandler, :messages)
       #=> [1, 2]
 
       GenEvent.call(pid, LoggerHandler, :messages)
       #=> []
 
-  We start a new event manager by calling `GenEvent.start_link/1`.
+  We start a new event manager by calling `GenEvent.start_link/0`.
   Notifications can be sent to the event manager which will then
   invoke `handle_event/2` for each registered handler.
 
-  We can add new handlers with `add_handler/3` and `add_mon_handler/3`.
-  Calls can also be made to specific handlers by using `call/3`.
+  We can add new handlers with `add_handler/3`. Calls can also
+  be made to specific handlers by using `call/3`.
 
   ## Callbacks
 
   There are 6 callbacks required to be implemented in a `GenEvent`. By
   adding `use GenEvent` to your module, Elixir will automatically define
   all 6 callbacks for you, leaving it up to you to implement the ones
-  you want to customize.
+  you want to customize. The callbacks are:
+
+    * `init(args)` - invoked when the event handler is added.
+
+      It must return:
+
+      -  `{:ok, state}`
+      -  `{:ok, state, :hibernate}`
+      -  `{:error, reason}`
+
+    * `handle_event(msg, state)` - invoked whenever an event is sent via
+      `notify/2`, `ack_notify/2` or `sync_notify/2`.
+
+      It must return:
+
+      -  `{:ok, new_state}`
+      -  `{:ok, new_state, :hibernate}`
+      -  `:remove_handler`
+
+    * `handle_call(msg, state)` - invoked when a `call/3` is done to a specific
+      handler.
+
+      It must return:
+
+      -  `{:ok, reply, new_state}`
+      -  `{:ok, reply, new_state, :hibernate}`
+      -  `{:remove_handler, reply}`
+
+    * `handle_info(msg, state)` - invoked to handle all other messages which
+      are received by the process. Must return the same values as
+      `handle_event/2`.
+
+    * `terminate(reason, state)` - called when the event handler is removed or
+      the event manager is terminating. It can return any term.
+
+      The reason is one of:
+
+      -  `:stop` - manager is terminating
+      -  `{:stop, reason}` - monitored process terminated (for monitored handlers)
+      -  `:remove_handler` - handler is being removed
+      -  `{:error, term}` - handler crashed or returned a bad value
+      -  `term` - any term passed to functions like `GenEvent.remove_handler/2`
+
+    * `code_change(old_vsn, state, extra)` - called when the application
+      code is being upgraded live (hot code swapping).
+
+      It must return:
+
+      -  `{:ok, new_state}`
 
   ## Name Registration
 
@@ -79,46 +122,45 @@ defmodule GenEvent do
 
   ## Modes
 
-  GenEvent supports three different notifications.
+  GenEvent stream supports three different notifications.
 
   On `GenEvent.ack_notify/2`, the manager acknowledges each event,
-  providing backpressure, but processing of the message happens
+  providing back pressure, but processing of the message happens
   asynchronously.
 
   On `GenEvent.sync_notify/2`, the manager acknowledges an event
-  just after it is processed by all event handlers.
+  just after it was processed by all event handlers.
 
   On `GenEvent.notify/2`, all events are processed asynchronously and
   there is no ack (which means there is no backpressure).
 
   ## Streaming
 
-  `GenEvent` messages can be streamed with the help of `stream/2`.
-  You will need to start another process to consume the stream:
+  `GenEvent`s can be streamed from and streamed with the help of `stream/2`.
+  Here are some examples:
 
-      Task.start_link fn ->
-        stream = GenEvent.stream(pid)
+      stream = GenEvent.stream(pid)
 
-        # Discard the next 3 events
-        _ = Enum.take(stream, 3)
+      # Take the next 10 events
+      Enum.take(stream, 10)
 
-        # Print all remaining events
-        for event <- stream do
-          IO.inspect event
-        end
+      # Print all remaining events
+      for event <- stream do
+        IO.inspect event
       end
 
-  Now call `GenEvent.notify/2` multiple times. You will see the
-  first three events will be skipped while the rest will be
-  continuously printed.
+  A stream may also be given an id, which allows all streams with the given
+  id to be cancelled at any moment via `cancel_streams/1`.
 
   ## Learn more and compatibility
 
-  If you wish to find out more about GenEvent, the documentation and links
-  in Erlang can provide extra insight.
+  If you wish to find out more about gen events, Elixir getting started
+  guides provide a tutorial-like introduction. The documentation and links
+  in Erlang can also provide extra insight.
 
-    * [`:gen_event` module documentation](http://www.erlang.org/doc/man/gen_event.html)
-    * [Event Handlers – Learn You Some Erlang for Great Good!](http://learnyousomeerlang.com/event-handlers)
+    * http://elixir-lang.org/getting_started/mix/1.html
+    * http://www.erlang.org/doc/man/gen_event.html
+    * http://learnyousomeerlang.com/event-handlers
 
   Keep in mind though Elixir and Erlang gen events are not 100% compatible.
   The `:gen_event.add_sup_handler/3` is not supported by Elixir's GenEvent,
@@ -128,158 +170,11 @@ defmodule GenEvent do
   too much kool aid" section of the "Learn you some Erlang" link above. Due
   to those changes, Elixir's GenEvent does not trap exits by default.
 
-  Furthermore, Elixir also normalizes the `{:error, _}` tuples returned
+  Futhermore, Elixir's also normalizes the `{:error, _}` tuples returned
   by many functions, in order to be more consistent with themselves and
   the `GenServer` module.
   """
 
-  @doc """
-  Invoked when the handler is added to the `GenEvent` process. `add_handler/3`
-  (and `add_mon_handler/3`) will block until it returns.
-
-  `args` is the argument term (third argument) passed to `add_handler/3`.
-
-  Returning `{:ok, state}` will cause `add_handler/3` to return `:ok` and the
-  handler to become part of the `GenEvent` loop with state `state`.
-
-  Returning `{:ok, state, :hibernate}` is similar to
-  `{:ok, state}` except the `GenEvent` process is hibernated before continuing
-  its loop. See `handle_event/2` for more information on hibernation.
-
-  Returning `{:error, reason}` will cause `add_handler/3` to return
-  `{:error, reason}` and the handler is not added to `GenEvent` loop.
-  """
-  @callback init(args :: term) ::
-    {:ok, state} |
-    {:ok, state, :hibernate} |
-    {:error, reason :: any} when state: any
-
-  @doc """
-  Invoked to handle `notify/2`, `ack_notify/2` or `sync_notify/2` messages.
-
-  `event` is the event message and `state` is the current state of the handler.
-
-  Returning `{:ok, new_state}` sets the handler's state to `new_state` and the
-  `GenEvent` loop continues.
-
-  Returning `{:ok, new_state, :hibernate}` is similar to
-  `{:ok, new_state}` except the process is hibernated once all handlers have
-  handled the events. The `GenEvent` process will continue the loop once a
-  message is its message queue. If a message is already in the message queue
-  this will be immediately. Hibernating a `GenEvent` causes garbage collection
-  and leaves a continuous heap that minimises the memory used by the process.
-
-  Hibernating should not be used aggressively as too much time could be spent
-  garbage collecting. Normally it should only be used when a message is not
-  expected soon and minimising the memory of the process is shown to be
-  beneficial.
-
-  Returning `:remove_handler` removes the handler from the `GenEvent` loop and
-  calls `terminate/2` with reason `:remove_handler` and state `state`.
-  """
-  @callback handle_event(event :: term, state :: term) ::
-    {:ok, new_state} |
-    {:ok, new_state, :hibernate} |
-    :remove_handler when new_state: term
-
-  @doc """
-  Invoked to handle synchronous `call/4` messages to a specific handler.
-
-  `request` is the request message sent by a `call/4` and `state` is the current
-  state of the handler.
-
-  Returning `{:ok, reply, new_state}` sends `reply` as a response to the call
-  and sets the handler's state to `new_state`.
-
-  Returning `{:ok, reply, new_state, :hibernate}` is similar to
-  `{:ok, reply, new_state}` except the process is hibernated. See
-  `handle_event/2` for more information on hibernation.
-
-  Returning `{:remove_handler, reply}` sends `reply` as a response to the call,
-  removes the handler from the `GenEvent` loop and calls `terminate/2` with
-  reason `:remove_handler` and state `state`.
-  """
-
-  @callback handle_call(request :: term, state :: term) ::
-    {:ok, reply, new_state} |
-    {:ok, reply, new_state, :hibernate} |
-    {:remove_handler, reply} when reply: term, new_state: term
-
-  @doc """
-  Invoked to handle all other messages. All handlers are run in the `GenEvent`
-  process so messages intended for other handlers should be ignored with a catch
-  all clause.
-
-  `msg` is the message and `state` is the current state of the handler.
-
-  Return values are the same as `handle_event/2`.
-  """
-  @callback handle_info(msg :: term, state :: term) ::
-    {:ok, new_state} |
-    {:ok, new_state, :hibernate} |
-    :remove_handler when new_state: term
-
-  @doc """
-  Invoked when the server is about to exit. It should do any cleanup required.
-
-  `reason` is removal reason and `state` is the current state of the handler.
-  The return value is returned to `GenEvent.remove_handler/3` or ignored if
-  removing for another reason.
-
-  `reason` is one of:
-
-  -  `:stop` - manager is terminating
-  -  `{:stop, term}` - monitored process terminated (for monitored handlers)
-  -  `:remove_handler` - handler is being removed
-  -  `{:error, term}` - handler crashed or returned a bad value and an error is
-  logged
-  -  `term` - any term passed to functions like `GenEvent.remove_handler/3`
-
-  If part of a supervision tree, a `GenEvent`'s `Supervisor` will send an exit
-  signal when shutting it down. The exit signal is based on the shutdown
-  strategy in the child's specification. If it is `:brutal_kill` the `GenEvent`
-  is killed and so `terminate/2` is not called for its handlers. However if it is
-  a timeout the `Supervisor` will send the exit signal `:shutdown` and the
-  `GenEvent` will have the duration of the timeout to call `terminate/2` on all
-  of its handlers - if the process is still alive after the timeout it is
-  killed.
-
-  If the `GenEvent` receives an exit signal (that is not `:normal`) from any
-  process when it is not trapping exits it will exit abruptly with the same
-  reason and so not call the handlers' `terminate/2`. Note that a process does
-  *NOT* trap exits by default and an exit signal is sent when a linked process
-  exits or its node is disconnected. Therefore it is not guaranteed that
-  `terminate/2` is called when a `GenEvent` exits.
-
-  Care should be taken to cleanup because the `GenEvent` can continue to loop
-  after removing the handler. This is different to most other OTP behaviours.
-  For example if the handler controls a `port` (e.g. `:gen_tcp.socket`) or
-  `File.io_device`, it will be need to be closed in `terminate/2` as the
-  process is not exiting so will not be automatically cleaned up.
-  """
-  @callback terminate(reason, state :: term) ::
-    term when reason: :stop | {:stop, term} | :remove_handler | {:error, term} | term
-
-  @doc """
-  Invoked to change the state of the handler when a different version of the
-  handler's module is loaded (hot code swapping) and the state's term
-  structure should be changed.
-
-  `old_vsn` is the previous version of the module (defined by the `@vsn`
-  attribute) when upgrading. When downgrading the previous version is wrapped in
-  a 2-tuple with first element `:down`. `state` is the current state of the
-  handler and `extra` is any extra data required to change the state.
-
-  Returning `{:ok, new_state}` changes the state to `new_state` and the code
-  change is successful.
-
-  If `code_change/3` raises, the code change fails and the handler will continue
-  with its previous state. Therefore this callback does not usually contain side
-  effects.
-  """
-  @callback code_change(old_vsn, state :: term, extra :: term) ::
-    {:ok, new_state :: term} when old_vsn: term | {:down, term}
-
   @typedoc "Return values of `start*` functions"
   @type on_start :: {:ok, pid} | {:error, {:already_started, pid}}
 
@@ -293,7 +188,7 @@ defmodule GenEvent do
   @type manager :: pid | name | {atom, node}
 
   @typedoc "Supported values for new handlers"
-  @type handler :: atom | {atom, term}
+  @type handler :: atom | {atom, term} | {pid, reference}
 
   @doc false
   defmacro __using__(_) do
@@ -312,11 +207,10 @@ defmodule GenEvent do
 
       @doc false
       def handle_call(msg, state) do
-        # We do this to trick Dialyzer to not complain about non-local returns.
-        reason = {:bad_call, msg}
-        case :erlang.phash2(1, 1) do
-          0 -> exit(reason)
-          1 -> {:remove_handler, reason}
+        # We do this to trick dialyzer to not complain about non-local returns.
+        case :random.uniform(1) do
+          1 -> exit({:bad_call, msg})
+          2 -> {:remove_handler, :ok}
         end
       end
 
@@ -349,8 +243,8 @@ defmodule GenEvent do
   section in the `GenServer` module docs.
 
   If the event manager is successfully created and initialized, the function
-  returns `{:ok, pid}`, where pid is the pid of the server. If a process with
-  the specified server name already exists, the function returns
+  returns `{:ok, pid}`, where pid is the pid of the server. If there already
+  exists a process with the specified server name, the function returns
   `{:error, {:already_started, pid}}` with the pid of that process.
 
   Note that a `GenEvent` started with `start_link/1` is linked to the
@@ -420,10 +314,6 @@ defmodule GenEvent do
 
   If the given handler was previously installed at the manager, this
   function returns `{:error, :already_present}`.
-
-  For installing multiple instances of the same handler, `{Module, id}` instead
-  of `Module` must be used. The handler could be then referenced with
-  `{Module, id}` instead of just `Module`.
   """
   @spec add_handler(manager, handler, term) :: :ok | {:error, term}
   def add_handler(manager, handler, args) do
@@ -456,7 +346,7 @@ defmodule GenEvent do
     * `{:swapped, new_handler, pid}` - if the process pid has replaced the
       event handler by another
 
-    * `term` - if the event handler is removed due to an error. Which term
+    * a term - if the event handler is removed due to an error. Which term
       depends on the error
 
   Keep in mind that the `{:gen_event_EXIT, handler, reason}` message is not
@@ -515,7 +405,7 @@ defmodule GenEvent do
   Sends a sync event notification to the event `manager`.
 
   In other words, this function only returns `:ok` after the event manager
-  invokes the `handle_event/2` callback on each installed event handler.
+  invokes the `handle_event/2` on each installed event handler.
 
   See `notify/2` for more info.
   """
@@ -525,7 +415,7 @@ defmodule GenEvent do
   end
 
   @doc """
-  Sends an ack event notification to the event `manager`.
+  Sends a ack event notification to the event `manager`.
 
   In other words, this function only returns `:ok` as soon as the
   event manager starts processing this event, but it does not wait
@@ -579,7 +469,7 @@ defmodule GenEvent do
 
   First, the old event handler is deleted by calling `terminate/2` with
   the given `args1` and collects the return value. Then the new event handler
-  is added and initiated by calling `init({args2, term})`, where `term` is the
+  is added and initiated by calling `init({args2, state}), where term is the
   return value of calling `terminate/2` in the old handler. This makes it
   possible to transfer information from one handler to another.
 
@@ -614,24 +504,18 @@ defmodule GenEvent do
   end
 
   @doc """
-  Stops the manager with the given `reason`.
+  Terminates the event `manager`.
 
-  Before terminating, the event manager will call
-  `terminate(:stop, ...)` for each installed event handler.
-  It returns `:ok` if the manager terminates with the given
-  reason, if it terminates with another reason, the call will
-  exit.
-
-  This function keeps OTP semantics regarding error reporting.
-  If the reason is any other than `:normal`, `:shutdown` or
-  `{:shutdown, _}`, an error report will be logged.
+  Before terminating, the event manager will call `terminate(:stop, ...)`
+  for each installed event handler.
   """
-  @spec stop(manager, reason :: term, timeout) :: :ok
-  def stop(manager, reason \\ :normal, timeout \\ :infinity) do
-    :gen.stop(manager, reason, timeout)
+  @spec stop(manager) :: :ok
+  def stop(manager) do
+    rpc(manager, :stop)
   end
 
   defp rpc(module, cmd) do
+    # TODO: Change the tag once patch is accepted by OTP
     {:ok, reply} = :gen.call(module, self(), cmd, :infinity)
     reply
   end
@@ -648,12 +532,7 @@ defmodule GenEvent do
 
   def init_it(starter, parent, name, _, _, options) do
     Process.put(:"$initial_call", {__MODULE__, :init_it, 6})
-    debug =
-      if function_exported?(:gen, :debug_options, 2) do
-        :gen.debug_options(name, options)
-      else
-        :gen.debug_options(options)
-      end
+    debug = :gen.debug_options(options)
     :proc_lib.init_ack(starter, {:ok, self()})
     loop(parent, name(name), [], debug, false)
   end
@@ -745,6 +624,13 @@ defmodule GenEvent do
         {hib, reply, handlers} = server_swap_handler(handler1, args1, handler2, args2, handlers, mon, name)
         reply(tag, reply)
         loop(parent, name, handlers, debug, hib)
+      {_from, tag, :stop} ->
+        try do
+          server_terminate(:normal, parent, handlers, name)
+        catch
+          :exit, :normal -> :ok
+        end
+        reply(tag, :ok)
       {_from, tag, :which_handlers} ->
         reply(tag, server_which_handlers(handlers))
         loop(parent, name, handlers, debug, false)
@@ -770,7 +656,7 @@ defmodule GenEvent do
   end
 
   @doc false
-  def system_code_change([name, handlers, hib], module, old_vsn, extra) do
+  def system_code_change([name, handlers, hib], module , old_vsn, extra) do
     handlers =
       for handler <- handlers do
         if handler(handler, :module) == module do
@@ -904,13 +790,13 @@ defmodule GenEvent do
     {hib, server_collect_process_handlers(mode, event, streams, handlers, name)}
   end
 
-  defp server_split_process_handlers(mode, event, [handler | t], handlers, streams) do
+  defp server_split_process_handlers(mode, event, [handler|t], handlers, streams) do
     case handler(handler, :id) do
       {pid, _ref} when is_pid(pid) ->
         server_process_notify(mode, event, handler)
-        server_split_process_handlers(mode, event, t, handlers, [handler | streams])
+        server_split_process_handlers(mode, event, t, handlers, [handler|streams])
       _ ->
-        server_split_process_handlers(mode, event, t, [handler | handlers], streams)
+        server_split_process_handlers(mode, event, t, [handler|handlers], streams)
     end
   end
 
@@ -926,10 +812,10 @@ defmodule GenEvent do
   defp mode_to_tag(:sync),  do: :sync_notify
   defp mode_to_tag(:async), do: :notify
 
-  defp server_notify(event, fun, [handler | t], name, handlers, acc, hib) do
+  defp server_notify(event, fun, [handler|t], name, handlers, acc, hib) do
     case server_update(handler, fun, event, name, handlers) do
       {new_hib, handler} ->
-        server_notify(event, fun, t, name, handlers, [handler | acc], hib or new_hib)
+        server_notify(event, fun, t, name, handlers, [handler|acc], hib or new_hib)
       :error ->
         server_notify(event, fun, t, name, handlers, acc, hib)
     end
@@ -963,16 +849,16 @@ defmodule GenEvent do
     end
   end
 
-  defp server_collect_process_handlers(:async, event, [handler | t], handlers, name) do
-    server_collect_process_handlers(:async, event, t, [handler | handlers], name)
+  defp server_collect_process_handlers(:async, event, [handler|t], handlers, name) do
+    server_collect_process_handlers(:async, event, t, [handler|handlers], name)
   end
 
-  defp server_collect_process_handlers(mode, event, [handler | t], handlers, name) when mode in [:sync, :ack] do
+  defp server_collect_process_handlers(mode, event, [handler|t], handlers, name) when mode in [:sync, :ack] do
     handler(ref: ref, id: id) = handler
 
     receive do
       {^ref, :ok} ->
-        server_collect_process_handlers(mode, event, t, [handler | handlers], name)
+        server_collect_process_handlers(mode, event, t, [handler|handlers], name)
       {_from, tag, {:delete_handler, ^id, args}} ->
         do_terminate(handler, args, :remove, name, :normal)
         reply(tag, :ok)
@@ -1062,9 +948,9 @@ defmodule GenEvent do
           {:ok, res} ->
             case res do
               {:ok, state} ->
-                {false, succ, [handler(handler, state: state) | handlers]}
+                {false, succ, [handler(handler, state: state)|handlers]}
               {:ok, state, :hibernate} ->
-                {true, succ, [handler(handler, state: state) | handlers]}
+                {true, succ, [handler(handler, state: state)|handlers]}
               {:error, _} = error ->
                 {false, error, handlers}
               other ->
@@ -1127,9 +1013,9 @@ defmodule GenEvent do
   defp report_error(handler, reason, state, last_in, name) do
     reason =
       case reason do
-        {:undef, [{m, f, a, _} | _]=mfas} ->
+        {:undef, [{m,f,a,_}|_]=mfas} ->
           cond do
-            :code.is_loaded(m) === false ->
+            :code.is_loaded(m) ->
               {:"module could not be loaded", mfas}
             function_exported?(m, f, length(a)) ->
               reason

lib/elixir/lib/gen_event/stream.ex

@@ -2,11 +2,11 @@ defmodule GenEvent.Stream do
   @moduledoc """
   Defines a `GenEvent` stream.
 
-  This is a struct returned by `GenEvent.stream/2`. The struct is public and
+  This is a struct returned by `stream/2`. The struct is public and
   contains the following fields:
 
     * `:manager`  - the manager reference given to `GenEvent.stream/2`
-    * `:timeout`  - the timeout between events, defaults to `:infinity`
+    * `:timeout`  - the timeout in between events, defaults to `:infinity`
 
   """
   defstruct manager: nil, timeout: :infinity
@@ -22,21 +22,12 @@ defmodule GenEvent.Stream do
 
   @doc false
   def handle_event(event, _state) do
-    # We do this to trick Dialyzer to not complain about non-local returns.
-    case :erlang.phash2(1, 1) do
-      0 -> exit({:bad_event, event})
-      1 -> :remove_handler
-    end
+    exit({:bad_event, event})
   end
 
   @doc false
   def handle_call(msg, _state) do
-    # We do this to trick Dialyzer to not complain about non-local returns.
-    reason = {:bad_call, msg}
-    case :erlang.phash2(1, 1) do
-      0 -> exit(reason)
-      1 -> {:remove_handler, reason}
-    end
+    exit({:bad_call, msg})
   end
 
   @doc false
@@ -152,9 +143,15 @@ defimpl Enumerable, for: GenEvent.Stream do
 
   defp wait_for_handler_removal(pid, ref, mon_ref) do
     receive do
-      {:gen_event_EXIT, {^pid, ^ref}, _reason} ->
+      {:gen_event_EXIT, {^pid, ^ref}, reason}
+          when reason == :normal
+          when reason == :shutdown
+          when tuple_size(reason) == 3 and elem(reason, 0) == :swapped  ->
         Process.demonitor(mon_ref, [:flush])
         :ok
+      {:gen_event_EXIT, {^pid, ^ref}, reason} ->
+        Process.demonitor(mon_ref, [:flush])
+        {:error, reason}
       {:DOWN, ^mon_ref, _, _, reason} ->
         {:error, reason}
     end

lib/elixir/lib/gen_server.ex

@@ -2,7 +2,7 @@ defmodule GenServer do
   @moduledoc """
   A behaviour module for implementing the server of a client-server relation.
 
-  A GenServer is a process like any other Elixir process and it can be used
+  A GenServer is a process as any other Elixir process and it can be used
   to keep state, execute code asynchronously and so on. The advantage of using
   a generic server process (GenServer) implemented using this module is that it
   will have a standard set of interface functions and include functionality for
@@ -23,12 +23,12 @@ defmodule GenServer do
 
         # Callbacks
 
-        def handle_call(:pop, _from, [h | t]) do
+        def handle_call(:pop, _from, [h|t]) do
           {:reply, h, t}
         end
 
         def handle_cast({:push, item}, state) do
-          {:noreply, [item | state]}
+          {:noreply, [item|state]}
         end
       end
 
@@ -61,7 +61,50 @@ defmodule GenServer do
   There are 6 callbacks required to be implemented in a `GenServer`. By
   adding `use GenServer` to your module, Elixir will automatically define
   all 6 callbacks for you, leaving it up to you to implement the ones
-  you want to customize.
+  you want to customize. The callbacks are:
+
+    * `init(args)` - invoked when the server is started.
+
+      It must return:
+
+      -  `{:ok, state}`
+      -  `{:ok, state, timeout}`
+      -  `:ignore`
+      -  `{:stop, reason}`
+
+    * `handle_call(msg, {from, ref}, state)` and `handle_cast(msg, state)` -
+      invoked to handle call (sync) and cast (async) messages.
+
+      It must 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}`
+
+    * `handle_info(msg, state)` - invoked to handle all other messages which
+      are received by the process.
+
+      It must return:
+
+      -  `{:noreply, state}`
+      -  `{:noreply, state, timeout}`
+      -  `{:stop, reason, state}`
+
+    * `terminate(reason, state)` - called when the server is about to
+      terminate, useful for cleaning up. It must return `:ok`.
+
+    * `code_change(old_vsn, state, extra)` - called when the application
+      code is being upgraded live (hot code swapping).
+
+      It must return:
+
+      -  `{:ok, new_state}`
+      -  `{:error, reason}`
 
   ## Name Registration
 
@@ -76,11 +119,8 @@ defmodule GenServer do
       term using the functions in the `:global` module.
 
     * `{:via, module, term}` - the GenServer is registered with the given
-      mechanism and name. The `:via` option expects a module that exports
-      `register_name/2`, `unregister_name/1`, `whereis_name/1` and `send/2`.
-      One such example is the `:global` module which uses these functions
-      for keeping the list of names of processes and their  associated pid's
-      that are available globally for a network of Erlang nodes.
+      mechanism and name. The `:via` option expects a module name to control
+      the registration mechanism alongside a name which can be any term.
 
   For example, we could start and register our Stack server locally as follows:
 
@@ -129,7 +169,7 @@ defmodule GenServer do
 
         # Server (callbacks)
 
-        def handle_call(:pop, _from, [h | t]) do
+        def handle_call(:pop, _from, [h|t]) do
           {:reply, h, t}
         end
 
@@ -139,7 +179,7 @@ defmodule GenServer do
         end
 
         def handle_cast({:push, item}, state) do
-          {:noreply, [item | state]}
+          {:noreply, [item|state]}
         end
 
         def handle_cast(request, state) do
@@ -151,259 +191,18 @@ defmodule GenServer do
   the same module. If the server and/or client implementations are growing
   complex, you may want to have them in different modules.
 
-  ## Receiving custom messages
-
-  The goal of a `GenServer` is to abstract the "receive" loop for developers,
-  automatically handling system messages, support code change, synchronous
-  calls and more. Therefore, you should never call your own "receive" inside
-  the GenServer callbacks as doing so will cause the GenServer to misbehave.
-  If you want to receive custom messages, always receive them in `handle_info/2`.
-
   ## Learn more
 
-  If you wish to find out more about gen servers, the Elixir Getting Started
-  guide provides a tutorial-like introduction. The documentation and links
+  If you wish to find out more about gen servers, Elixir getting started
+  guides provide a tutorial-like introduction. The documentation and links
   in Erlang can also provide extra insight.
 
-    * [GenServer – Elixir's Getting Started Guide](http://elixir-lang.org/getting-started/mix-otp/genserver.html)
-    * [`:gen_server` module documentation](http://www.erlang.org/doc/man/gen_server.html)
-    * [gen_server Behaviour – OTP Design Principles](http://www.erlang.org/doc/design_principles/gen_server_concepts.html)
-    * [Clients and Servers – Learn You Some Erlang for Great Good!](http://learnyousomeerlang.com/clients-and-servers)
+    * http://elixir-lang.org/getting_started/mix/1.html
+    * 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 """
-  Invoked when the server is started. `start_link/3` (or `start/3`) will
-  block until it returns.
-
-  `args` is the argument term (second argument) passed to `start_link/3`.
-
-  Returning `{:ok, state}` will cause `start_link/3` to return
-  `{:ok, pid}` and the process to enter its loop.
-
-  Returning `{:ok, state, timeout}` is similar to `{:ok, state}`
-  except `handle_info(:timeout, state)` will be called after `timeout`
-  milliseconds if no messages are received within the timeout.
-
-  Returning `{:ok, state, :hibernate}` is similar to
-  `{:ok, state}` except the process is hibernated before entering the loop. See
-  `handle_call/3` for more information on hibernation.
-
-  Returning `:ignore` will cause `start_link/3` to return `:ignore` and the
-  process will exit normally without entering the loop or calling `terminate/2`.
-  If used when part of a supervision tree the parent supervisor will not fail
-  to start nor immediately try to restart the `GenServer`. The remainder of the
-  supervision tree will be (re)started and so the `GenServer` should not be
-  required by other processes. It can be started later with
-  `Supervisor.restart_child/2` as the child specification is saved in the parent
-  supervisor. The main use cases for this are:
-
-    * The `GenServer` is disabled by configuration but might be enabled later.
-    * An error occurred and it will be handled by a different mechanism than the
-     `Supervisor`. Likely this approach involves calling `Supervisor.restart_child/2`
-      after a delay to attempt a restart.
-
-  Returning `{:stop, reason}` will cause `start_link/3` to return
-  `{:error, reason}` and the process to exit with reason `reason` without
-  entering the loop or calling `terminate/2`.
-  """
-  @callback init(args :: term) ::
-    {:ok, state} |
-    {:ok, state, timeout | :hibernate} |
-    :ignore |
-    {:stop, reason :: any} when state: any
-
-  @doc """
-  Invoked to handle synchronous `call/3` messages. `call/3` will block until a
-  reply is received (unless the call times out or nodes are disconnected).
-
-  `request` is the request message sent by a `call/3`, `from` is a 2-tuple
-  containing the caller's pid and a term that uniquely identifies the call, and
-  `state` is the current state of the `GenServer`.
-
-  Returning `{:reply, reply, new_state}` sends the response `reply` to the
-  caller and continues the loop with new state `new_state`.
-
-  Returning `{:reply, reply, new_state, timeout}` is similar to
-  `{:reply, reply, new_state}` except `handle_info(:timeout, new_state)` will be
-  called after `timeout` milliseconds if no messages are received.
-
-  Returning `{:reply, reply, new_state, :hibernate}` is similar to
-  `{:reply, reply, new_state}` except the process is hibernated and will
-  continue the loop once a message is in its message queue. If a message is
-  already in the message queue this will be immediately. Hibernating a
-  `GenServer` causes garbage collection and leaves a continuous heap that
-  minimises the memory used by the process.
-
-  Hibernating should not be used aggressively as too much time could be spent
-  garbage collecting. Normally it should only be used when a message is not
-  expected soon and minimising the memory of the process is shown to be
-  beneficial.
-
-  Returning `{:noreply, new_state}` does not send a response to the caller and
-  continues the loop with new state `new_state`. The response must be sent with
-  `reply/2`.
-
-  There are three main use cases for not replying using the return value:
-
-    * To reply before returning from the callback because the response is known
-      before calling a slow function.
-    * To reply after returning from the callback because the response is not yet
-      available.
-    * To reply from another process, such as a task.
-
-  When replying from another process the `GenServer` should exit if the other
-  process exits without replying as the caller will be blocking awaiting a
-  reply.
-
-  Returning `{:noreply, new_state, timeout | :hibernate}` is similar to
-  `{:noreply, new_state}` except a timeout or hibernation occurs as with a
-  `:reply` tuple.
-
-  Returning `{:stop, reason, reply, new_state}` stops the loop and `terminate/2`
-  is called with reason `reason` and state `new_state`. Then the `reply` is sent
-  as the response to call and the process exits with reason `reason`.
-
-  Returning `{:stop, reason, new_state}` is similar to
-  `{:stop, reason, reply, new_state}` except a reply is not sent.
-
-  If this callback is not implemented, the default implementation by
-  `use GenServer` will return `{:stop, {:bad_call, request}, state}`.
-  """
-  @callback handle_call(request :: term, from, state :: term) ::
-    {:reply, reply, new_state} |
-    {:reply, reply, new_state, timeout | :hibernate} |
-    {:noreply, new_state} |
-    {:noreply, new_state, timeout | :hibernate} |
-    {:stop, reason, reply, new_state} |
-    {:stop, reason, new_state} when reply: term, new_state: term, reason: term
-
-  @doc """
-  Invoked to handle asynchronous `cast/2` messages.
-
-  `request` is the request message sent by a `cast/2` and `state` is the current
-  state of the `GenServer`.
-
-  Returning `{:noreply, new_state}` continues the loop with new state `new_state`.
-
-  Returning `{:noreply, new_state, timeout}` is similar to
-  `{:noreply, new_state}` except `handle_info(:timeout, new_state)` will be
-  called after `timeout` milliseconds if no messages are received.
-
-  Returning `{:noreply, new_state, :hibernate}` is similar to
-  `{:noreply, new_state}` except the process is hibernated before continuing the
-  loop. See `handle_call/3` for more information.
-
-  Returning `{:stop, reason, new_state}` stops the loop and `terminate/2` is
-  called with the reason `reason` and state `new_state`. The process exits with
-  reason `reason`.
-
-  If this callback is not implemented, the default implementation by
-  `use GenServer` will return `{:stop, {:bad_cast, request}, state}`.
-  """
-  @callback handle_cast(request :: term, state :: term) ::
-    {:noreply, new_state} |
-    {:noreply, new_state, timeout | :hibernate} |
-    {:stop, reason :: term, new_state} when new_state: term
-
-  @doc """
-  Invoked to handle all other messages.
-
-  `msg` is the message and `state` is the current state of the `GenServer`. When
-  a timeout occurs the message is `:timeout`.
-
-  Return values are the same as `handle_cast/2`.
-
-  If this callback is not implemented, the default implementation by
-  `use GenServer` will return `{:noreply, state}`.
-  """
-  @callback handle_info(msg :: :timeout | term, state :: term) ::
-    {:noreply, new_state} |
-    {:noreply, new_state, timeout | :hibernate} |
-    {:stop, reason :: term, new_state} when new_state: term
-
-  @doc """
-  Invoked when the server is about to exit. It should do any cleanup required.
-
-  `reason` is exit reason and `state` is the current state of the `GenServer`.
-  The return value is ignored.
-
-  `terminate/2` is called if a callback (except `init/1`) returns a `:stop`
-  tuple, raises, calls `Kernel.exit/1` or returns an invalid value. It may also
-  be called if the `GenServer` traps exits using `Process.flag/2` *and* the
-  parent process sends an exit signal.
-
-  If part of a supervision tree a `GenServer`'s `Supervisor` will send an exit
-  signal when shutting it down. The exit signal is based on the shutdown
-  strategy in the child's specification. If it is `:brutal_kill` the `GenServer`
-  is killed and so `terminate/2` is not called. However if it is a timeout the
-  `Supervisor` will send the exit signal `:shutdown` and the `GenServer` will
-  have the duration of the timeout to call `terminate/2` - if the process is
-  still alive after the timeout it is killed.
-
-  If the `GenServer` receives an exit signal (that is not `:normal`) from any
-  process when it is not trapping exits it will exit abruptly with the same
-  reason and so not call `terminate/2`. Note that a process does *NOT* trap
-  exits by default and an exit signal is sent when a linked process exits or its
-  node is disconnected.
-
-  Therefore it is not guaranteed that `terminate/2` is called when a `GenServer`
-  exits. For such reasons, we usually recommend important clean-up rules to
-  happen in separated processes either by use of monitoring or by links
-  themselves. For example if the `GenServer` controls a `port` (e.g.
-  `:gen_tcp.socket`) or `File.io_device`, they will be closed on receiving a
-  `GenServer`'s exit signal and do not need to be closed in `terminate/2`.
-
-  If `reason` is not `:normal`, `:shutdown` nor `{:shutdown, term}` an error is
-  logged.
-  """
-  @callback terminate(reason, state :: term) ::
-    term when reason: :normal | :shutdown | {:shutdown, term} | term
-
-  @doc """
-  Invoked to change the state of the `GenServer` when a different version of a
-  module is loaded (hot code swapping) and the state's term structure should be
-  changed.
-
-  `old_vsn` is the previous version of the module (defined by the `@vsn`
-  attribute) when upgrading. When downgrading the previous version is wrapped in
-  a 2-tuple with first element `:down`. `state` is the current state of the
-  `GenServer` and `extra` is any extra data required to change the state.
-
-  Returning `{:ok, new_state}` changes the state to `new_state` and the code
-  change is successful.
-
-  Returning `{:error, reason}` fails the code change with reason `reason` and
-  the state remains as the previous state.
-
-  If `code_change/3` raises the code change fails and the loop will continue
-  with its previous state. Therefore this callback does not usually contain side effects.
-  """
-  @callback code_change(old_vsn, state :: term, extra :: term) ::
-    {:ok, new_state :: term} |
-    {:error, reason :: term} when old_vsn: term | {:down, term}
-
-  @doc """
-  Invoked in some cases to retrieve a formatted version of the `GenServer` status.
-
-  This callback can be useful to control the *appearance* of the status of the
-  `GenServer`. For example, it can be used to return a compact representation of
-  the `GenServers`'s state to avoid having large state terms printed.
-
-    * one of `:sys.get_status/1` or `:sys.get_status/2` is invoked to get the
-      status of the `GenServer`; in such cases, `reason` is `:normal`
-
-    * the `GenServer` terminates abnormally and logs an error; in such cases,
-      `reason` is `:terminate`
-
-  `pdict_and_state` is a two-elements list `[pdict, state]` where `pdict` is a
-  list of `{key, value}` tuples representing the current process dictionary of
-  the `GenServer` and `state` is the current state of the `GenServer`.
-  """
-  @callback format_status(reason, pdict_and_state :: list) ::
-    term when reason: :normal | :terminate
-
-  @optional_callbacks format_status: 2
-
   @typedoc "Return values of `start*` functions"
   @type on_start :: {:ok, pid} | :ignore | {:error, {:already_started, pid} | term}
 
@@ -411,32 +210,21 @@ defmodule GenServer do
   @type name :: atom | {:global, term} | {:via, module, term}
 
   @typedoc "Options used by the `start*` functions"
-  @type options :: [option]
+  @type options :: [debug: debug,
+                    name: name,
+                    timeout: timeout,
+                    spawn_opt: Process.spawn_opt]
 
-  @typedoc "Option values used by the `start*` functions"
-  @type option :: {:debug, debug} |
-                  {:name, name} |
-                  {:timeout, timeout} |
-                  {:spawn_opt, Process.spawn_opt}
-
-  @typedoc "Debug options supported by the `start*` functions"
+  @typedoc "debug options supported by the `start*` functions"
   @type debug :: [:trace | :log | :statistics | {:log_to_file, Path.t}]
 
   @typedoc "The server reference"
   @type server :: pid | name | {atom, node}
 
-  @typedoc """
-  Tuple describing the client of a call request.
-
-  `pid` is the pid of the caller and `tag` is a unique term used to identify the
-  call.
-  """
-  @type from :: {pid, tag :: term}
-
   @doc false
   defmacro __using__(_) do
     quote location: :keep do
-      @behaviour GenServer
+      @behaviour :gen_server
 
       @doc false
       def init(args) do
@@ -445,12 +233,7 @@ defmodule GenServer do
 
       @doc false
       def handle_call(msg, _from, state) do
-        # We do this to trick Dialyzer to not complain about non-local returns.
-        reason = {:bad_call, msg}
-        case :erlang.phash2(1, 1) do
-          0 -> exit(reason)
-          1 -> {:stop, reason, state}
-        end
+        {:stop, {:bad_call, msg}, state}
       end
 
       @doc false
@@ -460,12 +243,7 @@ defmodule GenServer do
 
       @doc false
       def handle_cast(msg, state) do
-        # We do this to trick Dialyzer to not complain about non-local returns.
-        reason = {:bad_cast, msg}
-        case :erlang.phash2(1, 1) do
-          0 -> exit(reason)
-          1 -> {:stop, reason, state}
-        end
+        {:stop, {:bad_cast, msg}, state}
       end
 
       @doc false
@@ -488,41 +266,38 @@ defmodule GenServer do
 
   This is often used to start the `GenServer` as part of a supervision tree.
 
-  Once the server is started, the `init/1` function of the given `module` is
-  called with `args` as its arguments to initialize the server. To ensure a
-  synchronized start-up procedure, this function does not return until `init/1`
-  has returned.
+  Once the server is started, it calls the `init/1` function in the given `module`
+  passing the given `args` to initialize it. To ensure a synchronized start-up
+  procedure, this function does not return until `init/1` has returned.
 
   Note that a `GenServer` started with `start_link/3` is linked to the
-  parent process and will exit in case of crashes from the parent. The GenServer
-  will also exit due to the `:normal` reasons in case it is configured to trap
-  exits in the `init/1` callback.
+  parent process and will exit in case of crashes. The GenServer will also
+  exit due to the `:normal` reasons in case it is configured to trap exits
+  in the `init/1` callback.
 
   ## Options
 
-    * `:name` - used for name registration as described in the "Name
-      registration" section of the module documentation
+  The `:name` option is used for name registration as described in the module
+  documentation. If the option `:timeout` option is present, the server is
+  allowed to spend the given milliseconds initializing or it will be
+  terminated and the start function will return `{:error, :timeout}`.
 
-    * `:timeout` - if present, the server is allowed to spend the given amount of
-      milliseconds initializing or it will be terminated and the start function
-      will return `{:error, :timeout}`
+  If the `:debug` option is present, the corresponding function in the
+  [`:sys` module](http://www.erlang.org/doc/man/sys.html) will be invoked.
 
-    * `:debug` - if present, the corresponding function in the [`:sys`
-      module](http://www.erlang.org/doc/man/sys.html) is invoked
-
-    * `:spawn_opt` - if present, its value is passed as options to the
-      underlying process as in `Process.spawn/4`
+  If the `:spawn_opt` option is present, its value will be passed as options
+  to the underlying process as in `Process.spawn/4`.
 
   ## Return values
 
-  If the server is successfully created and initialized, this function returns
-  `{:ok, pid}`, where `pid` is the pid of the server. If a process with the
-  specified server name already exists, this function returns
+  If the server is successfully created and initialized, the function returns
+  `{:ok, pid}`, where pid is the pid of the server. If there already exists a
+  process with the specified server name, the function returns
   `{:error, {:already_started, pid}}` with the pid of that process.
 
-  If the `init/1` callback fails with `reason`, this function returns
+  If the `init/1` callback fails with `reason`, the function returns
   `{:error, reason}`. Otherwise, if it returns `{:stop, reason}`
-  or `:ignore`, the process is terminated and this function returns
+  or `:ignore`, the process is terminated and the function returns
   `{:error, reason}` or `:ignore`, respectively.
   """
   @spec start_link(module, any, options) :: on_start
@@ -551,22 +326,6 @@ defmodule GenServer do
     end
   end
 
-  @doc """
-  Stops the server with the given `reason`.
-
-  The `terminate/2` callback of the given `server` will be invoked before
-  exiting. This function returns `:ok` if the server terminates with the
-  given reason; if it terminates with another reason, the call exits.
-
-  This function keeps OTP semantics regarding error reporting.
-  If the reason is any other than `:normal`, `:shutdown` or
-  `{:shutdown, _}`, an error report is logged.
-  """
-  @spec stop(server, reason :: term, timeout) :: :ok
-  def stop(server, reason \\ :normal, timeout \\ :infinity) do
-    :gen.stop(server, reason, timeout)
-  end
-
   @doc """
   Makes a synchronous call to the `server` and waits for its reply.
 
@@ -574,55 +333,46 @@ defmodule GenServer do
   arrives or a timeout occurs. `handle_call/3` will be called on the server
   to handle the request.
 
-  `server` can be any of the values described in the "Name registration"
-  section of the documentation for this module.
+  The server can be any of the values described in the `Name Registration`
+  section of the module documentation.
 
   ## Timeouts
 
-  `timeout` is an integer greater than zero which specifies how many
+  The `timeout` is an integer greater than zero which specifies how many
   milliseconds to wait for a reply, or the atom `:infinity` to wait
-  indefinitely. The default value is `5000`. If no reply is received within
-  the specified time, the function call fails and the caller exits. If the
-  caller catches the failure and continues running, and the server is just late
-  with the reply, it may arrive at any time later into the caller's message
-  queue. The caller must in this case be prepared for this and discard any such
-  garbage messages that are two-element tuples with a reference as the first
-  element.
+  indefinitely. The default value is 5000. If no reply is received within
+  the specified time, the function call fails. If the caller catches the
+  failure and continues running, and the server is just late with the reply,
+  it may arrive at any time later into the caller's message queue. The caller
+  must in this case be prepared for this and discard any such garbage messages
+  that are two element tuples with a reference as the first element.
   """
   @spec call(server, term, timeout) :: term
   def call(server, request, timeout \\ 5000) do
-    case whereis(server) do
-      nil ->
-        exit({:noproc, {__MODULE__, :call, [server, request, timeout]}})
-      pid when pid == self() ->
-        exit({:calling_self, {__MODULE__, :call, [server, request, timeout]}})
-      pid ->
-        try do
-          :gen.call(pid, :"$gen_call", request, timeout)
-        catch
-          :exit, reason ->
-            exit({reason, {__MODULE__, :call, [server, request, timeout]}})
-        else
-          {:ok, res} -> res
-        end
+    try do
+      :gen.call(server, :"$gen_call", request, timeout)
+    catch
+      :exit, reason ->
+        exit({reason, {__MODULE__, :call, [server, request, timeout]}})
+    else
+      {:ok, res} -> res
     end
   end
 
   @doc """
   Sends an asynchronous request to the `server`.
 
-  This function always returns `:ok` regardless of whether
-  the destination `server` (or node) exists. Therefore it
-  is unknown whether the destination `server` successfully
-  handled the message.
+  This function returns `:ok` immediately, regardless of
+  whether the destination node or server does exists, unless
+  the server is specified as an atom.
 
   `handle_cast/2` will be called on the server to handle
-  the request. In case the `server` is on a node which is
-  not yet connected to the caller one, the call is going to
+  the request. In case the server is a node which is not
+  yet connected to the caller one, the call is going to
   block until a connection happens. This is different than
   the behaviour in OTP's `:gen_server` where the message
-  is sent by another process in this case, which could cause
-  messages to other nodes to arrive out of order.
+  would be sent by another process, which could cause
+  messages to arrive out of order.
   """
   @spec cast(server, term) :: :ok
   def cast(server, request)
@@ -654,7 +404,7 @@ defmodule GenServer do
   @doc """
   Casts all servers locally registered as `name` at the specified nodes.
 
-  This function returns immediately and ignores nodes that do not exist, or where the
+  The function returns immediately and ignores nodes that do not exist, or where the
   server name does not exist.
 
   See `multi_call/4` for more information.
@@ -671,42 +421,25 @@ defmodule GenServer do
   end
 
   defp do_send(dest, msg) do
-    try do
-      send(dest, msg)
-      :ok
-    catch
-      _, _ -> :ok
-    end
+    send(dest, msg)
+    :ok
   end
 
   @doc """
   Calls all servers locally registered as `name` at the specified `nodes`.
 
-  First, the `request` is sent to every node in `nodes`; then, the caller waits
-  for the replies. This function returns a two-element tuple `{replies,
-  bad_nodes}` where:
+  The `request` is first sent to every node and then we wait for the
+  replies. This function returns a tuple containing the node and its reply
+  as first element and all bad nodes as second element. The bad nodes is a
+  list of nodes that either did not exist, or where a server with the given
+  `name` did not exist or did not reply.
 
-    * `replies` - is a list of `{node, reply}` tuples where `node` is the node
-      that replied and `reply` is its reply
-    * `bad_nodes` - is a list of nodes that either did not exist or where a
-      server with the given `name` did not exist or did not reply
-
-  `nodes` is a list of node names to which the request is sent. The default
-  value is the list of all known nodes (including this node).
+  Nodes is a list of node names to which the request is sent. The default
+  value is the list of all known nodes.
 
   To avoid that late answers (after the timeout) pollute the caller's message
   queue, a middleman process is used to do the actual calls. Late answers will
   then be discarded when they arrive to a terminated process.
-
-  ## Examples
-
-  Assuming the `Stack` GenServer mentioned in the docs for the `GenServer`
-  module is registered as `Stack` in the `:"foo@my-machine"` and
-  `:"bar@my-machine"` nodes:
-
-      GenServer.multi_call(Stack, :pop)
-      #=> {[{:"foo@my-machine", :hello}, {:"bar@my-machine", :world}], []}
-
   """
   @spec multi_call([node], name :: atom, term, timeout) ::
                   {replies :: [{node, term}], bad_nodes :: [node]}
@@ -717,36 +450,20 @@ defmodule GenServer do
   @doc """
   Replies to a client.
 
-  This function can be used to explicitely send a reply to a client that called
-  `call/3` or `multi_call/4` when the reply cannot be specified in the return
-  value of `handle_call/3`.
+  This function can be used by a server to explicitly send a reply to a
+  client that called `call/3` or `multi_call/4`. When the reply cannot be
+  defined in the return value of `handle_call/3`.
 
-  `client` must be the `from` argument (the second argument) accepted by
-  `handle_call/3` callbacks. `reply` is an arbitrary term which will be given
-  back to the client as the return value of the call.
-
-  Note that `reply/2` can be called from any process, not just the GenServer
-  that originally received the call (as long as that GenServer communicated the
-  `from` argument somehow).
+  The `client` must be the `from` argument (the second argument) received
+  in `handle_call/3` callbacks. Reply is an arbitrary term which will be
+  given back to the client as the return value of the call.
 
   This function always returns `:ok`.
-
-  ## Examples
-
-      def handle_call(:reply_in_one_second, from, state) do
-        Process.send_after(self(), {:reply, from}, 1_000)
-        {:noreply, state}
-      end
-
-      def handle_info({:reply, from}, state) do
-        GenServer.reply(from, :one_second_has_passed)
-      end
-
   """
-  @spec reply(from, term) :: :ok
+  @spec reply({pid, reference}, term) :: :ok
   def reply(client, reply)
 
-  def reply({to, tag}, reply) when is_pid(to) do
+  def reply({to, tag}, reply) do
     try do
       send(to, {tag, reply})
       :ok
@@ -755,46 +472,9 @@ defmodule GenServer do
     end
   end
 
-  @doc """
-  Returns the `pid` or `{name, node}` of a GenServer process, or `nil` if
-  no process is associated with the given name.
-
-  ## Examples
-
-  For example, to lookup a server process, monitor it and send a cast to it:
-
-      process = GenServer.whereis(server)
-      monitor = Process.monitor(process)
-      GenServer.cast(process, :hello)
-
-  """
-  @spec whereis(server) :: pid | {atom, node} | nil
-  def whereis(pid) when is_pid(pid), do: pid
-  def whereis(name) when is_atom(name) do
-    Process.whereis(name)
-  end
-  def whereis({:global, name}) do
-    case :global.whereis_name(name) do
-      pid when is_pid(pid) -> pid
-      :undefined           -> nil
-    end
-  end
-  def whereis({:via, mod, name}) do
-    case apply(mod, :whereis_name, [name]) do
-      pid when is_pid(pid) -> pid
-      :undefined           -> nil
-    end
-  end
-  def whereis({name, local}) when is_atom(name) and local == node() do
-    Process.whereis(name)
-  end
-  def whereis({name, node} = server) when is_atom(name) and is_atom(node) do
-    server
-  end
-
   @compile {:inline, [nodes: 0]}
 
   defp nodes do
-    [node() | :erlang.nodes()]
+    [node()|:erlang.nodes()]
   end
 end

lib/elixir/lib/hash_dict.ex

@@ -1,12 +1,19 @@
 defmodule HashDict do
   @moduledoc """
-  WARNING: this module is deprecated.
+  A key-value store.
 
-  Use the `Map` module instead.
+  The `HashDict` is represented internally as a struct, therefore
+  `%HashDict{}` can be used whenever there is a need to match
+  on any `HashDict`. Note though the struct fields are private and
+  must not be accessed directly. Instead, use the functions on this
+  or in the `Dict` module.
+
+  Implementation-wise, `HashDict` is implemented using tries, which
+  grows in space as the number of keys grows, working well with both
+  small and large set of keys. For more information about the
+  functions and their APIs, please consult the `Dict` module.
   """
 
-  # TODO: Deprecate every function by 1.4
-
   use Dict
 
   @node_bitmap 0b111
@@ -92,7 +99,7 @@ defmodule HashDict do
   defp do_fetch(node, key, hash) do
     index = key_mask(hash)
     case elem(node, index) do
-      [^key | v]   -> {:ok, v}
+      [^key|v]     -> {:ok, v}
       {^key, v, _} -> {:ok, v}
       {_, _, n}    -> do_fetch(n, key, key_shift(hash))
       _            -> :error
@@ -103,11 +110,11 @@ defmodule HashDict do
     index = key_mask(hash)
     case elem(node, index) do
       [] ->
-        {put_elem(node, index, [key | value]), 1}
-      [^key | _] ->
-        {put_elem(node, index, [key | value]), 0}
-      [k | v] ->
-        n = put_elem(@node_template, key_mask(key_shift(hash)), [key | value])
+        {put_elem(node, index, [key|value]), 1}
+      [^key|_] ->
+        {put_elem(node, index, [key|value]), 0}
+      [k|v] ->
+        n = put_elem(@node_template, key_mask(key_shift(hash)), [key|value])
         {put_elem(node, index, {k, v, n}), 1}
       {^key, _, n} ->
         {put_elem(node, index, {key, value, n}), 0}
@@ -121,11 +128,11 @@ defmodule HashDict do
     index = key_mask(hash)
     case elem(node, index) do
       [] ->
-        {put_elem(node, index, [key | initial.()]), 1}
-      [^key | value] ->
-        {put_elem(node, index, [key | fun.(value)]), 0}
-      [k | v] ->
-        n = put_elem(@node_template, key_mask(key_shift(hash)), [key | initial.()])
+        {put_elem(node, index, [key|initial.()]), 1}
+      [^key|value] ->
+        {put_elem(node, index, [key|fun.(value)]), 0}
+      [k|v] ->
+        n = put_elem(@node_template, key_mask(key_shift(hash)), [key|initial.()])
         {put_elem(node, index, {k, v, n}), 1}
       {^key, value, n} ->
         {put_elem(node, index, {key, fun.(value), n}), 0}
@@ -140,16 +147,16 @@ defmodule HashDict do
     case elem(node, index) do
       [] ->
         :error
-      [^key | value] ->
+      [^key|value] ->
         {put_elem(node, index, []), value}
-      [_ | _] ->
+      [_|_] ->
         :error
       {^key, value, n} ->
         {put_elem(node, index, do_compact_node(n)), value}
       {k, v, n} ->
         case do_delete(n, key, key_shift(hash)) do
           {@node_template, value} ->
-            {put_elem(node, index, [k | v]), value}
+            {put_elem(node, index, [k|v]), value}
           {n, value} ->
             {put_elem(node, index, {k, v, n}), value}
           :error ->
@@ -161,9 +168,9 @@ defmodule HashDict do
   Enum.each 0..(@node_size - 1), fn index ->
     defp do_compact_node(node) when elem(node, unquote(index)) != [] do
       case elem(node, unquote(index)) do
-        [k | v] ->
+        [k|v] ->
           case put_elem(node, unquote(index), []) do
-            @node_template -> [k | v]
+            @node_template -> [k|v]
             n -> {k, v, n}
           end
         {k, v, n} ->
@@ -186,8 +193,8 @@ defmodule HashDict do
     next.(acc)
   end
 
-  defp do_reduce_each([k | v], {:cont, acc}, fun, next) do
-    next.(fun.({k, v}, acc))
+  defp do_reduce_each([k|v], {:cont, acc}, fun, next) do
+    next.(fun.({k,v}, acc))
   end
 
   defp do_reduce_each({k, v, n}, {:cont, acc}, fun, next) do
@@ -226,10 +233,25 @@ defimpl Enumerable, for: HashDict do
   def count(dict),             do: {:ok, HashDict.size(dict)}
 end
 
+defimpl Access, for: HashDict do
+  def get(dict, key) do
+    HashDict.get(dict, key, nil)
+  end
+
+  def get_and_update(dict, key, fun) do
+    {get, update} = fun.(HashDict.get(dict, key, nil))
+    {get, HashDict.put(dict, key, update)}
+  end
+end
+
 defimpl Collectable, for: HashDict do
+  def empty(_dict) do
+    HashDict.new
+  end
+
   def into(original) do
     {original, fn
-      dict, {:cont, {k, v}} -> HashDict.put(dict, k, v)
+      dict, {:cont, {k, v}} -> Dict.put(dict, k, v)
       dict, :done -> dict
       _, :halt -> :ok
     end}

lib/elixir/lib/hash_set.ex

@@ -1,11 +1,20 @@
 defmodule HashSet do
   @moduledoc """
-  WARNING: this module is deprecated.
+  A set store.
 
-  Use the `MapSet` module instead.
+  The `HashSet` is represented internally as a struct, therefore
+  `%HashSet{}` can be used whenever there is a need to match
+  on any `HashSet`. Note though the struct fields are private and
+  must not be accessed directly. Instead, use the functions on this
+  or in the `Set` module.
+
+  The `HashSet` is implemented using tries, which grows in
+  space as the number of keys grows, working well with both
+  small and large set of keys. For more information about the
+  functions and their APIs, please consult the `Set` module.
   """
 
-  # TODO: Deprecate every function by 1.4
+  @behaviour Set
 
   @node_bitmap 0b111
   @node_shift 3
@@ -20,6 +29,9 @@ defmodule HashSet do
   @compile :inline_list_funcs
   @compile {:inline, key_hash: 1, key_mask: 1, key_shift: 1}
 
+  @doc """
+  Creates a new empty set.
+  """
   @spec new :: Set.t
   def new do
     %HashSet{}
@@ -44,7 +56,7 @@ defmodule HashSet do
   end
 
   def to_list(set) do
-    set_fold(set, [], &[&1 | &2]) |> :lists.reverse
+    set_fold(set, [], &[&1|&2]) |> :lists.reverse
   end
 
   def equal?(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) do
@@ -112,10 +124,10 @@ defmodule HashSet do
   defp do_member?(node, term, hash) do
     index = key_mask(hash)
     case elem(node, index) do
-      []          -> false
-      [^term | _] -> true
-      [_]         -> false
-      [_ | n]     -> do_member?(n, term, key_shift(hash))
+      []        -> false
+      [^term|_] -> true
+      [_]       -> false
+      [_|n]     -> do_member?(n, term, key_shift(hash))
     end
   end
 
@@ -124,14 +136,14 @@ defmodule HashSet do
     case elem(node, index) do
       [] ->
         {put_elem(node, index, [term]), 1}
-      [^term | _] ->
+      [^term|_] ->
         {node, 0}
       [t] ->
         n = put_elem(@node_template, key_mask(key_shift(hash)), [term])
-        {put_elem(node, index, [t | n]), 1}
-      [t | n] ->
+        {put_elem(node, index, [t|n]), 1}
+      [t|n] ->
         {n, counter} = do_put(n, term, key_shift(hash))
-        {put_elem(node, index, [t | n]), counter}
+        {put_elem(node, index, [t|n]), counter}
     end
   end
 
@@ -144,14 +156,14 @@ defmodule HashSet do
         {:ok, put_elem(node, index, [])}
       [_] ->
         :error
-      [^term | n] ->
+      [^term|n] ->
         {:ok, put_elem(node, index, do_compact_node(n))}
-      [t | n] ->
+      [t|n] ->
         case do_delete(n, term, key_shift(hash)) do
           {:ok, @node_template} ->
             {:ok, put_elem(node, index, [t])}
           {:ok, n} ->
-            {:ok, put_elem(node, index, [t | n])}
+            {:ok, put_elem(node, index, [t|n])}
           :error ->
             :error
         end
@@ -164,19 +176,19 @@ defmodule HashSet do
         [t] ->
           case put_elem(node, unquote(index), []) do
             @node_template -> [t]
-            n -> [t | n]
+            n -> [t|n]
           end
-        [t | n] ->
-          [t | put_elem(node, unquote(index), do_compact_node(n))]
+        [t|n] ->
+          [t|put_elem(node, unquote(index), do_compact_node(n))]
       end
     end
   end
 
   ## Set fold
 
-  defp do_fold_each([], acc, _fun),     do: acc
-  defp do_fold_each([t], acc, fun),     do: fun.(t, acc)
-  defp do_fold_each([t | n], acc, fun), do: do_fold(n, fun.(t, acc), fun, @node_size)
+  defp do_fold_each([], acc, _fun),   do: acc
+  defp do_fold_each([t], acc, fun),   do: fun.(t, acc)
+  defp do_fold_each([t|n], acc, fun), do: do_fold(n, fun.(t, acc), fun, @node_size)
 
   defp do_fold(node, acc, fun, count) when count > 0 do
     acc = do_fold_each(:erlang.element(count, node), acc, fun)
@@ -205,7 +217,7 @@ defmodule HashSet do
     next.(fun.(t, acc))
   end
 
-  defp do_reduce_each([t | n], {:cont, acc}, fun, next) do
+  defp do_reduce_each([t|n], {:cont, acc}, fun, next) do
     do_reduce(n, fun.(t, acc), fun, @node_size, next)
   end
 
@@ -241,6 +253,10 @@ defimpl Enumerable, for: HashSet do
 end
 
 defimpl Collectable, for: HashSet do
+  def empty(_dict) do
+    HashSet.new
+  end
+
   def into(original) do
     {original, fn
       set, {:cont, x} -> HashSet.put(set, x)

lib/elixir/lib/inspect.ex

@@ -16,20 +16,20 @@ defprotocol Inspect do
   ## Examples
 
   Many times, inspecting a structure can be implemented in function
-  of existing entities. For example, here is `MapSet`'s `inspect`
+  of existing entities. For example, here is `HashSet`'s `inspect`
   implementation:
 
-      defimpl Inspect, for: MapSet do
+      defimpl Inspect, for: HashSet do
         import Inspect.Algebra
 
         def inspect(dict, opts) do
-          concat ["#MapSet<", to_doc(MapSet.to_list(dict), opts), ">"]
+          concat ["#HashSet<", to_doc(HashSet.to_list(dict), opts), ">"]
         end
       end
 
   The `concat` function comes from `Inspect.Algebra` and it
   concatenates algebra documents together. In the example above,
-  it is concatenating the string `"MapSet<"` (all strings are
+  it is concatenating the string `"HashSet<"` (all strings are
   valid algebra documents that keep their formatting when pretty
   printed), the document returned by `Inspect.Algebra.to_doc/2` and the
   other string `">"`.
@@ -41,21 +41,20 @@ defprotocol Inspect do
   ## Error handling
 
   In case there is an error while your structure is being inspected,
-  Elixir will raise an `ArgumentError` error and will automatically fall back
-  to a raw representation for printing the structure.
+  Elixir will automatically fall back to a raw representation.
 
   You can however access the underlying error by invoking the Inspect
-  implementation directly. For example, to test Inspect.MapSet above,
+  implementation directly. For example, to test Inspect.HashSet above,
   you can invoke it as:
 
-      Inspect.MapSet.inspect(MapSet.new, %Inspect.Opts{})
+      Inspect.HashSet.inspect(HashSet.new, Inspect.Opts.new)
 
   """
 
   # Handle structs in Any
   @fallback_to_any true
 
-  def inspect(term, opts)
+  def inspect(thing, opts)
 end
 
 defimpl Inspect, for: Atom do
@@ -88,7 +87,7 @@ defimpl Inspect, for: Atom do
       atom in Macro.binary_ops or atom in Macro.unary_ops ->
         ":" <> binary
       true ->
-        <<?:, ?", Inspect.BitString.escape(binary, ?")::binary, ?">>
+        << ?:, ?", Inspect.BitString.escape(binary, ?") :: binary, ?" >>
     end
   end
 
@@ -104,7 +103,7 @@ defimpl Inspect, for: Atom do
 
   defp valid_ref_identifier?(_), do: false
 
-  defp valid_ref_piece?(<<?., h, t::binary>>) when h in ?A..?Z do
+  defp valid_ref_piece?(<<?., h, t :: binary>>) when h in ?A..?Z do
     valid_ref_piece? valid_identifier?(t)
   end
 
@@ -113,7 +112,7 @@ defimpl Inspect, for: Atom do
 
   # Detect if atom
 
-  defp valid_atom_identifier?(<<h, t::binary>>) when h in ?a..?z or h in ?A..?Z or h == ?_ do
+  defp valid_atom_identifier?(<<h, t :: binary>>) when h in ?a..?z or h in ?A..?Z or h == ?_ do
     valid_atom_piece?(t)
   end
 
@@ -129,7 +128,7 @@ defimpl Inspect, for: Atom do
     end
   end
 
-  defp valid_identifier?(<<h, t::binary>>)
+  defp valid_identifier?(<<h, t :: binary>>)
       when h in ?a..?z
       when h in ?A..?Z
       when h in ?0..?9
@@ -141,16 +140,16 @@ defimpl Inspect, for: Atom do
 end
 
 defimpl Inspect, for: BitString do
-  def inspect(term, %Inspect.Opts{binaries: bins, base: base} = opts) when is_binary(term) do
-    if base == :decimal and (bins == :as_strings or (bins == :infer and String.printable?(term))) do
-      <<?", escape(term, ?")::binary, ?">>
+  def inspect(thing, %Inspect.Opts{binaries: bins} = opts) when is_binary(thing) do
+    if bins == :as_strings or (bins == :infer and String.printable?(thing)) do
+      <<?", escape(thing, ?") :: binary, ?">>
     else
-      inspect_bitstring(term, opts)
+      inspect_bitstring(thing, opts)
     end
   end
 
-  def inspect(term, opts) do
-    inspect_bitstring(term, opts)
+  def inspect(thing, opts) do
+    inspect_bitstring(thing, opts)
   end
 
   ## Escaping
@@ -160,54 +159,54 @@ defimpl Inspect, for: BitString do
     escape(other, char, <<>>)
   end
 
-  defp escape(<<char, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, ?\\, char>>)
+  defp escape(<< char, t :: binary >>, char, binary) do
+    escape(t, char, << binary :: binary, ?\\, char >>)
   end
-  defp escape(<<?#, ?{, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, ?\\, ?#, ?{>>)
+  defp escape(<<?#, ?{, t :: binary>>, char, binary) do
+    escape(t, char, << binary :: binary, ?\\, ?#, ?{>>)
   end
-  defp escape(<<?\a, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, ?\\, ?a>>)
+  defp escape(<<?\a, t :: binary>>, char, binary) do
+    escape(t, char, << binary :: binary, ?\\, ?a >>)
   end
-  defp escape(<<?\b, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, ?\\, ?b>>)
+  defp escape(<<?\b, t :: binary>>, char, binary) do
+    escape(t, char, << binary :: binary, ?\\, ?b >>)
   end
-  defp escape(<<?\d, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, ?\\, ?d>>)
+  defp escape(<<?\d, t :: binary>>, char, binary) do
+    escape(t, char, << binary :: binary, ?\\, ?d >>)
   end
-  defp escape(<<?\e, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, ?\\, ?e>>)
+  defp escape(<<?\e, t :: binary>>, char, binary) do
+    escape(t, char, << binary :: binary, ?\\, ?e >>)
   end
-  defp escape(<<?\f, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, ?\\, ?f>>)
+  defp escape(<<?\f, t :: binary>>, char, binary) do
+    escape(t, char, << binary :: binary, ?\\, ?f >>)
   end
-  defp escape(<<?\n, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, ?\\, ?n>>)
+  defp escape(<<?\n, t :: binary>>, char, binary) do
+    escape(t, char, << binary :: binary, ?\\, ?n >>)
   end
-  defp escape(<<?\r, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, ?\\, ?r>>)
+  defp escape(<<?\r, t :: binary>>, char, binary) do
+    escape(t, char, << binary :: binary, ?\\, ?r >>)
   end
-  defp escape(<<?\\, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, ?\\, ?\\>>)
+  defp escape(<<?\\, t :: binary>>, char, binary) do
+    escape(t, char, << binary :: binary, ?\\, ?\\ >>)
   end
-  defp escape(<<?\t, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, ?\\, ?t>>)
+  defp escape(<<?\t, t :: binary>>, char, binary) do
+    escape(t, char, << binary :: binary, ?\\, ?t >>)
   end
-  defp escape(<<?\v, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, ?\\, ?v>>)
+  defp escape(<<?\v, t :: binary>>, char, binary) do
+    escape(t, char, << binary :: binary, ?\\, ?v >>)
   end
-  defp escape(<<h::utf8, t::binary>>, char, binary) do
-    head = <<h::utf8>>
+  defp escape(<<h :: utf8, t :: binary>>, char, binary) do
+    head = << h :: utf8 >>
     if String.printable?(head) do
       escape(t, char, append(head, binary))
     else
-      <<byte::8, h::binary>> = head
-      t = <<h::binary, t::binary>>
-      escape(t, char, <<binary::binary, escape_char(byte)::binary>>)
+      << byte :: size(8), h :: binary >> = head
+      t = << h :: binary, t :: binary >>
+      escape(t, char, << binary :: binary, escape_char(byte) :: binary >>)
     end
   end
-  defp escape(<<h, t::binary>>, char, binary) do
-    escape(t, char, <<binary::binary, escape_char(h)::binary>>)
+  defp escape(<<h, t :: binary>>, char, binary) do
+    escape(t, char, << binary :: binary, escape_char(h) :: binary >>)
   end
   defp escape(<<>>, _char, binary), do: binary
 
@@ -218,17 +217,17 @@ defimpl Inspect, for: BitString do
   end
 
   def escape_char(char) when char < 0x100 do
-    <<a::4, b::4>> = <<char::8>>
+    <<a::4, b::4>> = <<char::size(8)>>
     <<?\\, ?x, to_hex(a), to_hex(b)>>
   end
 
   def escape_char(char) when char < 0x10000 do
-    <<a::4, b::4, c::4, d::4>> = <<char::16>>
+    <<a::4, b::4, c::4, d::4>> = <<char::size(16)>>
     <<?\\, ?x, ?{, to_hex(a), to_hex(b), to_hex(c), to_hex(d), ?}>>
   end
 
   def escape_char(char) when char < 0x1000000 do
-    <<a::4, b::4, c::4, d::4, e::4, f::4>> = <<char::24>>
+    <<a::4, b::4, c::4, d::4, e::4, f::4>> = <<char::size(24)>>
     <<?\\, ?x, ?{, to_hex(a), to_hex(b), to_hex(c),
                    to_hex(d), to_hex(e), to_hex(f), ?}>>
   end
@@ -236,40 +235,35 @@ defimpl Inspect, for: BitString do
   defp to_hex(c) when c in 0..9, do: ?0+c
   defp to_hex(c) when c in 10..15, do: ?A+c-10
 
-  defp append(<<h, t::binary>>, binary), do: append(t, <<binary::binary, h>>)
+  defp append(<<h, t :: binary>>, binary), do: append(t, << binary :: binary, h >>)
   defp append(<<>>, binary), do: binary
 
   ## Bitstrings
 
-  defp inspect_bitstring("", _opts) do
-    "<<>>"
-  end
-
   defp inspect_bitstring(bitstring, opts) do
-    nest surround("<<", each_bit(bitstring, opts.limit, opts), ">>"), 1
+    each_bit(bitstring, opts.limit, "<<") <> ">>"
   end
 
-  defp each_bit(_, 0, _) do
-    "..."
+  defp each_bit(_, 0, acc) do
+    acc <> "..."
   end
 
-  defp each_bit(<<>>, _counter, _opts) do
-    :doc_nil
+  defp each_bit(<<h, t :: bitstring>>, counter, acc) when t != <<>> do
+    each_bit(t, decrement(counter), acc <> Integer.to_string(h) <> ", ")
   end
 
-  defp each_bit(<<h::8>>, _counter, opts) do
-    Inspect.Integer.inspect(h, opts)
+  defp each_bit(<<h :: size(8)>>, _counter, acc) do
+    acc <> Integer.to_string(h)
   end
 
-  defp each_bit(<<h, t::bitstring>>, counter, opts) do
-    glue(concat(Inspect.Integer.inspect(h, opts), ","),
-         each_bit(t, decrement(counter), opts))
+  defp each_bit(<<>>, _counter, acc) do
+    acc
   end
 
-  defp each_bit(bitstring, _counter, opts) do
+  defp each_bit(bitstring, _counter, acc) do
     size = bit_size(bitstring)
-    <<h::size(size)>> = bitstring
-    Inspect.Integer.inspect(h, opts) <> "::size(" <> Integer.to_string(size) <> ")"
+    <<h :: size(size)>> = bitstring
+    acc <> Integer.to_string(h) <> "::size(" <> Integer.to_string(size) <> ")"
   end
 
   defp decrement(:infinity), do: :infinity
@@ -279,31 +273,17 @@ end
 defimpl Inspect, for: List do
   def inspect([], _opts), do: "[]"
 
-  # TODO: Deprecate :char_lists and :as_char_lists keys in v1.5
-  def inspect(term, %Inspect.Opts{charlists: lists, char_lists: lists_deprecated} = opts) do
-    lists =
-      if lists == :infer and lists_deprecated != :infer do
-        case lists_deprecated do
-          :as_char_lists ->
-            :as_charlists
-          _ ->
-            lists_deprecated
-        end
-      else
-        lists
-      end
-
+  def inspect(thing, %Inspect.Opts{char_lists: lists} = opts) do
     cond do
-      lists == :as_charlists or (lists == :infer and printable?(term)) ->
-        <<?', Inspect.BitString.escape(IO.chardata_to_string(term), ?')::binary, ?'>>
-      keyword?(term) ->
-        surround_many("[", term, "]", opts, &keyword/2)
+      lists == :as_char_lists or (lists == :infer and printable?(thing)) ->
+        << ?', Inspect.BitString.escape(IO.chardata_to_string(thing), ?') :: binary, ?' >>
+      keyword?(thing) ->
+        surround_many("[", thing, "]", opts, &keyword/2)
       true ->
-        surround_many("[", term, "]", opts, &to_doc/2)
+        surround_many("[", thing, "]", opts, &to_doc/2)
     end
   end
 
-  @doc false
   def keyword({key, value}, opts) do
     concat(
       key_to_binary(key) <> ": ",
@@ -311,9 +291,8 @@ defimpl Inspect, for: List do
     )
   end
 
-  @doc false
   def keyword?([{key, _value} | rest]) when is_atom(key) do
-    case Atom.to_charlist(key) do
+    case Atom.to_char_list(key) do
       'Elixir.' ++ _ -> false
       _ -> keyword?(rest)
     end
@@ -322,19 +301,6 @@ defimpl Inspect, for: List do
   def keyword?([]),     do: true
   def keyword?(_other), do: false
 
-  @doc false
-  def printable?([c | cs]) when c in 32..126, do: printable?(cs)
-  def printable?([?\n | cs]), do: printable?(cs)
-  def printable?([?\r | cs]), do: printable?(cs)
-  def printable?([?\t | cs]), do: printable?(cs)
-  def printable?([?\v | cs]), do: printable?(cs)
-  def printable?([?\b | cs]), do: printable?(cs)
-  def printable?([?\f | cs]), do: printable?(cs)
-  def printable?([?\e | cs]), do: printable?(cs)
-  def printable?([?\a | cs]), do: printable?(cs)
-  def printable?([]), do: true
-  def printable?(_), do: false
-
   ## Private
 
   defp key_to_binary(key) do
@@ -343,6 +309,18 @@ defimpl Inspect, for: List do
       other -> other
     end
   end
+
+  defp printable?([c|cs]) when is_integer(c) and c in 32..126, do: printable?(cs)
+  defp printable?([?\n|cs]), do: printable?(cs)
+  defp printable?([?\r|cs]), do: printable?(cs)
+  defp printable?([?\t|cs]), do: printable?(cs)
+  defp printable?([?\v|cs]), do: printable?(cs)
+  defp printable?([?\b|cs]), do: printable?(cs)
+  defp printable?([?\f|cs]), do: printable?(cs)
+  defp printable?([?\e|cs]), do: printable?(cs)
+  defp printable?([?\a|cs]), do: printable?(cs)
+  defp printable?([]), do: true
+  defp printable?(_), do: false
 end
 
 defimpl Inspect, for: Tuple do
@@ -380,8 +358,8 @@ defimpl Inspect, for: Map do
 end
 
 defimpl Inspect, for: Integer do
-  def inspect(term, %Inspect.Opts{base: base}) do
-    Integer.to_string(term, base_to_value(base))
+  def inspect(thing, %Inspect.Opts{base: base}) do
+    Integer.to_string(thing, base_to_value(base))
     |> prepend_prefix(base)
   end
 
@@ -406,8 +384,8 @@ defimpl Inspect, for: Integer do
 end
 
 defimpl Inspect, for: Float do
-  def inspect(term, _opts) do
-    IO.iodata_to_binary(:io_lib_format.fwrite_g(term))
+  def inspect(thing, _opts) do
+    IO.iodata_to_binary(:io_lib_format.fwrite_g(thing))
   end
 end
 
@@ -428,7 +406,7 @@ defimpl Inspect, for: Regex do
   defp escape(<<term>> <> rest, buf, term),
     do: escape(rest, buf <> <<?\\, term>>, term)
 
-  # the list of characters is from "String.printable?" impl
+  # the list of characters is from `String.printable?` impl
   # minus characters treated specially by regex: \s, \d, \b, \e
 
   defp escape(<<?\n>> <> rest, buf, term),
@@ -472,7 +450,7 @@ defimpl Inspect, for: Function do
     if fun_info[:type] == :external and fun_info[:env] == [] do
       "&#{Inspect.Atom.inspect(mod)}.#{fun_info[:name]}/#{fun_info[:arity]}"
     else
-      case Atom.to_charlist(mod) do
+      case Atom.to_char_list(mod) do
         'elixir_compiler_' ++ _ ->
           if function_exported?(mod, :__RELATIVE__, 0) do
             "#Function<#{uniq(fun_info)} in file:#{mod.__RELATIVE__}>"

lib/elixir/lib/inspect/algebra.ex

@@ -4,8 +4,8 @@ defmodule Inspect.Opts do
 
   The following fields are available:
 
-    * `:structs` - when `false`, structs are not formatted by the inspect
-      protocol, they are instead printed as maps, defaults to `true`.
+    * `:structs` - when false, structs are not formatted by the inspect
+      protocol, they are instead printed as maps, defaults to true.
 
     * `:binaries` - when `:as_strings` all binaries will be printed as strings,
       non-printable bytes will be escaped.
@@ -15,75 +15,53 @@ defmodule Inspect.Opts do
       When the default `:infer`, the binary will be printed as a string if it
       is printable, otherwise in bit syntax.
 
-    * `:charlists` - when `:as_charlists` all lists will be printed as char
+    * `:char_lists` - when `:as_char_lists` all lists will be printed as char
       lists, non-printable elements will be escaped.
 
       When `:as_lists` all lists will be printed as lists.
 
-      When the default `:infer`, the list will be printed as a charlist if it
+      When the default `:infer`, the list will be printed as a char list if it
       is printable, otherwise as list.
 
     * `:limit` - limits the number of items that are printed for tuples,
-      bitstrings, and lists, does not apply to strings nor charlists, defaults
+      bitstrings, and lists, does not apply to strings nor char lists, defaults
       to 50.
 
-    * `:pretty` - if set to `true` enables pretty printing, defaults to `false`.
+    * `:pretty` - if set to true enables pretty printing, defaults to false.
 
-    * `:width` - defaults to 80 characters, used when pretty is `true` or when
-      printing to IO devices. Set to 0 to force each item to be printed on its
-      own line.
+    * `:width` - defaults to the 80 characters, used when pretty is true or
+      when printing to IO devices.
 
     * `:base` - print integers as :binary, :octal, :decimal, or :hex, defaults
-      to :decimal. When inspecting binaries any `:base` other than `:decimal`
-      implies `binaries: :as_binaries`.
-
-    * `:safe` - when `false`, failures while inspecting structs will be raised
-      as errors instead of being wrapped in the `Inspect.Error` exception. This
-      is useful when debugging failures and crashes for custom inspect
-      implementations
+      to :decimal
 
   """
 
-  # TODO: Deprecate char_lists key by v1.5
   defstruct structs: true,
             binaries: :infer,
-            charlists: :infer,
             char_lists: :infer,
             limit: 50,
             width: 80,
             base: :decimal,
-            pretty: false,
-            safe: true
+            pretty: false
 
-  # TODO: Deprecate char_lists key and :as_char_lists value by v1.5
   @type t :: %__MODULE__{
                structs: boolean,
                binaries: :infer | :as_binaries | :as_strings,
-               charlists: :infer | :as_lists | :as_charlists,
                char_lists: :infer | :as_lists | :as_char_lists,
-               limit: pos_integer | :infinity,
+               limit: pos_integer,
                width: pos_integer | :infinity,
                base: :decimal | :binary | :hex | :octal,
-               pretty: boolean,
-               safe: boolean}
-end
-
-defmodule Inspect.Error do
-  @moduledoc """
-  Raised when a struct cannot be inspected.
-  """
-  defexception [:message]
+               pretty: boolean}
 end
 
 defmodule Inspect.Algebra do
   @moduledoc ~S"""
   A set of functions for creating and manipulating algebra
-  documents.
+  documents, as described in ["Strictly Pretty" (2000) by Christian Lindig][0].
 
-  This module implements the functionality described in
-  ["Strictly Pretty" (2000) by Christian Lindig][0] with small
-  additions, like support for String nodes, and a custom
-  rendering function that maximises horizontal space use.
+  An algebra document is represented by an `Inspect.Algebra` node
+  or a regular string.
 
       iex> Inspect.Algebra.empty
       :doc_nil
@@ -126,7 +104,7 @@ defmodule Inspect.Algebra do
   `:flat` (breaks as spaces) and `:break` (breaks as newlines).
   Implementing the same logic in a strict language such as Elixir leads
   to an exponential growth of possible documents, unless document groups
-  are encoded explicitly as `:flat` or `:break`. Those groups are then reduced
+  are encoded explictly as `:flat` or `:break`. Those groups are then reduced
   to a simple document, where the layout is already decided, per [Lindig][0].
 
   This implementation slightly changes the semantic of Lindig's algorithm
@@ -151,7 +129,7 @@ defmodule Inspect.Algebra do
   @nesting 1
   @break " "
 
-  # Functional interface to "doc" records
+  # Functional interface to `doc` records
 
   @type t :: :doc_nil | :doc_line | doc_cons | doc_nest | doc_break | doc_group | binary
 
@@ -207,8 +185,6 @@ defmodule Inspect.Algebra do
         Inspect.inspect(map, opts)
       rescue
         e ->
-          stacktrace = System.stacktrace
-
           # Because we try to raise a nice error message in case
           # we can't inspect a struct, there is a chance the error
           # message itself relies on the struct being printed, so
@@ -220,20 +196,11 @@ defmodule Inspect.Algebra do
           else
             try do
               Process.put(:inspect_trap, true)
-
               res = Inspect.Map.inspect(map, opts)
-              res = IO.iodata_to_binary(format(res, :infinity))
-
-              exception = Inspect.Error.exception(
-                message: "got #{inspect e.__struct__} with message " <>
-                         "#{inspect Exception.message(e)} while inspecting #{res}"
-              )
-
-              if opts.safe do
-                Inspect.inspect(exception, opts)
-              else
-                reraise(exception, stacktrace)
-              end
+              formatted = IO.iodata_to_binary(format(res, :infinity))
+              raise ArgumentError,
+                "Got #{inspect e.__struct__} with message " <>
+                "\"#{Exception.message(e)}\" while inspecting #{formatted}"
             after
               Process.delete(:inspect_trap)
             end
@@ -280,7 +247,7 @@ defmodule Inspect.Algebra do
   """
   @spec concat([t]) :: doc_cons
   def concat(docs) do
-    fold_doc(docs, &concat(&1, &2))
+    folddoc(docs, &concat(&1, &2))
   end
 
   @doc ~S"""
@@ -411,18 +378,17 @@ defmodule Inspect.Algebra do
   ## Examples
 
       iex> doc = ["A", "B"]
-      iex> doc = Inspect.Algebra.fold_doc(doc, fn(x, y) ->
+      iex> doc = Inspect.Algebra.folddoc(doc, fn(x,y) ->
       ...>   Inspect.Algebra.concat [x, "!", y]
       ...> end)
       iex> Inspect.Algebra.format(doc, 80)
       ["A", "!", "B"]
 
   """
-  @spec fold_doc([t], ((t, t) -> t)) :: t
-  def fold_doc(list, fun)
-  def fold_doc([], _), do: empty
-  def fold_doc([doc], _), do: doc
-  def fold_doc([d | ds], fun), do: fun.(d, fold_doc(ds, fun))
+  @spec folddoc([t], ((t, t) -> t)) :: t
+  def folddoc([], _), do: empty
+  def folddoc([doc], _), do: doc
+  def folddoc([d|ds], f), do: f.(d, folddoc(ds, f))
 
   # Elixir conveniences
 
@@ -478,41 +444,34 @@ defmodule Inspect.Algebra do
     concat(left, right)
   end
 
-  defp do_surround_many(left, docs, right, limit, opts, fun, sep) do
-    surround(left, do_surround_many(docs, limit, opts, fun, sep), right)
+  defp do_surround_many(left, docs, right, limit, _opts, fun, sep) do
+    surround(left, do_surround_many(docs, limit, _opts, fun, sep), right)
   end
 
   defp do_surround_many(_, 0, _opts, _fun, _sep) do
     "..."
   end
 
-  defp do_surround_many([], _limit, _opts, _fun, _sep) do
-    :doc_nil
-  end
-
   defp do_surround_many([h], limit, opts, fun, _sep) do
     fun.(h, %{opts | limit: limit})
   end
 
-  defp do_surround_many([h | t], limit, opts, fun, sep) when is_list(t) do
+  defp do_surround_many([h|t], limit, opts, fun, sep) when is_list(t) do
     limit = decrement(limit)
-    h = fun.(h, %{opts | limit: limit})
-    t = do_surround_many(t, limit, opts, fun, sep)
-    do_join(h, t, sep)
+    glue(
+      concat(fun.(h, %{opts | limit: limit}), sep),
+      do_surround_many(t, limit, opts, fun, sep)
+    )
   end
 
-  defp do_surround_many([h | t], limit, opts, fun, _sep) do
+  defp do_surround_many([h|t], limit, opts, fun, _sep) do
     limit = decrement(limit)
-    h = fun.(h, %{opts | limit: limit})
-    t = fun.(t, %{opts | limit: limit})
-    do_join(h, t, @tail_separator)
+    glue(
+      concat(fun.(h, %{opts | limit: limit}), @tail_separator),
+      fun.(t, %{opts | limit: limit})
+    )
   end
 
-  defp do_join(:doc_nil, :doc_nil, _), do: :doc_nil
-  defp do_join(h, :doc_nil, _),        do: h
-  defp do_join(:doc_nil, t, _),        do: t
-  defp do_join(h, t, sep),             do: glue(concat(h, sep), t)
-
   defp decrement(:infinity), do: :infinity
   defp decrement(counter),   do: counter - 1
 
@@ -524,7 +483,7 @@ defmodule Inspect.Algebra do
   document to fit in the given width.
   """
   @spec format(t, non_neg_integer | :infinity) :: iodata
-  def format(d, w) when w == :infinity or w >= 0 do
+  def format(d, w) do
     format(w, 0, [{0, default_mode(w), doc_group(d)}])
   end
 

lib/elixir/lib/integer.ex

@@ -6,233 +6,75 @@ defmodule Integer do
   import Bitwise
 
   @doc """
-  Determines if `integer` is odd.
+  Determines if an integer is odd.
 
-  Returns `true` if the given `integer` is an odd number,
-  otherwise it returns `false`.
+  Returns `true` if `n` is an odd number, otherwise `false`.
 
   Allowed in guard clauses.
-
-  ## Examples
-
-      iex> Integer.is_odd(5)
-      true
-
-      iex> Integer.is_odd(6)
-      false
-
-      iex> Integer.is_odd(-5)
-      true
-
-      iex> Integer.is_odd(0)
-      false
-
   """
-  defmacro is_odd(integer) do
-    quote do: (unquote(integer) &&& 1) == 1
+  defmacro is_odd(n) do
+    quote do: (unquote(n) &&& 1) == 1
   end
 
   @doc """
-  Determines if an `integer` is even.
+  Determines if an integer is even.
 
-  Returns `true` if the given `integer` is an even number,
-  otherwise it returns `false`.
+  Returns `true` if `n` is an even number, otherwise `false`.
 
   Allowed in guard clauses.
-
-  ## Examples
-
-      iex> Integer.is_even(10)
-      true
-
-      iex> Integer.is_even(5)
-      false
-
-      iex> Integer.is_even(-10)
-      true
-
-      iex> Integer.is_even(0)
-      true
-
   """
-  defmacro is_even(integer) do
-    quote do: (unquote(integer) &&& 1) == 0
+  defmacro is_even(n) do
+    quote do: (unquote(n) &&& 1) == 0
   end
 
   @doc """
-  Returns the ordered digits for the given non-negative `integer`.
+  Converts a binary to an integer.
 
-  An optional `base` value may be provided representing the radix for the returned
-  digits. This one can be an integer >= 2.
-
-  ## Examples
-
-      iex> Integer.digits(101)
-      [1, 0, 1]
-
-      iex> Integer.digits(170, 2)
-      [1, 0, 1, 0, 1, 0, 1, 0]
-
-  """
-  @spec digits(non_neg_integer, pos_integer) :: [non_neg_integer, ...]
-  def digits(integer, base \\ 10)
-      when is_integer(integer) and integer >= 0 and is_integer(base) and base >= 2 do
-    do_digits(integer, base, [])
-  end
-
-  defp do_digits(0, _base, []), do: [0]
-  defp do_digits(1, _base, []), do: [1]
-  defp do_digits(base, base, []), do: [1, 0]
-  defp do_digits(0, _base, acc), do: acc
-  defp do_digits(integer, base, acc) do
-    do_digits div(integer, base), base, [rem(integer, base) | acc]
-  end
-
-  @doc """
-  Returns the integer represented by the ordered `digits`.
-
-  An optional `base` value may be provided representing the radix for the `digits`.
-  This one can be an integer >= 2.
-
-  ## Examples
-
-      iex> Integer.undigits([1, 2, 3])
-      123
-
-      iex> Integer.undigits([1, 4], 16)
-      20
-
-      iex> Integer.undigits([])
-      0
-
-  """
-  @spec undigits([integer], integer) :: integer
-  def undigits(digits, base \\ 10) when is_list(digits) and is_integer(base) and base >= 2 do
-    do_undigits(digits, base, 0)
-  end
-
-  defp do_undigits([], _base, []), do: 0
-  defp do_undigits([0], _base, []), do: 0
-  defp do_undigits([1], _base, []), do: 1
-  defp do_undigits([1, 0], base, []), do: base
-  defp do_undigits([], _base, acc), do: acc
-  defp do_undigits([digit | tail], base, acc) do
-    do_undigits(tail, base, acc * base + digit)
-  end
-
-  @doc """
-  Parses a text representation of an integer.
-
-  An optional `base` to the corresponding integer can be provided.
-  If `base` is not given, 10 will be used.
-
-  If successful, returns a tuple in the form of `{integer, remainder_of_binary}`.
+  If successful, returns a tuple of the form `{integer, remainder_of_binary}`.
   Otherwise `:error`.
 
-  Raises an error if `base` is less than 2 or more than 36.
-
-  If you want to convert a string-formatted integer directly to a integer,
-  `String.to_integer/1` or `String.to_integer/2` can be used instead.
-
   ## Examples
 
       iex> Integer.parse("34")
-      {34, ""}
+      {34,""}
 
       iex> Integer.parse("34.5")
-      {34, ".5"}
+      {34,".5"}
 
       iex> Integer.parse("three")
       :error
 
-      iex> Integer.parse("34", 10)
-      {34, ""}
-
-      iex> Integer.parse("f4", 16)
-      {244, ""}
-
-      iex> Integer.parse("Awww++", 36)
-      {509216, "++"}
-
-      iex> Integer.parse("fab", 10)
-      :error
-
-      iex> Integer.parse("a2", 38)
-      ** (ArgumentError) invalid base 38
-
   """
-  @spec parse(binary, 2..36) :: {integer, binary} | :error | no_return
-  def parse(binary, base \\ 10)
-
-  def parse("", base) when base in 2..36,
-    do: :error
-
-  def parse(binary, base) when is_binary(binary) and base in 2..36 do
-    parse_in_base(binary, base)
-  end
-
-  def parse(binary, base) when is_binary(binary) do
-    raise ArgumentError, "invalid base #{base}"
-  end
-
-  defp parse_in_base("-" <> bin, base) do
-    case do_parse(bin, base) do
-      {number, remainder} -> {-number, remainder}
+  @spec parse(binary) :: {integer, binary} | :error
+  def parse(<< ?-, bin :: binary >>) do
+    case do_parse(bin) do
       :error -> :error
+      {number, remainder} -> {-number, remainder}
     end
   end
 
-  defp parse_in_base("+" <> bin, base) do
-    do_parse(bin, base)
+  def parse(<< ?+, bin :: binary >>) do
+    do_parse(bin)
   end
 
-  defp parse_in_base(binary, base) when is_binary(binary) do
-    do_parse(binary, base)
+  def parse(bin) when is_binary(bin) do
+    do_parse(bin)
   end
 
-  defp do_parse(<<char, rest::binary>>, base) do
-    if valid_digit_in_base?(char, base) do
-      do_parse(rest, base, parse_digit(char, base))
-    else
-      :error
-    end
+  defp do_parse(<< char, bin :: binary >>) when char in ?0..?9, do: do_parse(bin, char - ?0)
+  defp do_parse(_), do: :error
+
+  defp do_parse(<< char, rest :: binary >>, acc) when char in ?0..?9 do
+    do_parse rest, 10 * acc + (char - ?0)
   end
 
-  defp do_parse(_, _) do
-    :error
-  end
-
-  defp do_parse(<<char, rest::binary>> = bin, base, acc) do
-    if valid_digit_in_base?(char, base) do
-      do_parse(rest, base, base * acc + parse_digit(char, base))
-    else
-      {acc, bin}
-    end
-  end
-
-  defp do_parse(bitstring, _, acc) do
+  defp do_parse(bitstring, acc) do
     {acc, bitstring}
   end
 
-  defp parse_digit(char, _) do
-    cond do
-      char in ?0..?9 -> char - ?0
-      char in ?A..?Z -> char - ?A + 10
-      true           -> char - ?a + 10
-    end
-  end
-
-  defp valid_digit_in_base?(char, base) do
-    if base <= 10 do
-      char in ?0..(?0 + base - 1)
-    else
-      char in ?0..?9 or char in ?A..(?A + base - 11) or char in ?a..(?a + base - 11)
-    end
-  end
-
   @doc """
   Returns a binary which corresponds to the text representation
-  of `integer`.
+  of `some_integer`.
 
   Inlined by the compiler.
 
@@ -241,26 +83,15 @@ defmodule Integer do
       iex> Integer.to_string(123)
       "123"
 
-      iex> Integer.to_string(+456)
-      "456"
-
-      iex> Integer.to_string(-789)
-      "-789"
-
-      iex> Integer.to_string(0123)
-      "123"
-
   """
   @spec to_string(integer) :: String.t
-  def to_string(integer) do
-    :erlang.integer_to_binary(integer)
+  def to_string(some_integer) do
+    :erlang.integer_to_binary(some_integer)
   end
 
   @doc """
   Returns a binary which corresponds to the text representation
-  of `integer` in the given `base`.
-
-  `base` can be an integer between 2 and 36.
+  of `some_integer` in base `base`.
 
   Inlined by the compiler.
 
@@ -269,69 +100,42 @@ defmodule Integer do
       iex> Integer.to_string(100, 16)
       "64"
 
-      iex> Integer.to_string(-100, 16)
-      "-64"
-
-      iex> Integer.to_string(882681651, 36)
-      "ELIXIR"
-
   """
   @spec to_string(integer, 2..36) :: String.t
-  def to_string(integer, base) do
-    :erlang.integer_to_binary(integer, base)
+  def to_string(some_integer, base) do
+    :erlang.integer_to_binary(some_integer, base)
   end
 
   @doc """
-  Returns a charlist which corresponds to the text representation of the given `integer`.
+  Returns a char list which corresponds to the text representation of the given integer.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> Integer.to_charlist(123)
-      '123'
-
-      iex> Integer.to_charlist(+456)
-      '456'
-
-      iex> Integer.to_charlist(-789)
-      '-789'
-
-      iex> Integer.to_charlist(0123)
-      '123'
+      iex> Integer.to_char_list(7)
+      '7'
 
   """
-  @spec to_charlist(integer) :: charlist
-  def to_charlist(integer) do
-    :erlang.integer_to_list(integer)
+  @spec to_char_list(integer) :: char_list
+  def to_char_list(number) do
+    :erlang.integer_to_list(number)
   end
 
   @doc """
-  Returns a charlist which corresponds to the text representation of `integer` in the given `base`.
-
-  `base` can be an integer between 2 and 36.
+  Returns a char list which corresponds to the text representation of the
+  given integer in the given case.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> Integer.to_charlist(100, 16)
-      '64'
-
-      iex> Integer.to_charlist(-100, 16)
-      '-64'
-
-      iex> Integer.to_charlist(882681651, 36)
-      'ELIXIR'
+      iex> Integer.to_char_list(1023, 16)
+      '3FF'
 
   """
-  @spec to_charlist(integer, 2..36) :: charlist
-  def to_charlist(integer, base) do
-    :erlang.integer_to_list(integer, base)
+  @spec to_char_list(integer, 2..36) :: char_list
+  def to_char_list(number, base) do
+    :erlang.integer_to_list(number, base)
   end
-
-  # TODO: Deprecate by v1.5
-  @doc false
-  @spec to_char_list(integer) :: charlist
-  def to_char_list(integer), do: Integer.to_charlist(integer)
 end

lib/elixir/lib/io.ex

@@ -1,36 +1,32 @@
 defmodule IO do
   @moduledoc """
-  Functions handling input/output (IO).
+  Functions handling IO.
 
-  Many functions in this module expect an IO device as an argument.
+  Many functions in this module expects an IO device as argument.
   An IO device must be a pid or an atom representing a process.
   For convenience, Elixir provides `:stdio` and `:stderr` as
   shortcuts to Erlang's `:standard_io` and `:standard_error`.
 
-  The majority of the functions expect chardata, i.e. strings or
+  The majority of the functions expect char data, i.e. strings or
   lists of characters and strings. In case another type is given,
-  functions will convert to string via the `String.Chars` protocol
+  it will do a conversion to string via the `String.Chars` protocol
   (as shown in typespecs).
 
-  The functions starting with `bin` expect iodata as an argument,
+  The functions starting with `bin*` expects iodata as argument,
   i.e. binaries or lists of bytes and binaries.
 
   ## IO devices
 
   An IO device may be an atom or a pid. In case it is an atom,
-  the atom must be the name of a registered process. In addition,
-  Elixir provides two shortcuts:
+  the atom must be the name of a registered process. However,
+  there are three exceptions for this rule:
 
-    * `:stdio` - a shortcut for `:standard_io`, which maps to
-      the current `Process.group_leader/0` in Erlang
+    * `:standard_io` - when the `:standard_io` atom is given,
+      it is treated as a shortcut for `Process.group_leader`
 
-    * `:stderr` - a shortcut for the named process `:standard_error`
-      provided in Erlang
+    * `:stdio` - is a shortcut for `:standard_io`
 
-  IO devices maintain their position, that means subsequent calls to any
-  reading or writing functions will start from the place when the device
-  was last accessed. Position of files can be changed using the
-  `:file.position/2` function.
+    * `:stderr` - is a shortcut for `:standard_error`
 
   """
 
@@ -47,11 +43,8 @@ defmodule IO do
   end
 
   @doc """
-  Reads from the IO `device`.
-
-  The `device` is iterated by the given number of characters or line by line if
-  `:line` is given.
-  Alternatively, if `:all` is given, then whole `device` is returned.
+  Reads `count` characters from the IO device, a whole
+  `:line` or the whole device with `:all`.
 
   It returns:
 
@@ -67,7 +60,7 @@ defmodule IO do
   empty string in case the device has reached EOF.
   """
   @spec read(device, :all | :line | non_neg_integer) :: chardata | nodata
-  def read(device \\ group_leader(), line_or_chars)
+  def read(device \\ group_leader, chars_or_line)
 
   def read(device, :all) do
     do_read_all(map_dev(device), "")
@@ -77,7 +70,7 @@ defmodule IO do
     :io.get_line(map_dev(device), '')
   end
 
-  def read(device, count) when is_integer(count) and count >= 0 do
+  def read(device, count) when count >= 0 do
     :io.get_chars(map_dev(device), '', count)
   end
 
@@ -90,11 +83,8 @@ defmodule IO do
   end
 
   @doc """
-  Reads from the IO `device`. The operation is Unicode unsafe.
-
-  The `device` is iterated by the given number of characters or line by line if
-  `:line` is given.
-  Alternatively, if `:all` is given, then whole `device` is returned.
+  Reads `count` characters from the IO device, a whole
+  `:line` or the whole device with `:all`.
 
   It returns:
 
@@ -109,11 +99,11 @@ defmodule IO do
   If `:all` is given, `:eof` is never returned, but an
   empty string in case the device has reached EOF.
 
-  Note: do not use this function on IO devices in Unicode mode
+  Note: do not use this function on IO devices in unicode mode
   as it will return the wrong result.
   """
   @spec binread(device, :all | :line | non_neg_integer) :: iodata | nodata
-  def binread(device \\ group_leader(), line_or_chars)
+  def binread(device \\ group_leader, chars_or_line)
 
   def binread(device, :all) do
     do_binread_all(map_dev(device), "")
@@ -126,16 +116,15 @@ defmodule IO do
     end
   end
 
-  def binread(device, count) when is_integer(count) and count >= 0 do
+  def binread(device, count) when count >= 0 do
     case :file.read(map_dev(device), count) do
       {:ok, data} -> data
       other -> other
     end
   end
 
-  @read_all_size 4096
   defp do_binread_all(mapped_dev, acc) do
-    case :file.read(mapped_dev, @read_all_size) do
+    case :file.read_line(mapped_dev) do
       {:ok, data} -> do_binread_all(mapped_dev, acc <> data)
       :eof -> acc
       other -> other
@@ -143,18 +132,18 @@ defmodule IO do
   end
 
   @doc """
-  Writes `item` to the given `device`.
+  Writes the given argument to the given device.
 
-  By default the `device` is the standard output.
+  By default the device is the standard output.
   It returns `:ok` if it succeeds.
 
   ## Examples
 
       IO.write "sample"
-      #=> sample
+      #=> "sample"
 
       IO.write :stderr, "error"
-      #=> error
+      #=> "error"
 
   """
   @spec write(device, chardata | String.Chars.t) :: :ok
@@ -163,13 +152,12 @@ defmodule IO do
   end
 
   @doc """
-  Writes `item` as a binary to the given `device`.
-  No Unicode conversion happens.
-  The operation is Unicode unsafe.
+  Writes the given argument to the given device
+  as a binary, no unicode conversion happens.
 
   Check `write/2` for more information.
 
-  Note: do not use this function on IO devices in Unicode mode
+  Note: do not use this function on IO devices in unicode mode
   as it will return the wrong result.
   """
   @spec binwrite(device, iodata) :: :ok | {:error, term}
@@ -178,83 +166,37 @@ defmodule IO do
   end
 
   @doc """
-  Writes `item` to the given `device`, similar to `write/2`,
-  but adds a newline at the end.
+  Writes the argument to the device, similar to `write/2`,
+  but adds a newline at the end. The argument is expected
+  to be a chardata.
   """
   @spec puts(device, chardata | String.Chars.t) :: :ok
   def puts(device \\ group_leader(), item) do
-    :io.put_chars map_dev(device), [to_chardata(item), ?\n]
+    erl_dev = map_dev(device)
+    :io.put_chars erl_dev, [to_chardata(item), ?\n]
   end
 
   @doc """
-  Writes a `message` to stderr, along with the given `stacktrace`.
-
-  This function also notifies the compiler a warning was printed
-  (in case --warnings-as-errors was enabled). It returns `:ok`
-  if it succeeds.
-
-  An empty list can be passed to avoid stacktrace printing.
-
-  ## Examples
-
-      stacktrace = [{MyApp, :main, 1, [file: 'my_app.ex', line: 4]}]
-      IO.warn "variable bar is unused", stacktrace
-      #=> warning: variable bar is unused
-      #=>   my_app.ex:4: MyApp.main/1
-
-  """
-  @spec warn(chardata | String.Chars.t, Exception.stacktrace) :: :ok
-  def warn(message, []) do
-    :elixir_errors.warn([to_chardata(message), ?\n])
-  end
-  def warn(message, stacktrace) when is_list(stacktrace) do
-    formatted = Enum.map_join(stacktrace, "\n  ", &Exception.format_stacktrace_entry(&1))
-    :elixir_errors.warn([to_chardata(message), ?\n, "  ", formatted, ?\n])
-  end
-
-  @doc """
-  Writes a `message` to stderr, along with the current stacktrace.
-
-  It returns `:ok` if it succeeds.
-
-  ## Examples
-
-      IO.warn "variable bar is unused"
-      #=> warning: variable bar is unused
-      #=>   (iex) evaluator.ex:108: IEx.Evaluator.eval/4
-
-  """
-  @spec warn(chardata | String.Chars.t) :: :ok
-  def warn(message) do
-    {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
-    warn(message, Enum.drop(stacktrace, 2))
-  end
-
-  @doc """
-  Inspects and writes the given `item` to the device.
+  Inspects and writes the given argument to the device.
 
   It enables pretty printing by default with width of
   80 characters. The width can be changed by explicitly
   passing the `:width` option.
 
-  See `Inspect.Opts` for a full list of options.
-
   ## Examples
 
       IO.inspect Process.list, width: 40
 
   """
-  @spec inspect(item, Keyword.t) :: item when item: var
+  @spec inspect(term, Keyword.t) :: term
   def inspect(item, opts \\ []) do
     inspect group_leader(), item, opts
   end
 
   @doc """
-  Inspects `item` according to the given options using the IO `device`.
-
-  See `Inspect.Opts` for a full list of options.
+  Inspects the item with options using the given device.
   """
-  @spec inspect(device, item, Keyword.t) :: item when item: var
+  @spec inspect(device, term, Keyword.t) :: term
   def inspect(device, item, opts) when is_list(opts) do
     opts   = struct(Inspect.Opts, opts)
     iodata = Inspect.Algebra.format(Inspect.Algebra.to_doc(item, opts), opts.width)
@@ -263,34 +205,10 @@ defmodule IO do
   end
 
   @doc """
-  Gets a number of bytes from IO device `:stdio`.
-
-  If `:stdio` is a Unicode device, `count` implies
-  the number of Unicode codepoints to be retrieved.
+  Gets a number of bytes from the io device. If the
+  io device is a unicode device, `count` implies
+  the number of unicode codepoints to be retrieved.
   Otherwise, `count` is the number of raw bytes to be retrieved.
-
-  See `IO.getn/3` for a description of return values.
-
-  """
-  @spec getn(chardata | String.Chars.t, pos_integer) :: chardata | nodata
-  @spec getn(device, chardata | String.Chars.t) :: chardata | nodata
-  def getn(prompt, count \\ 1)
-
-  def getn(prompt, count) when is_integer(count) and count > 0 do
-    getn(group_leader, prompt, count)
-  end
-
-  def getn(device, prompt) when not is_integer(prompt) do
-    getn(device, prompt, 1)
-  end
-
-  @doc """
-  Gets a number of bytes from the IO `device`.
-
-  If the IO `device` is a Unicode device, `count` implies
-  the number of Unicode codepoints to be retrieved.
-  Otherwise, `count` is the number of raw bytes to be retrieved.
-
   It returns:
 
     * `data` - the input characters
@@ -300,33 +218,41 @@ defmodule IO do
     * `{:error, reason}` - other (rare) error condition;
       for instance, `{:error, :estale}` if reading from an
       NFS volume
+  """
+  @spec getn(chardata | String.Chars.t, pos_integer) :: chardata | nodata
+  @spec getn(device, chardata | String.Chars.t) :: chardata | nodata
+  def getn(prompt, count \\ 1)
 
+  def getn(prompt, count) when is_integer(count) do
+    getn(group_leader, prompt, count)
+  end
+
+  def getn(device, prompt) do
+    getn(device, prompt, 1)
+  end
+
+  @doc """
+  Gets a number of bytes from the io device. If the
+  io device is a unicode device, `count` implies
+  the number of unicode codepoints to be retrieved.
+  Otherwise, `count` is the number of raw bytes to be retrieved.
   """
   @spec getn(device, chardata | String.Chars.t, pos_integer) :: chardata | nodata
-  def getn(device, prompt, count) when is_integer(count) and count > 0 do
+  def getn(device, prompt, count) do
     :io.get_chars(map_dev(device), to_chardata(prompt), count)
   end
 
   @doc """
-  Reads a line from the IO `device`.
-
-  It returns:
+  Reads a line from the IO device. It returns:
 
     * `data` - the characters in the line terminated
-      by a line-feed (LF) or end of file (EOF)
+      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 volume
-
-  ## Examples
-
-  To display "What is your name?" as a prompt and await user input:
-
-      IO.gets "What is your name?\n"
-
   """
   @spec gets(device, chardata | String.Chars.t) :: chardata | nodata
   def gets(device \\ group_leader(), prompt) do
@@ -334,16 +260,16 @@ defmodule IO do
   end
 
   @doc """
-  Converts the IO `device` into an `IO.Stream`.
+  Converts the io device into a `IO.Stream`.
 
   An `IO.Stream` implements both `Enumerable` and
   `Collectable`, allowing it to be used for both read
   and write.
 
-  The `device` is iterated by the given number of characters or line by line if
-  `:line` is given.
+  The device is iterated line by line if `:line` is given or
+  by a given number of codepoints.
 
-  This reads from the IO as utf-8. Check out
+  This reads the IO as utf-8. Check out
   `IO.binstream/2` to handle the IO as a raw binary.
 
   Note that an IO stream has side effects and every time
@@ -358,34 +284,28 @@ defmodule IO do
 
   """
   @spec stream(device, :line | pos_integer) :: Enumerable.t
-  def stream(device, line_or_codepoints)
-      when line_or_codepoints == :line
-      when is_integer(line_or_codepoints) and line_or_codepoints > 0 do
+  def stream(device, line_or_codepoints) do
     IO.Stream.__build__(map_dev(device), false, line_or_codepoints)
   end
 
   @doc """
-  Converts the IO `device` into an `IO.Stream`. The operation is Unicode unsafe.
+  Converts the IO device into a `IO.Stream`.
 
   An `IO.Stream` implements both `Enumerable` and
   `Collectable`, allowing it to be used for both read
   and write.
 
-  The `device` is iterated by the given number of bytes or line by line if
-  `:line` is given.
-  This reads from the IO device as a raw binary.
+  The device is iterated line by line or by a number of bytes.
+  This reads the IO device as a raw binary.
 
   Note that an IO stream has side effects and every time
   you go over the stream you may get different results.
 
-  Finally, do not use this function on IO devices in Unicode
+  Finally, do not use this function on IO devices in unicode
   mode as it will return the wrong result.
-
   """
   @spec binstream(device, :line | pos_integer) :: Enumerable.t
-  def binstream(device, line_or_bytes)
-      when line_or_bytes == :line
-      when is_integer(line_or_bytes) and line_or_bytes > 0 do
+  def binstream(device, line_or_bytes) do
     IO.Stream.__build__(map_dev(device), true, line_or_bytes)
   end
 
@@ -393,8 +313,8 @@ defmodule IO do
   Converts chardata (a list of integers representing codepoints,
   lists and strings) into a string.
 
-  In case the conversion fails, it raises an `UnicodeConversionError`.
-  If a string is given, it returns the string itself.
+  In case the conversion fails, it raises a `UnicodeConversionError`.
+  If a string is given, returns the string itself.
 
   ## Examples
 
@@ -404,9 +324,6 @@ defmodule IO do
       iex> IO.chardata_to_string([0x0061, "bc"])
       "abc"
 
-      iex> IO.chardata_to_string("string")
-      "string"
-
   """
   @spec chardata_to_string(chardata) :: String.t | no_return
   def chardata_to_string(string) when is_binary(string) do
@@ -414,17 +331,25 @@ defmodule IO do
   end
 
   def chardata_to_string(list) when is_list(list) do
-    List.to_string(list)
+    case :unicode.characters_to_binary(list) do
+      result when is_binary(result) ->
+        result
+
+      {:error, encoded, rest} ->
+        raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :invalid
+
+      {:incomplete, encoded, rest} ->
+        raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :incomplete
+    end
   end
 
   @doc """
   Converts iodata (a list of integers representing bytes, lists
   and binaries) into a binary.
-  The operation is Unicode unsafe.
 
   Notice that this function treats lists of integers as raw bytes
   and does not perform any kind of encoding conversion. If you want
-  to convert from a charlist to a string (UTF-8 encoded), please
+  to convert from a char list to a string (UTF-8 encoded), please
   use `chardata_to_string/1` instead.
 
   If this function receives a binary, the same binary is returned.
@@ -436,12 +361,12 @@ defmodule IO do
       iex> bin1 = <<1, 2, 3>>
       iex> bin2 = <<4, 5>>
       iex> bin3 = <<6>>
-      iex> IO.iodata_to_binary([bin1, 1, [2, 3, bin2], 4 | bin3])
-      <<1, 2, 3, 1, 2, 3, 4, 5, 4, 6>>
+      iex> IO.iodata_to_binary([bin1, 1, [2, 3, bin2], 4|bin3])
+      <<1,2,3,1,2,3,4,5,4,6>>
 
       iex> bin = <<1, 2, 3>>
       iex> IO.iodata_to_binary(bin)
-      <<1, 2, 3>>
+      <<1,2,3>>
 
   """
   @spec iodata_to_binary(iodata) :: binary
@@ -456,7 +381,7 @@ defmodule IO do
 
   ## Examples
 
-      iex> IO.iodata_length([1, 2 | <<3, 4>>])
+      iex> IO.iodata_length([1, 2|<<3, 4>>])
       4
 
   """
@@ -466,8 +391,8 @@ defmodule IO do
   end
 
   @doc false
-  def each_stream(device, line_or_codepoints) do
-    case read(device, line_or_codepoints) do
+  def each_stream(device, what) do
+    case read(device, what) do
       :eof ->
         {:halt, device}
       {:error, reason} ->
@@ -478,8 +403,8 @@ defmodule IO do
   end
 
   @doc false
-  def each_binstream(device, line_or_chars) do
-    case binread(device, line_or_chars) do
+  def each_binstream(device, what) do
+    case binread(device, what) do
       :eof ->
         {:halt, device}
       {:error, reason} ->
@@ -491,7 +416,7 @@ defmodule IO do
 
   @compile {:inline, map_dev: 1, to_chardata: 1}
 
-  # Map the Elixir names for standard IO and error to Erlang names
+  # Map the Elixir names for standard io and error to Erlang names
   defp map_dev(:stdio),  do: :standard_io
   defp map_dev(:stderr), do: :standard_error
   defp map_dev(other) when is_atom(other) or is_pid(other) or is_tuple(other), do: other

lib/elixir/lib/io/ansi.ex

@@ -1,7 +1,7 @@
 defmodule IO.ANSI.Sequence do
   @moduledoc false
 
-  defmacro defsequence(name, code, terminator \\ "m") do
+  defmacro defsequence(name, code \\ "", terminator \\ "m") do
     quote bind_quoted: [name: name, code: code, terminator: terminator] do
       def unquote(name)() do
         "\e[#{unquote(code)}#{unquote(terminator)}"
@@ -16,25 +16,24 @@ end
 
 defmodule IO.ANSI do
   @moduledoc """
-  Functionality to render ANSI escape sequences.
-
-  [ANSI escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code)
-  are characters embedded in text used to control formatting, color, and
-  other output options on video text terminals.
+  Functionality to render ANSI escape sequences
+  (http://en.wikipedia.org/wiki/ANSI_escape_code) —  characters embedded
+  in text used to control formatting, color, and other output options
+  on video text terminals.
   """
 
   import IO.ANSI.Sequence
 
-  @typep ansicode :: atom
-  @typep ansilist :: maybe_improper_list(char | ansicode | binary | ansilist, binary | ansicode | [])
-  @type  ansidata :: ansilist | ansicode | binary
+  @typep ansicode :: atom()
+  @typep ansilist :: maybe_improper_list(char() | ansicode() | binary() | ansilist(), binary() | ansicode() | [])
+  @type  ansidata :: ansilist() | ansicode() | binary()
 
   @doc """
   Checks if ANSI coloring is supported and enabled on this machine.
 
   This function simply reads the configuration value for
   `:ansi_enabled` in the `:elixir` application. The value is by
-  default `false` unless Elixir can detect during startup that
+  default false unless Elixir can detect during startup that
   both `stdout` and `stderr` are terminals.
   """
   @spec enabled? :: boolean
@@ -42,34 +41,6 @@ defmodule IO.ANSI do
     Application.get_env(:elixir, :ansi_enabled, false)
   end
 
-  @doc "Sets foreground color"
-  @spec color(0..255) :: String.t
-  def color(code) when code in 0..255, do: "\e[38;5;#{code}m"
-
-  @doc ~S"""
-  Sets the foreground color from individual RGB values.
-
-  Valid values for each color are in the range 0 to 5.
-  """
-  @spec color(0..5, 0..5, 0..5) :: String.t
-  def color(r, g, b) when r in 0..5 and g in 0..5 and b in 0..5 do
-    color(16 + (36 * r) + (6 * g) + b)
-  end
-
-  @doc "Sets background color"
-  @spec color_background(0..255) :: String.t
-  def color_background(code) when code in 0..255, do: "\e[48;5;#{code}m"
-
-  @doc ~S"""
-  Sets the background color from individual RGB values.
-
-  Valid values for each color are in the range 0 to 5.
-  """
-  @spec color_background(0..5, 0..5, 0..5) :: String.t
-  def color_background(r, g, b) when r in 0..5 and g in 0..5 and b in 0..5 do
-    color_background(16 + (36 * r) + (6 * g) + b)
-  end
-
   @doc "Resets all attributes"
   defsequence :reset, 0
 
@@ -79,7 +50,7 @@ defmodule IO.ANSI do
   @doc "Faint (decreased intensity), not widely supported"
   defsequence :faint, 2
 
-  @doc "Italic: on. Not widely supported. Sometimes treated as inverse"
+  @doc "Italic: on. Not widely supported. Sometimes treated as inverse."
   defsequence :italic, 3
 
   @doc "Underline: Single"
@@ -100,7 +71,7 @@ defmodule IO.ANSI do
   @doc "Conceal. Not widely supported"
   defsequence :conceal, 8
 
-  @doc "Crossed-out. Characters legible, but marked for deletion. Not widely supported"
+  @doc "Crossed-out. Characters legible, but marked for deletion. Not widely supported."
   defsequence :crossed_out, 9
 
   @doc "Sets primary (default) font"
@@ -124,8 +95,9 @@ defmodule IO.ANSI do
   defsequence :blink_off, 25
 
   colors = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]
+  colors = Enum.zip(0..(length(colors)-1), colors)
 
-  for {color, code} <- Enum.with_index(colors) do
+  for {code, color} <- colors do
     @doc "Sets foreground color to #{color}"
     defsequence color, code + 30
 
@@ -154,17 +126,14 @@ defmodule IO.ANSI do
   @doc "Not overlined"
   defsequence :not_overlined, 55
 
-  @doc "Sends cursor home"
+  @doc "Send cursor home"
   defsequence :home, "", "H"
 
-  @doc "Clears screen"
+  @doc "Clear screen"
   defsequence :clear, "2", "J"
 
-  @doc "Clears line"
-  defsequence :clear_line, "2", "K"
-
   defp format_sequence(other) do
-    raise ArgumentError, "invalid ANSI sequence specification: #{inspect other}"
+    raise ArgumentError, "invalid ANSI sequence specification: #{other}"
   end
 
   @doc ~S"""
@@ -173,7 +142,7 @@ defmodule IO.ANSI do
 
   The named sequences are represented by atoms.
 
-  It will also append an `IO.ANSI.reset/0` to the chardata when a conversion is
+  It will also append an `IO.ANSI.reset` to the chardata when a conversion is
   performed. If you don't want this behaviour, use `format_fragment/2`.
 
   An optional boolean parameter can be passed to enable or disable
@@ -186,8 +155,8 @@ defmodule IO.ANSI do
       [[[[[[], "Hello, "] | "\e[31m"] | "\e[1m"], "world!"] | "\e[0m"]
 
   """
-  def format(chardata, emit? \\ enabled?) when is_boolean(emit?) do
-    do_format(chardata, [], [], emit?, :maybe)
+  def format(chardata, emit \\ enabled?) when is_boolean(emit) do
+    do_format(chardata, [], [], emit, :maybe)
   end
 
   @doc ~S"""
@@ -206,12 +175,12 @@ defmodule IO.ANSI do
       [[[[[[] | "\e[1m"], 87], 111], 114], 100]
 
   """
-  def format_fragment(chardata, emit? \\ enabled?) when is_boolean(emit?) do
-    do_format(chardata, [], [], emit?, false)
+  def format_fragment(chardata, emit \\ enabled?) when is_boolean(emit) do
+    do_format(chardata, [], [], emit, false)
   end
 
-  defp do_format([term | rest], rem, acc, emit?, append_reset) do
-    do_format(term, [rest | rem], acc, emit?, append_reset)
+  defp do_format([term | rest], rem, acc, emit, append_reset) do
+    do_format(term, [rest | rem], acc, emit, append_reset)
   end
 
   defp do_format(term, rem, acc, true, append_reset) when is_atom(term) do
@@ -222,19 +191,19 @@ defmodule IO.ANSI do
     do_format([], rem, acc, false, append_reset)
   end
 
-  defp do_format(term, rem, acc, emit?, append_reset) when not is_list(term) do
-    do_format([], rem, [acc, term], emit?, append_reset)
+  defp do_format(term, rem, acc, emit, append_reset) when not is_list(term) do
+    do_format([], rem, [acc | [term]], emit, append_reset)
   end
 
-  defp do_format([], [next | rest], acc, emit?, append_reset) do
-    do_format(next, rest, acc, emit?, append_reset)
+  defp do_format([], [next | rest], acc, emit, append_reset) do
+    do_format(next, rest, acc, emit, append_reset)
   end
 
   defp do_format([], [], acc, true, true) do
     [acc | IO.ANSI.reset]
   end
 
-  defp do_format([], [], acc, _emit?, _append_reset) do
+  defp do_format([], [], acc, _emit, _append_reset) do
     acc
   end
 end

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

@@ -25,10 +25,10 @@ defmodule IO.ANSI.Docs do
     [enabled:           true,
      doc_bold:          [:bright],
      doc_code:          [:cyan, :bright],
-     doc_headings:      [:yellow],
+     doc_headings:      [:yellow, :bright],
      doc_inline_code:   [:cyan],
      doc_table_heading: [:reverse],
-     doc_title:         [:reverse, :yellow],
+     doc_title:         [:reverse, :yellow, :bright],
      doc_underline:     [:underline],
      width:             80]
   end
@@ -43,7 +43,7 @@ defmodule IO.ANSI.Docs do
     options = Keyword.merge(default_options, options)
     width   = options[:width]
     padding = div(width + String.length(heading), 2)
-    heading = heading |> String.pad_leading(padding) |> String.pad_trailing(width)
+    heading = heading |> String.rjust(padding) |> String.ljust(width)
     write(:doc_title, heading, options)
     newline_after_block
   end
@@ -57,8 +57,8 @@ defmodule IO.ANSI.Docs do
   def print(doc, options \\ []) do
     options = Keyword.merge(default_options, options)
     doc
-    |> String.split(["\r\n", "\n"], trim: false)
-    |> Enum.map(&String.trim_trailing/1)
+    |> String.split(["\r\n","\n"], trim: false)
+    |> Enum.map(&String.rstrip/1)
     |> process([], "", options)
   end
 
@@ -68,19 +68,19 @@ defmodule IO.ANSI.Docs do
 
   defp process(["# " <> heading | rest], text, indent, options) do
     write_text(text, indent, options)
-    write_h1(String.trim(heading), options)
+    write_h1(String.strip(heading), options)
     process(rest, [], "", options)
   end
 
   defp process(["## " <> heading | rest], text, indent, options) do
     write_text(text, indent, options)
-    write_h2(String.trim(heading), options)
+    write_h2(String.strip(heading), options)
     process(rest, [], "", options)
   end
 
   defp process(["### " <> heading | rest], text, indent, options) do
     write_text(text, indent, options)
-    write_h3(String.trim(heading), indent, options)
+    write_h3(String.strip(heading), indent, options)
     process(rest, [], "", options)
   end
 
@@ -94,25 +94,25 @@ defmodule IO.ANSI.Docs do
     process_code(rest, [line], indent, options)
   end
 
-  defp process(["```" <> _line | rest], text, indent, options) do
-    process_fenced_code_block(rest, text, indent, options, _delimiter = "```")
-  end
-
-  defp process(["~~~" <> _line | rest], text, indent, options) do
-    process_fenced_code_block(rest, text, indent, options, _delimiter = "~~~")
-  end
-
   defp process(all=[line | rest], text, indent, options) do
     {stripped, count} = strip_spaces(line, 0, :infinity)
-    cond do
-      link_label?(stripped, count) ->
-        write_text([line], indent, options, true)
-        process(rest, text, indent, options)
-      table_line?(stripped) and rest != [] and table_line?(hd(rest)) ->
-        write_text(text, indent, options)
-        process_table(all, indent, options)
-      true ->
-        process_rest(stripped, rest, count, text, indent, options)
+    if is_table_line?(stripped) and rest != [] and is_table_line?(hd(rest)) do
+      write_text(text, indent, options)
+      process_table(all, indent, options)
+    else
+      case stripped do
+        <<bullet, ?\s, item :: binary>> when bullet in @bullets ->
+          write_text(text, indent, options)
+          process_list("• ", item, rest, count, indent, options)
+        <<d1, ?., ?\s, item :: binary>> when d1 in ?0..?9 ->
+          write_text(text, indent, options)
+          process_list(<<d1, ?., ?\s>>, item, rest, count, indent, options)
+        <<d1, d2, ?., ?\s, item :: binary>> when d1 in ?0..?9 and d2 in ?0..?9 ->
+          write_text(text, indent, options)
+          process_list(<<d1, d2, ?., ?\s>>, item, rest, count, indent, options)
+        _ ->
+          process(rest, [stripped | text], indent, options)
+      end
     end
   end
 
@@ -135,25 +135,9 @@ defmodule IO.ANSI.Docs do
 
   ## Lists
 
-  defp process_rest(stripped, rest, count, text, indent, options) do
-    case stripped do
-      <<bullet, ?\s, item::binary>> when bullet in @bullets ->
-        write_text(text, indent, options)
-        process_list("• ", item, rest, count, indent, options)
-      <<d1, ?., ?\s, item::binary>> when d1 in ?0..?9 ->
-        write_text(text, indent, options)
-        process_list(<<d1, ?., ?\s>>, item, rest, count, indent, options)
-      <<d1, d2, ?., ?\s, item::binary>> when d1 in ?0..?9 and d2 in ?0..?9 ->
-        write_text(text, indent, options)
-        process_list(<<d1, d2, ?., ?\s>>, item, rest, count, indent, options)
-      _ ->
-        process(rest, [stripped | text], indent, options)
-    end
-  end
-
   defp process_list(entry, line, rest, count, indent, options) do
     # The first list always win some extra padding
-    entry = if indent == "", do: "  " <> entry, else: entry
+    if indent == "", do: entry = "  " <> entry
     new_indent = indent <> String.duplicate(" ", String.length(entry))
 
     {contents, rest, done} = process_list_next(rest, count, byte_size(new_indent), [])
@@ -178,11 +162,11 @@ defmodule IO.ANSI.Docs do
 
   defp process_list_next_kind(stripped, rest, count, next_count) do
     case {stripped, rest} do
-      {<<bullet, ?\s, _::binary>>, _} when bullet in @bullets and next_count <= count ->
+      {<<bullet, ?\s, _ :: binary>>, _} when bullet in @bullets and next_count <= count ->
         :list
-      {<<d1, ?., ?\s, _::binary>>, _} when d1 in ?0..?9 and next_count <= count ->
+      {<<d1, ?., ?\s, _ :: binary>>, _} when d1 in ?0..?9 and next_count <= count ->
         :list
-      {<<d1, d2, ?., ?\s, _::binary>>, _} when d1 in ?0..?9 and d2 in ?0..?9 and next_count <= count ->
+      {<<d1, d2, ?., ?\s, _ :: binary>>, _} when d1 in ?0..?9 and d2 in ?0..?9 and next_count <= count ->
         :list
       {"", [" " <> _ | _]} ->
         :next
@@ -197,7 +181,7 @@ defmodule IO.ANSI.Docs do
 
   defp write_text(text, indent, options) do
     case Enum.reverse(text) do
-      [:no_wrap | rest] -> write_text(rest, indent, options, true)
+      [:no_wrap|rest] -> write_text(rest, indent, options, true)
       rest -> write_text(rest, indent, options, false)
     end
   end
@@ -210,7 +194,7 @@ defmodule IO.ANSI.Docs do
     lines
     |> Enum.join(" ")
     |> handle_links
-    |> handle_inline(options)
+    |> handle_inline(nil, [], [], options)
     |> String.split(~r{\s})
     |> write_with_wrap(options[:width] - byte_size(indent), indent, no_wrap)
 
@@ -229,7 +213,7 @@ defmodule IO.ANSI.Docs do
   end
 
   defp process_code(["    " <> line | rest], code, indent, options) do
-    process_code(rest, [line | code], indent, options)
+    process_code(rest, [line|code], indent, options)
   end
 
   defp process_code(rest, code, indent, options) do
@@ -237,23 +221,6 @@ defmodule IO.ANSI.Docs do
     process(rest, [], indent, options)
   end
 
-  defp process_fenced_code_block(rest, text, indent, options, delimiter) do
-    write_text(text, indent, options)
-    process_fenced_code(rest, [], indent, options, delimiter)
-  end
-
-  defp process_fenced_code([], code, indent, options, _delimiter) do
-    write_code(code, indent, options)
-  end
-
-  defp process_fenced_code([line | rest], code, indent, options, delimiter) do
-    if line === delimiter do
-      process_code(rest, code, indent, options)
-    else
-      process_fenced_code(rest, [line | code], indent, options, delimiter)
-    end
-  end
-
   defp write_code(code, indent, options) do
     write(:doc_code, "#{indent}┃ #{Enum.join(Enum.reverse(code), "\n#{indent}┃ ")}", options)
     newline_after_block
@@ -262,7 +229,7 @@ defmodule IO.ANSI.Docs do
   ## Tables
 
   defp process_table(lines, indent, options) do
-    {table, rest} = Enum.split_while(lines, &table_line?/1)
+    {table, rest} = Enum.split_while(lines, &is_table_line?/1)
     table_lines(table, options)
     newline_after_block
     process(rest, [], indent, options)
@@ -285,8 +252,8 @@ defmodule IO.ANSI.Docs do
 
   defp split_into_columns(line, options) do
     line
-    |> String.trim("|")
-    |> String.trim()
+    |> String.strip(?|)
+    |> String.strip()
     |> String.split(~r/\s\|\s/)
     |> Enum.map(&render_column(&1, options))
   end
@@ -295,7 +262,7 @@ defmodule IO.ANSI.Docs do
     col = col
           |> String.replace(~r/\\ \|/x, "|")
           |> handle_links
-          |> handle_inline(options)
+          |> handle_inline(nil, [], [], options)
     {col, length_without_escape(col, 0)}
   end
 
@@ -303,7 +270,7 @@ defmodule IO.ANSI.Docs do
     do: cols ++ List.duplicate({"", 0}, col_count - length(cols))
 
   defp max_column_widths(cols, widths),
-    do: Enum.zip(cols, widths) |> Enum.map(fn {a, b} -> max(a, b) end)
+    do: Enum.zip(cols, widths) |> Enum.map(fn {a,b} -> max(a,b) end)
 
   # If second line is heading separator, use the heading style on the first
   defp render_table([first, second | rest], widths, options) do
@@ -342,7 +309,7 @@ defmodule IO.ANSI.Docs do
     end
   end
 
-  defp table_line?(line) do
+  defp is_table_line?(line) do
     Regex.match?(~r'''
       ( ^ \s{0,3} \| (?: [^|]+ \|)+ \s* $ )
     |
@@ -352,14 +319,6 @@ defmodule IO.ANSI.Docs do
 
   ## Helpers
 
-  defp link_label?("[" <> rest, count) when count <= 3, do: link_label?(rest)
-  defp link_label?(_, _), do: false
-
-  defp link_label?("]: " <> _), do: true
-  defp link_label?("]" <> _), do: false
-  defp link_label?(""), do: false
-  defp link_label?(<<_>> <> rest), do: link_label?(rest)
-
   defp strip_spaces(" " <> line, acc, max) when acc < max,
     do: strip_spaces(line, acc + 1, max)
   defp strip_spaces(rest, acc, _max),
@@ -379,13 +338,13 @@ defmodule IO.ANSI.Docs do
     write_with_wrap(rest, available, indent, false)
   end
 
-  defp take_words([word | words], available, acc) do
+  defp take_words([word|words], available, acc) do
     available = available - length_without_escape(word, 0)
 
     cond do
       # It fits, take one for space and continue decreasing
       available > 0 ->
-        take_words(words, available - 1, [word | acc])
+        take_words(words, available - 1, [word|acc])
 
       # No space but we got no words
       acc == [] ->
@@ -393,7 +352,7 @@ defmodule IO.ANSI.Docs do
 
       # Otherwise
       true ->
-        {Enum.reverse(acc), [word | words]}
+        {Enum.reverse(acc), [word|words]}
     end
   end
 
@@ -401,11 +360,11 @@ defmodule IO.ANSI.Docs do
     {Enum.reverse(acc), []}
   end
 
-  defp length_without_escape(<<?\e, ?[, _, _, ?m>> <> rest, count) do
+  defp length_without_escape(<< ?\e, ?[, _, _, ?m, rest :: binary >>, count) do
     length_without_escape(rest, count)
   end
 
-  defp length_without_escape(<<?\e, ?[, _, ?m>> <> rest, count) do
+  defp length_without_escape(<< ?\e, ?[, _, ?m, rest :: binary >>, count) do
     length_without_escape(rest, count)
   end
 
@@ -423,123 +382,83 @@ defmodule IO.ANSI.Docs do
   end
 
   defp escape_underlines_in_link(text) do
-    Regex.replace(~r{https?\S*}, text, &String.replace(&1, "_", "\\_"))
+    case Regex.match?(~r{.*(https?\S*)}, text) do
+      true -> Regex.replace(~r{_}, text, "\\\\_")
+      _    -> text
+    end
   end
 
   defp remove_square_brackets_in_link(text) do
     Regex.replace(~r{\[(.*?)\]\((.*?)\)}, text, "\\1 (\\2)")
   end
 
+  # Single inline quotes.
+  @single [?`, ?_, ?*]
 
-  # We have four entries: **, *, _ and `.
-  #
-  # The first three behave the same while the last one is simpler
-  # when it comes to delimiters. But, since the first has two
-  # characters, we need to handle 3 cases:
-  #
-  # 1. **
-  # 2. _ and *
-  # 3. `
-  #
-  # Where the first two should have the same code but match differently.
-  @single [?_, ?*]
+  # ` does not require space in between
+  @spaced [?_, ?*]
 
-  # Characters that can mark the beginning or the end of a word.
-  # Only support the most common ones at this moment.
-  @delimiters [?\s, ?', ?", ?!, ?@, ?#, ?$, ?%, ?^, ?&, ?-, ?+, ?(, ?), ?[, ?], ?{, ?}, ?<, ?>, ?.]
-
-  # Inline start
-
-  defp handle_inline(<<?*, ?*, rest::binary>>, options) do
-    handle_inline(rest, ?d, ["**"], [], options)
+  # Clauses for handling spaces
+  defp handle_inline(<<?*, ?*, ?\s, rest :: binary>>, nil, buffer, acc, options) do
+    handle_inline(rest, nil, [?\s, ?*, ?*|buffer], acc, options)
   end
 
-  defp handle_inline(<<mark, rest::binary>>, options) when mark in @single do
-    handle_inline(rest, mark, [<<mark>>], [], options)
+  defp handle_inline(<<mark, ?\s, rest :: binary>>, nil, buffer, acc, options) when mark in @spaced do
+    handle_inline(rest, nil, [?\s, mark|buffer], acc, options)
   end
 
-  defp handle_inline(rest, options) do
-    handle_inline(rest, nil, [], [], options)
+  defp handle_inline(<<?\s, ?*, ?*, rest :: binary>>, limit, buffer, acc, options) do
+    handle_inline(rest, limit, [?*, ?*, ?\s|buffer], acc, options)
   end
 
-  # Inline delimiters
-
-  defp handle_inline(<<delimiter, ?*, ?*, rest::binary>>, nil, buffer, acc, options)
-      when rest != "" and delimiter in @delimiters do
-    handle_inline(rest, ?d, ["**"], [delimiter, Enum.reverse(buffer) | acc], options)
-  end
-
-  defp handle_inline(<<delimiter, mark, rest::binary>>, nil, buffer, acc, options)
-      when rest != "" and delimiter in @delimiters and mark in @single do
-    handle_inline(rest, mark, [<<mark>>], [delimiter, Enum.reverse(buffer) | acc], options)
-  end
-
-  defp handle_inline(<<?`, rest::binary>>, nil, buffer, acc, options)
-      when rest != "" do
-    handle_inline(rest, ?`, ["`"], [Enum.reverse(buffer) | acc], options)
+  defp handle_inline(<<?\s, mark, rest :: binary>>, limit, buffer, acc, options) when mark in @spaced do
+    handle_inline(rest, limit, [mark, ?\s|buffer], acc, options)
   end
 
   # Clauses for handling escape
-
-  defp handle_inline(<<?\\, ?\\, ?*, ?*, rest::binary>>, nil, buffer, acc, options)
-      when rest != "" do
-    handle_inline(rest, ?d, ["**"], [?\\, Enum.reverse(buffer) | acc], options)
+  defp handle_inline(<<?\\, ?\\, rest :: binary>>, limit, buffer, acc, options) do
+    handle_inline(rest, limit, [?\\|buffer], acc, options)
   end
 
-  defp handle_inline(<<?\\, ?\\, mark, rest::binary>>, nil, buffer, acc, options)
-      when rest != "" and mark in @single do
-    handle_inline(rest, mark, [<<mark>>], [?\\, Enum.reverse(buffer) | acc], options)
+  defp handle_inline(<<?\\, ?*, ?*, rest :: binary>>, limit, buffer, acc, options) do
+    handle_inline(rest, limit, [?*, ?*|buffer], acc, options)
   end
 
-  defp handle_inline(<<?\\, ?\\, rest::binary>>, limit, buffer, acc, options) do
-    handle_inline(rest, limit, [?\\ | buffer], acc, options)
+  # A escape is not valid inside `
+  defp handle_inline(<<?\\, mark, rest :: binary>>, limit, buffer, acc, options)
+      when mark in [?_, ?*, ?`] and not(mark == limit and mark == ?`) do
+    handle_inline(rest, limit, [mark|buffer], acc, options)
   end
 
-  # An escape is not valid inside `
-  defp handle_inline(<<?\\, mark, rest::binary>>, limit, buffer, acc, options)
-      when not(mark == limit and mark == ?`) do
-    handle_inline(rest, limit, [mark | buffer], acc, options)
+  # Inline start
+  defp handle_inline(<<?*, ?*, rest :: binary>>, nil, buffer, acc, options) when rest != "" do
+    handle_inline(rest, ?d, ["**"], [Enum.reverse(buffer)|acc], options)
+  end
+
+  defp handle_inline(<<mark, rest :: binary>>, nil, buffer, acc, options) when rest != "" and mark in @single do
+    handle_inline(rest, mark, [<<mark>>], [Enum.reverse(buffer)|acc], options)
   end
 
   # Inline end
-
-  defp handle_inline(<<?*, ?*, delimiter, rest::binary>>, ?d, buffer, acc, options)
-      when delimiter in @delimiters do
-    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer(buffer, options) | acc], options)
+  defp handle_inline(<<?*, ?*, rest :: binary>>, ?d, buffer, acc, options) do
+    handle_inline(rest, nil, [], [inline_buffer(buffer, options)|acc], options)
   end
 
-  defp handle_inline(<<mark, delimiter, rest::binary>>, mark, buffer, acc, options)
-      when delimiter in @delimiters and mark in @single do
-    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer(buffer, options) | acc], options)
+  defp handle_inline(<<mark, rest :: binary>>, mark, buffer, acc, options) when mark in @single do
+    handle_inline(rest, nil, [], [inline_buffer(buffer, options)|acc], options)
   end
 
-  defp handle_inline(<<?*, ?*, rest::binary>>, ?d, buffer, acc, options)
-      when rest == "" do
-    handle_inline(<<>>, nil, [], [inline_buffer(buffer, options) | acc], options)
-  end
-
-  defp handle_inline(<<mark, rest::binary>>, mark, buffer, acc, options)
-      when rest == "" and mark in @single do
-    handle_inline(<<>>, nil, [], [inline_buffer(buffer, options) | acc], options)
-  end
-
-  defp handle_inline(<<?`, rest::binary>>, ?`, buffer, acc, options) do
-    handle_inline(rest, nil, [], [inline_buffer(buffer, options) | acc], options)
-  end
-
-  # Catch all
-
-  defp handle_inline(<<char, rest::binary>>, mark, buffer, acc, options) do
-    handle_inline(rest, mark, [char | buffer], acc, options)
+  defp handle_inline(<<char, rest :: binary>>, mark, buffer, acc, options) do
+    handle_inline(rest, mark, [char|buffer], acc, options)
   end
 
   defp handle_inline(<<>>, _mark, buffer, acc, _options) do
-    IO.iodata_to_binary Enum.reverse([Enum.reverse(buffer) | acc])
+    IO.iodata_to_binary Enum.reverse([Enum.reverse(buffer)|acc])
   end
 
   defp inline_buffer(buffer, options) do
-    [h | t] = Enum.reverse([IO.ANSI.reset | buffer])
-    [color_for(h, options) | t]
+    [h|t] = Enum.reverse([IO.ANSI.reset|buffer])
+    [color_for(h, options)|t]
   end
 
   defp color_for(mark, colors) do

lib/elixir/lib/io/stream.ex

@@ -10,7 +10,7 @@ end
 
 defmodule IO.Stream do
   @moduledoc """
-  Defines an `IO.Stream` struct returned by `IO.stream/2` and `IO.binstream/2`.
+  Defines a `IO.Stream` struct returned by `IO.stream/2` and `IO.binstream/2`.
 
   The following fields are public:
 
@@ -18,9 +18,6 @@ defmodule IO.Stream do
     * `raw`           - a boolean indicating if bin functions should be used
     * `line_or_bytes` - if reading should read lines or a given amount of bytes
 
-  It is worth noting that an IO stream has side effects and every time you go
-  over the stream you may get different results.
-
   """
 
   defstruct device: nil, raw: true, line_or_bytes: :line
@@ -33,6 +30,10 @@ defmodule IO.Stream do
   end
 
   defimpl Collectable do
+    def empty(stream) do
+      stream
+    end
+
     def into(%{device: device, raw: raw} = stream) do
       {:ok, into(stream, device, raw)}
     end

lib/elixir/lib/kernel/cli.ex

@@ -12,6 +12,7 @@ defmodule Kernel.CLI do
     argv = for arg <- argv, do: IO.chardata_to_string(arg)
 
     {config, argv} = parse_argv(argv)
+    :elixir_code_server.cast({:paths, config.pa, config.pz})
     System.argv(argv)
 
     run fn _ ->
@@ -33,17 +34,10 @@ defmodule Kernel.CLI do
   by escripts generated by Elixir.
   """
   def run(fun, halt \\ true) do
-    {ok_or_shutdown, status} = exec_fun(fun, {:ok, 0})
-    if ok_or_shutdown == :shutdown or halt do
-      {_, status} = at_exit({ok_or_shutdown, status})
-
-      # Ensure Logger messages are flushed before halting
-      case :erlang.whereis(Logger) do
-        pid when is_pid(pid) -> Logger.flush()
-        _ -> :ok
-      end
-
-      System.halt(status)
+    res = exec_fun(fun, {:ok, 0})
+    if elem(res, 0) == :shutdown or halt do
+      {_, int} = at_exit(res)
+      System.halt(int)
     end
   end
 
@@ -62,7 +56,7 @@ defmodule Kernel.CLI do
   ## Helpers
 
   defp at_exit(res) do
-    hooks = :elixir_config.get_and_put(:at_exit, [])
+    hooks = :elixir_code_server.call(:flush_at_exit)
     res = Enum.reduce(hooks, res, &exec_fun/2)
     if hooks == [], do: res, else: at_exit(res)
   end
@@ -71,7 +65,7 @@ defmodule Kernel.CLI do
     parent = self()
 
     {pid, ref} =
-      spawn_monitor(fn ->
+      spawn_monitor fn ->
         try do
           fun.(elem(res, 1))
         catch
@@ -88,12 +82,12 @@ defmodule Kernel.CLI do
             stack = System.stacktrace
             print_error(kind, reason, stack)
             send parent, {self, {:shutdown, 1}}
-            exit(to_exit(kind, reason, stack))
+            :erlang.raise(kind, reason, stack)
         else
           _ ->
             send parent, {self, res}
         end
-      end)
+      end
 
     receive do
       {^pid, res} ->
@@ -105,13 +99,9 @@ defmodule Kernel.CLI do
     end
   end
 
-  defp to_exit(:throw, reason, stack), do: {{:nocatch, reason}, stack}
-  defp to_exit(:error, reason, stack), do: {reason, stack}
-  defp to_exit(:exit, reason, _stack), do: reason
-
   defp shared_option?(list, config, callback) do
     case parse_shared(list, config) do
-      {[h | hs], _} when h == hd(list) ->
+      {[h|hs], _} when h == hd(list) ->
         new_config = %{config | errors: ["#{h} : Unknown option" | config.errors]}
         callback.(hs, new_config)
       {new_list, new_config} ->
@@ -123,20 +113,19 @@ defmodule Kernel.CLI do
     IO.puts :stderr, Exception.format(kind, reason, prune_stacktrace(trace))
   end
 
-  @elixir_internals [:elixir, :elixir_exp, :elixir_compiler, :elixir_module, :elixir_clauses,
-                     :elixir_translator, :elixir_expand, :elixir_lexical, :elixir_exp_clauses,
-                     :elixir_def, :elixir_map]
+  @elixir_internals [:elixir, :elixir_exp, :elixir_compiler, :elixir_module, :elixir_translator,
+                     :elixir_expand, :elixir_lexical]
 
-  defp prune_stacktrace([{mod, _, _, _} | t]) when mod in @elixir_internals do
+  defp prune_stacktrace([{mod, _, _, _}|t]) when mod in @elixir_internals do
     prune_stacktrace(t)
   end
 
-  defp prune_stacktrace([{__MODULE__, :wrapper, 1, _} | _]) do
+  defp prune_stacktrace([{__MODULE__, :wrapper, 1, _}|_]) do
     []
   end
 
-  defp prune_stacktrace([h | t]) do
-    [h | prune_stacktrace(t)]
+  defp prune_stacktrace([h|t]) do
+    [h|prune_stacktrace(t)]
   end
 
   defp prune_stacktrace([]) do
@@ -145,54 +134,48 @@ defmodule Kernel.CLI do
 
   # Parse shared options
 
-  defp parse_shared([opt | _t], _config) when opt in ["-v", "--version"] do
-    if function_exported?(IEx, :started?, 0) and IEx.started? do
-      IO.puts "IEx " <> System.build_info[:build]
-    else
-      IO.puts :erlang.system_info(:system_version)
-      IO.puts "Elixir " <> System.build_info[:build]
-    end
-
+  defp parse_shared([opt|_t], _config) when opt in ["-v", "--version"] do
+    IO.puts "Elixir #{System.version}"
     System.halt 0
   end
 
-  defp parse_shared(["-pa", h | t], config) do
+  defp parse_shared(["-pa", h|t], config) do
     paths = expand_code_path(h)
     Enum.each(paths, &:code.add_patha/1)
     parse_shared t, %{config | pa: config.pa ++ paths}
   end
 
-  defp parse_shared(["-pz", h | t], config) do
+  defp parse_shared(["-pz", h|t], config) do
     paths = expand_code_path(h)
     Enum.each(paths, &:code.add_pathz/1)
     parse_shared t, %{config | pz: config.pz ++ paths}
   end
 
-  defp parse_shared(["--app", h | t], config) do
+  defp parse_shared(["--app", h|t], config) do
     parse_shared t, %{config | commands: [{:app, h} | config.commands]}
   end
 
-  defp parse_shared(["--no-halt" | t], config) do
+  defp parse_shared(["--no-halt"|t], config) do
     parse_shared t, %{config | halt: false}
   end
 
-  defp parse_shared(["-e", h | t], config) do
+  defp parse_shared(["-e", h|t], config) do
     parse_shared t, %{config | commands: [{:eval, h} | config.commands]}
   end
 
-  defp parse_shared(["-r", h | t], config) do
+  defp parse_shared(["-r", h|t], config) do
     parse_shared t, %{config | commands: [{:require, h} | config.commands]}
   end
 
-  defp parse_shared(["-pr", h | t], config) do
+  defp parse_shared(["-pr", h|t], config) do
     parse_shared t, %{config | commands: [{:parallel_require, h} | config.commands]}
   end
 
-  defp parse_shared([erl, _ | t], config) when erl in ["--erl", "--sname", "--name", "--cookie", "--logger-otp-reports", "--logger-sasl-reports"] do
+  defp parse_shared([erl, _|t], config) when erl in ["--erl", "--sname", "--name", "--cookie"] do
     parse_shared t, config
   end
 
-  defp parse_shared([erl | t], config) when erl in ["--detached", "--hidden", "--werl"] do
+  defp parse_shared([erl|t], config) when erl in ["--detached", "--hidden", "--werl"] do
     parse_shared t, config
   end
 
@@ -203,30 +186,30 @@ defmodule Kernel.CLI do
   defp expand_code_path(path) do
     path = Path.expand(path)
     case Path.wildcard(path) do
-      []   -> [to_charlist(path)]
-      list -> Enum.map(list, &to_charlist/1)
+      []   -> [to_char_list(path)]
+      list -> Enum.map(list, &to_char_list/1)
     end
   end
 
   # Process init options
 
-  defp parse_argv(["--" | t], config) do
+  defp parse_argv(["--"|t], config) do
     {config, t}
   end
 
-  defp parse_argv(["+elixirc" | t], config) do
+  defp parse_argv(["+elixirc"|t], config) do
     parse_compiler t, config
   end
 
-  defp parse_argv(["+iex" | t], config) do
+  defp parse_argv(["+iex"|t], config) do
     parse_iex t, config
   end
 
-  defp parse_argv(["-S", h | t], config) do
+  defp parse_argv(["-S", h|t], config) do
     {%{config | commands: [{:script, h} | config.commands]}, t}
   end
 
-  defp parse_argv([h | t] = list, config) do
+  defp parse_argv([h|t] = list, config) do
     case h do
       "-" <> _ ->
         shared_option? list, config, &parse_argv(&1, &2)
@@ -245,35 +228,35 @@ defmodule Kernel.CLI do
 
   # Parse compiler options
 
-  defp parse_compiler(["--" | t], config) do
+  defp parse_compiler(["--"|t], config) do
     {config, t}
   end
 
-  defp parse_compiler(["-o", h | t], config) do
+  defp parse_compiler(["-o", h|t], config) do
     parse_compiler t, %{config | output: h}
   end
 
-  defp parse_compiler(["--no-docs" | t], config) do
+  defp parse_compiler(["--no-docs"|t], config) do
     parse_compiler t, %{config | compiler_options: [{:docs, false} | config.compiler_options]}
   end
 
-  defp parse_compiler(["--no-debug-info" | t], config) do
+  defp parse_compiler(["--no-debug-info"|t], config) do
     parse_compiler t, %{config | compiler_options: [{:debug_info, false} | config.compiler_options]}
   end
 
-  defp parse_compiler(["--ignore-module-conflict" | t], config) do
+  defp parse_compiler(["--ignore-module-conflict"|t], config) do
     parse_compiler t, %{config | compiler_options: [{:ignore_module_conflict, true} | config.compiler_options]}
   end
 
-  defp parse_compiler(["--warnings-as-errors" | t], config) do
+  defp parse_compiler(["--warnings-as-errors"|t], config) do
     parse_compiler t, %{config | compiler_options: [{:warnings_as_errors, true} | config.compiler_options]}
   end
 
-  defp parse_compiler(["--verbose" | t], config) do
+  defp parse_compiler(["--verbose"|t], config) do
     parse_compiler t, %{config | verbose_compile: true}
   end
 
-  defp parse_compiler([h | t] = list, config) do
+  defp parse_compiler([h|t] = list, config) do
     case h do
       "-" <> _ ->
         shared_option? list, config, &parse_compiler(&1, &2)
@@ -284,30 +267,30 @@ defmodule Kernel.CLI do
   end
 
   defp parse_compiler([], config) do
-    {%{config | commands: [{:compile, config.compile} | config.commands]}, []}
+    {%{config | commands: [{:compile, config.compile}|config.commands]}, []}
   end
 
-  # Parse IEx options
+  # Parse iex options
 
-  defp parse_iex(["--" | t], config) do
+  defp parse_iex(["--"|t], config) do
     {config, t}
   end
 
   # This clause is here so that Kernel.CLI does not
   # error out with "unknown option"
-  defp parse_iex(["--dot-iex", _ | t], config) do
+  defp parse_iex(["--dot-iex", _|t], config) do
     parse_iex t, config
   end
 
-  defp parse_iex([opt, _ | t], config) when opt in ["--remsh"] do
+  defp parse_iex([opt, _|t], config) when opt in ["--remsh"] do
     parse_iex t, config
   end
 
-  defp parse_iex(["-S", h | t], config) do
+  defp parse_iex(["-S", h|t], config) do
     {%{config | commands: [{:script, h} | config.commands]}, t}
   end
 
-  defp parse_iex([h | t] = list, config) do
+  defp parse_iex([h|t] = list, config) do
     case h do
       "-" <> _ ->
         shared_option? list, config, &parse_iex(&1, &2)
@@ -390,13 +373,8 @@ defmodule Kernel.CLI do
       {:ok, files} ->
         wrapper fn ->
           Code.compiler_options(config.compiler_options)
-          opts =
-            if config.verbose_compile do
-              [each_long_compilation: &IO.puts("Compiling #{&1} (it's taking more than 5s)")]
-            else
-              []
-            end
-          Kernel.ParallelCompiler.files_to_path(files, config.output, opts)
+          Kernel.ParallelCompiler.files_to_path(files, config.output,
+            each_file: fn file -> if config.verbose_compile do IO.puts "Compiled #{file}" end end)
         end
       {:missing, missing} ->
         {:error, "No files matched pattern(s) #{Enum.join(missing, ",")}"}
@@ -404,10 +382,7 @@ defmodule Kernel.CLI do
   end
 
   defp filter_patterns(pattern) do
-    pattern
-    |> Path.wildcard
-    |> :lists.usort
-    |> Enum.filter(&File.regular?/1)
+    Enum.filter(Enum.uniq(Path.wildcard(pattern)), &File.regular?(&1))
   end
 
   defp filter_multiple_patterns(patterns) do
@@ -427,9 +402,9 @@ defmodule Kernel.CLI do
        &elem(&1, 1)
 
     if missing_patterns == [] do
-      {:ok, :lists.usort(Enum.concat(files))}
+      {:ok, Enum.uniq(Enum.concat(files))}
     else
-      {:missing, :lists.usort(missing_patterns)}
+      {:missing,  Enum.uniq(missing_patterns)}
     end
   end
 

lib/elixir/lib/kernel/error_handler.ex

@@ -4,34 +4,37 @@ defmodule Kernel.ErrorHandler do
   @moduledoc false
 
   def undefined_function(module, fun, args) do
-    ensure_loaded(module) or ensure_compiled(module, :module)
+    ensure_loaded(module)
     :error_handler.undefined_function(module, fun, args)
   end
 
   def undefined_lambda(module, fun, args) do
-    ensure_loaded(module) or ensure_compiled(module, :module)
+    ensure_loaded(module)
     :error_handler.undefined_lambda(module, fun, args)
   end
 
-  def ensure_loaded(module) do
-    case :code.ensure_loaded(module) do
-      {:module, _} -> true
-      {:error, _} -> false
-    end
+  def release() do
+    # On release, no further allow elixir_ensure_compiled
+    # directives and revert to the original error handler.
+    # Note we should not delete the elixir_compiler_pid though,
+    # as we still want to send notifications to the compiler.
+    :erlang.erase(:elixir_ensure_compiled)
+    :erlang.process_flag(:error_handler, :error_handler)
+    :ok
   end
 
-  # Never wait on nil because it should never be defined.
-  def ensure_compiled(nil, _kind) do
-    false
-  end
-  def ensure_compiled(module, kind) do
-    parent = :erlang.get(:elixir_compiler_pid)
-    ref    = :erlang.make_ref
-    send parent, {:waiting, kind, self(), ref, module, :elixir_module.compiler_modules()}
-    :erlang.garbage_collect(self)
-    receive do
-      {^ref, :found}     -> true
-      {^ref, :not_found} -> false
+  defp ensure_loaded(module) do
+    case Code.ensure_loaded(module) do
+      {:module, _} -> :ok
+      {:error, _} ->
+        parent = :erlang.get(:elixir_compiler_pid)
+        ref    = :erlang.make_ref
+        send parent, {:waiting, :module, self(), ref, module}
+        :erlang.garbage_collect(self)
+        receive do
+          {^ref, :ready}   -> :ok
+          {^ref, :release} -> release()
+        end
     end
   end
 end

lib/elixir/lib/kernel/lexical_tracker.ex

@@ -1,6 +1,9 @@
-# This is an Elixir module responsible for tracking
+# This is a module Elixir responsible for tracking
 # the usage of aliases, imports and requires in the Elixir scope.
 #
+# The implementation simply stores dispatch information in an
+# ETS table and then consults this table once compilation is done.
+#
 # Note that since this is required for bootstrap, we can't use
 # any of the `GenServer.Behaviour` conveniences.
 defmodule Kernel.LexicalTracker do
@@ -8,18 +11,15 @@ defmodule Kernel.LexicalTracker do
   @timeout 30_000
   @behaviour :gen_server
 
-  @doc """
-  Returns all remotes referenced in this lexical scope.
-  """
-  def remote_references(arg) do
-    :gen_server.call(to_pid(arg), :remote_references, @timeout)
-  end
+  @import 2
+  @alias  3
 
   @doc """
-  Returns all remote dispatches in this lexical scope.
+  Returns all remotes linked to in this lexical scope.
   """
-  def remote_dispatches(arg) do
-    :gen_server.call(to_pid(arg), :remote_dispatches, @timeout)
+  def remotes(arg) do
+    ets = :gen_server.call(to_pid(arg), :ets, @timeout)
+    :ets.match(ets, {:"$1", :_, :_}) |> List.flatten
   end
 
   @doc """
@@ -51,8 +51,8 @@ defmodule Kernel.LexicalTracker do
   end
 
   @doc false
-  def add_import(pid, module, fas, line, warn) do
-    :gen_server.cast(pid, {:add_import, module, fas, line, warn})
+  def add_import(pid, module, line, warn) do
+    :gen_server.cast(pid, {:add_import, module, line, warn})
   end
 
   @doc false
@@ -61,18 +61,13 @@ defmodule Kernel.LexicalTracker do
   end
 
   @doc false
-  def remote_reference(pid, module, mode) do
-    :gen_server.cast(pid, {:remote_reference, module, mode})
+  def remote_dispatch(pid, module) do
+    :gen_server.cast(pid, {:remote_dispatch, module})
   end
 
   @doc false
-  def remote_dispatch(pid, module, fa, line, mode) do
-    :gen_server.cast(pid, {:remote_dispatch, module, fa, line, mode})
-  end
-
-  @doc false
-  def import_dispatch(pid, module, fa, line, mode) do
-    :gen_server.cast(pid, {:import_dispatch, module, fa, line, mode})
+  def import_dispatch(pid, module) do
+    :gen_server.cast(pid, {:import_dispatch, module})
   end
 
   @doc false
@@ -82,96 +77,79 @@ defmodule Kernel.LexicalTracker do
 
   @doc false
   def collect_unused_imports(pid) do
-    unused(pid, :import)
+    unused(pid, @import)
   end
 
   @doc false
   def collect_unused_aliases(pid) do
-    unused(pid, :alias)
+    unused(pid, @alias)
   end
 
-  defp unused(pid, tag) do
-    :gen_server.call(pid, {:unused, tag}, @timeout)
+  defp unused(pid, pos) do
+    ets = :gen_server.call(pid, :ets, @timeout)
+    :ets.foldl(fn
+      {module, _, _} = tuple, acc when is_integer(:erlang.element(pos, tuple)) ->
+        [{module, :erlang.element(pos, tuple)}|acc]
+      _, acc ->
+        acc
+    end, [], ets) |> Enum.sort
   end
 
   # Callbacks
 
   def init(dest) do
-    {:ok, %{directives: %{}, references: %{}, compile: %{},
-            runtime: %{}, dest: dest}}
+    {:ok, {:ets.new(:lexical, [:protected]), dest}}
   end
 
   @doc false
-  def handle_call({:unused, tag}, _from, state) do
-    directives =
-      for {{^tag, module_or_mfa}, marker} <- state.directives,
-          is_integer(marker),
-          do: {module_or_mfa, marker}
-
-    {:reply, Enum.sort(directives), state}
+  def handle_call(:ets, _from, {d, dest}) do
+    {:reply, d, {d, dest}}
   end
 
-  def handle_call(:remote_references, _from, state) do
-    {:reply, partition(Enum.to_list(state.references), [], []), state}
+  def handle_call(:dest, _from, {d, dest}) do
+    {:reply, dest, {d, dest}}
   end
 
-  def handle_call(:remote_dispatches, _from, state) do
-    {:reply, {state.compile, state.runtime}, state}
+  def handle_call(request, _from, {d, dest}) do
+    {:stop, {:bad_call, request}, {d, dest}}
   end
 
-  def handle_call(:dest, _from, state) do
-    {:reply, state.dest, state}
+  def handle_cast({:remote_dispatch, module}, {d, dest}) do
+    add_module(d, module)
+    {:noreply, {d, dest}}
   end
 
-  def handle_cast({:remote_reference, module, mode}, state) do
-    {:noreply, %{state | references: add_reference(state.references, module, mode)}}
+  def handle_cast({:import_dispatch, module}, {d, dest}) do
+    add_dispatch(d, module, @import)
+    {:noreply, {d, dest}}
   end
 
-  def handle_cast({:remote_dispatch, module, fa, line, mode}, state) do
-    references = add_reference(state.references, module, mode)
-    state = add_remote_dispatch(state, module, fa, line, mode)
-    {:noreply, %{state | references: references}}
+  def handle_cast({:alias_dispatch, module}, {d, dest}) do
+    add_dispatch(d, module, @alias)
+    {:noreply, {d, dest}}
   end
 
-  def handle_cast({:import_dispatch, module, {function, arity} = fa, line, mode}, state) do
-    state =
-      state
-      |> add_import_dispatch(module, function, arity)
-      |> add_remote_dispatch(module, fa, line, mode)
-
-    {:noreply, state}
+  def handle_cast({:add_import, module, line, warn}, {d, dest}) do
+    add_directive(d, module, line, warn, @import)
+    {:noreply, {d, dest}}
   end
 
-  def handle_cast({:alias_dispatch, module}, state) do
-    {:noreply, %{state | directives: add_dispatch(state.directives, module, :alias)}}
+  def handle_cast({:add_alias, module, line, warn}, {d, dest}) do
+    add_directive(d, module, line, warn, @alias)
+    {:noreply, {d, dest}}
   end
 
-  def handle_cast({:add_import, module, fas, line, warn}, state) when is_atom(module) do
-    directives =
-      state.directives
-      |> Enum.reject(&match?({{:import, {^module, _, _}}, _}, &1))
-      |> :maps.from_list
-      |> add_directive(module, line, warn, :import)
-
-    directives =
-      Enum.reduce(fas, directives, fn {function, arity}, directives ->
-        add_directive(directives, {module, function, arity}, line, warn, :import)
-      end)
-
-    {:noreply, %{state | directives: directives}}
+  def handle_cast(:stop, {d, dest}) do
+    {:stop, :normal, {d, dest}}
   end
 
-  def handle_cast({:add_alias, module, line, warn}, state) do
-    {:noreply, %{state | directives: add_directive(state.directives, module, line, warn, :alias)}}
-  end
-
-  def handle_cast(:stop, state) do
-    {:stop, :normal, state}
+  def handle_cast(msg, {d, dest}) do
+    {:stop, {:bad_cast, msg}, {d, dest}}
   end
 
   @doc false
-  def handle_info(_msg, state) do
-    {:noreply, state}
+  def handle_info(_msg, {d, dest}) do
+    {:noreply, {d, dest}}
   end
 
   @doc false
@@ -184,62 +162,23 @@ defmodule Kernel.LexicalTracker do
     {:ok, state}
   end
 
-  defp partition([{remote, :compile} | t], compile, runtime),
-    do: partition(t, [remote | compile], runtime)
-  defp partition([{remote, :runtime} | t], compile, runtime),
-    do: partition(t, compile, [remote | runtime])
-  defp partition([], compile, runtime),
-    do: {compile, runtime}
-
   # Callbacks helpers
 
-  defp add_reference(references, module, :runtime) when is_atom(module),
-    do: map_put_new(module, :runtime, references)
-  defp add_reference(references, module, :compile) when is_atom(module),
-    do: :maps.put(module, :compile, references)
-
-  defp add_remote_dispatch(state, module, fa, line, mode) when is_atom(module) do
-    map_update mode, %{module => %{fa => [line]}}, state, fn mode_dispatches ->
-      map_update module, %{fa => [line]}, mode_dispatches, fn module_dispatches ->
-        map_update fa, [line], module_dispatches, &[line | List.delete(&1, line)]
-      end
-    end
-  end
-
-  defp add_import_dispatch(state, module, function, arity) do
-    directives =
-      add_dispatch(state.directives, module, :import)
-      |> add_dispatch({module, function, arity}, :import)
-    # Always compile time because we depend
-    # on the module at compile time
-    references = add_reference(state.references, module, :compile)
-
-    %{state | directives: directives, references: references}
-  end
-
-  # In the map we keep imports and aliases.
+  # In the table we keep imports and aliases.
+  # If the value is false, it was not imported/aliased
+  # If the value is true, it was imported/aliased
   # If the value is a line, it was imported/aliased and has a pending warning
-  # If the value is true, it was imported/aliased and used
-  defp add_directive(directives, module_or_mfa, line, warn, tag) do
+  defp add_module(d, module) do
+    :ets.insert_new(d, {module, false, false})
+  end
+
+  defp add_dispatch(d, module, pos) do
+    :ets.update_element(d, module, {pos, true})
+  end
+
+  defp add_directive(d, module, line, warn, pos) do
+    add_module(d, module)
     marker = if warn, do: line, else: true
-    :maps.put({tag, module_or_mfa}, marker, directives)
-  end
-
-  defp add_dispatch(directives, module_or_mfa, tag) do
-    :maps.put({tag, module_or_mfa}, true, directives)
-  end
-
-  defp map_update(key, initial, map, fun) do
-    case :maps.find(key, map) do
-      {:ok, val} -> :maps.put(key, fun.(val), map)
-      :error -> :maps.put(key, initial, map)
-    end
-  end
-
-  defp map_put_new(key, value, map) do
-    case :maps.find(key, map) do
-      {:ok, _} -> map
-      :error -> :maps.put(key, value, map)
-    end
+    :ets.update_element(d, module, {pos, marker})
   end
 end

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -20,19 +20,12 @@ defmodule Kernel.ParallelCompiler do
     * `:each_file` - for each file compiled, invokes the callback passing the
       file
 
-    * `:each_long_compilation` - for each file that takes more than a given
-      timeout (see the `:long_compilation_threshold` option) to compile, invoke
-      this callback passing the file as its argument
-
-    * `:long_compilation_threshold` - the timeout (in seconds) after the
-      `:each_long_compilation` callback is invoked; defaults to `10`
-
     * `:each_module` - for each module compiled, invokes the callback passing
       the file, module and the module bytecode
 
     * `:dest` - the destination directory for the beam files. When using `files/2`,
       this information is only used to properly annotate the beam files before
-      they are loaded into memory. If you want a file to actually be written to
+      they are loaded into memory. If you want a file to actually be writen to
       `dest`, use `files_to_path/3` instead.
 
   Returns the modules generated by each compiled file.
@@ -59,134 +52,91 @@ defmodule Kernel.ParallelCompiler do
     :elixir_code_server.cast({:reset_warnings, compiler_pid})
     schedulers = max(:erlang.system_info(:schedulers_online), 2)
 
-    result = spawn_compilers(%{
-      entries: files,
-      original: files,
-      output: path,
-      options: options,
-      waiting: [],
-      queued: [],
-      schedulers: schedulers,
-      result: [],
-    })
+    result = spawn_compilers(files, files, path, options, [], [], schedulers, [])
 
     # In case --warning-as-errors is enabled and there was a warning,
-    # compilation status will be set to error.
+    # compilation status will be set to error and we fail with CompileError
     case :elixir_code_server.call({:compilation_status, compiler_pid}) do
-      :ok ->
-        result
-      :error ->
-        IO.puts :stderr, "Compilation failed due to warnings while using the --warnings-as-errors option"
-        exit({:shutdown, 1})
+      :ok    -> result
+      :error -> exit({:shutdown, 1})
     end
   end
 
-  # We already have n=schedulers currently running, don't spawn new ones
-  defp spawn_compilers(%{queued: queued, waiting: waiting, schedulers: schedulers} = state)
-      when length(queued) - length(waiting) >= schedulers do
-    wait_for_messages(state)
+  # We already have 4 currently running, don't spawn new ones
+  defp spawn_compilers(entries, original, output, options, waiting, queued, schedulers, result) when
+      length(queued) - length(waiting) >= schedulers do
+    wait_for_messages(entries, original, output, options, waiting, queued, schedulers, result)
   end
 
   # Release waiting processes
-  defp spawn_compilers(%{entries: [{ref, found} | t], waiting: waiting} = state) do
-    waiting =
-      case List.keytake(waiting, ref, 2) do
-        {{_kind, pid, ^ref, _on, _defining}, waiting} ->
-          send pid, {ref, found}
-          waiting
-        nil ->
-          waiting
-      end
-    spawn_compilers(%{state | entries: t, waiting: waiting})
+  defp spawn_compilers([h|t], original, output, options, waiting, queued, schedulers, result) when is_pid(h) do
+    {_kind, ^h, ref, _module} = List.keyfind(waiting, h, 1)
+    send h, {ref, :ready}
+    waiting = List.keydelete(waiting, h, 1)
+    spawn_compilers(t, original, output, options, waiting, queued, schedulers, result)
   end
 
-  defp spawn_compilers(%{entries: [file | files], queued: queued, output: output, options: options} = state) do
+  # Spawn a compiler for each file in the list until we reach the limit
+  defp spawn_compilers([h|t], original, output, options, waiting, queued, schedulers, result) do
     parent = self()
 
     {pid, ref} =
       :erlang.spawn_monitor fn ->
+        # Notify Code.ensure_compiled/2 that we should
+        # attempt to compile the module by doing a dispatch.
+        :erlang.put(:elixir_ensure_compiled, true)
+
         # Set the elixir_compiler_pid used by our custom Kernel.ErrorHandler.
         :erlang.put(:elixir_compiler_pid, parent)
         :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
 
         exit(try do
           _ = if output do
-            :elixir_compiler.file_to_path(file, output)
+            :elixir_compiler.file_to_path(h, output)
           else
-            :elixir_compiler.file(file, Keyword.get(options, :dest))
+            :elixir_compiler.file(h, Keyword.get(options, :dest))
           end
-          {:shutdown, file}
+          {:compiled, h}
         catch
           kind, reason ->
             {:failure, kind, reason, System.stacktrace}
         end)
       end
 
-    timeout = Keyword.get(options, :long_compilation_threshold, 10) * 1_000
-    timer_ref = Process.send_after(self(), {:timed_out, pid}, timeout)
-
-    new_queued = [{pid, ref, file, timer_ref} | queued]
-    spawn_compilers(%{state | entries: files, queued: new_queued})
+    spawn_compilers(t, original, output, options, waiting,
+                    [{pid, ref, h}|queued], schedulers, result)
   end
 
   # No more files, nothing waiting, queue is empty, we are done
-  defp spawn_compilers(%{entries: [], waiting: [], queued: [], result: result}) do
+  defp spawn_compilers([], _original, _output, _options, [], [], _schedulers, result) do
     for {:module, mod} <- result, do: mod
   end
 
   # Queued x, waiting for x: POSSIBLE ERROR! Release processes so we get the failures
-  defp spawn_compilers(%{entries: [], waiting: waiting, queued: queued} = state) when length(waiting) == length(queued) do
-    entries = for {pid, _, _, _} <- queued,
-                  entry = waiting_on_without_definition(waiting, pid),
-                  {_, _, ref, on, _} = entry,
-                  do: {on, {ref, :not_found}}
-
-    # Instead of releasing all files at once, we release them in groups
-    # based on the module they are waiting on. We pick the module being
-    # depended on with less edges, as it is the mostly likely source of
-    # error (for example, someone made a type). This may not always be
-    # true though: for example, if there is a macro injecting code into
-    # multiple modules and such code becomes faulty, now multiple modules
-    # are waiting on the same module required by the faulty code. However,
-    # since we need to pick something to be first, the one with fewer edges
-    # sounds like a sane choice.
-    entries =
-      entries
-      |> Enum.group_by(&elem(&1, 0), &elem(&1, 1))
-      |> Enum.sort_by(&length(elem(&1, 1)))
-      |> Enum.find_value([], &elem(&1, 1))
-
-    case entries do
-      [] -> handle_deadlock(waiting, queued)
-      _  -> spawn_compilers(%{state | entries: entries})
+  defp spawn_compilers([], original, output, options, waiting, queued, schedulers, result) when length(waiting) == length(queued) do
+    Enum.each queued, fn {child, _, _} ->
+      {_kind, ^child, ref, _module} = List.keyfind(waiting, child, 1)
+      send child, {ref, :release}
     end
+    wait_for_messages([], original, output, options, waiting, queued, schedulers, result)
   end
 
   # No more files, but queue and waiting are not full or do not match
-  defp spawn_compilers(%{entries: []} = state) do
-    wait_for_messages(state)
-  end
-
-  defp waiting_on_without_definition(waiting, pid) do
-    {_, ^pid, _, on, _} = entry = List.keyfind(waiting, pid, 1)
-    if Enum.any?(waiting, fn {_, _, _, _, defining} -> on in defining end) do
-      nil
-    else
-      entry
-    end
+  defp spawn_compilers([], original, output, options, waiting, queued, schedulers, result) do
+    wait_for_messages([], original, output, options, waiting, queued, schedulers, result)
   end
 
   # Wait for messages from child processes
-  defp wait_for_messages(state) do
-    %{entries: entries, options: options, waiting: waiting, queued: queued, result: result} = state
-
+  defp wait_for_messages(entries, original, output, options, waiting, queued, schedulers, result) do
     receive do
       {:struct_available, module} ->
-        available = for {:struct, _, ref, waiting_module, _defining} <- waiting,
+        available = for {:struct, pid, _, waiting_module} <- waiting,
                         module == waiting_module,
-                        do: {ref, :found}
+                        not pid in entries,
+                        do: pid
 
-        spawn_compilers(%{state | entries: available ++ entries, result: [{:struct, module} | result]})
+        spawn_compilers(available ++ entries, original, output, options,
+                        waiting, queued, schedulers, [{:struct, module}|result])
 
       {:module_available, child, ref, file, module, binary} ->
         if callback = Keyword.get(options, :each_module) do
@@ -196,94 +146,49 @@ defmodule Kernel.ParallelCompiler do
         # Release the module loader which is waiting for an ack
         send child, {ref, :ack}
 
-        available = for {:module, _, ref, waiting_module, _defining} <- waiting,
+        available = for {_kind, pid, _, waiting_module} <- waiting,
                         module == waiting_module,
-                        do: {ref, :found}
+                        not pid in entries,
+                        do: pid
 
-        cancel_waiting_timer(queued, child)
+        spawn_compilers(available ++ entries, original, output, options,
+                        waiting, queued, schedulers, [{:module, module}|result])
 
-        spawn_compilers(%{state | entries: available ++ entries, result: [{:module, module} | result]})
+      {:waiting, kind, child, ref, on} ->
+        defined = fn {k, m} -> on == m and k in [kind, :module] end
 
-      {:waiting, kind, child, ref, on, defining} ->
         # Oops, we already got it, do not put it on waiting.
-        waiting =
-          if :lists.any(&match?({^kind, ^on}, &1), result) do
-            send child, {ref, :found}
-            waiting
-          else
-            [{kind, child, ref, on, defining} | waiting]
-          end
-
-        spawn_compilers(%{state | waiting: waiting})
-
-      {:timed_out, child} ->
-        callback = Keyword.get(options, :each_long_compilation)
-        case List.keyfind(queued, child, 0) do
-          {^child, _, file, _} when not is_nil(callback) ->
-            callback.(file)
-          _ ->
-            :ok
+        if :lists.any(defined, result) do
+          send child, {ref, :ready}
+        else
+          waiting = [{kind, child, ref, on}|waiting]
         end
-        spawn_compilers(state)
 
-      {:DOWN, _down_ref, :process, down_pid, {:shutdown, file}} ->
+        spawn_compilers(entries, original, output, options, waiting, queued, schedulers, result)
+
+      {:DOWN, _down_ref, :process, down_pid, {:compiled, file}} ->
         if callback = Keyword.get(options, :each_file) do
           callback.(file)
         end
 
-        cancel_waiting_timer(queued, down_pid)
-
         # Sometimes we may have spurious entries in the waiting
         # list because someone invoked try/rescue UndefinedFunctionError
         new_entries = List.delete(entries, down_pid)
         new_queued  = List.keydelete(queued, down_pid, 0)
         new_waiting = List.keydelete(waiting, down_pid, 1)
-        spawn_compilers(%{state | entries: new_entries, waiting: new_waiting, queued: new_queued})
+        spawn_compilers(new_entries, original, output, options, new_waiting, new_queued, schedulers, result)
 
       {:DOWN, down_ref, :process, _down_pid, reason} ->
-        handle_failure(down_ref, reason, queued)
-        wait_for_messages(state)
+        handle_failure(down_ref, reason, entries, waiting, queued)
+        wait_for_messages(entries, original, output, options, waiting, queued, schedulers, result)
     end
   end
 
-  defp handle_deadlock(waiting, queued) do
-    deadlock =
-      for {pid, _, file, _} <- queued do
-        {:current_stacktrace, stacktrace} = Process.info(pid, :current_stacktrace)
-        Process.exit(pid, :kill)
-
-        {_kind, ^pid, _, on, _} = List.keyfind(waiting, pid, 1)
-        error = CompileError.exception(description: "deadlocked waiting on module #{inspect on}",
-                                       file: nil, line: nil)
-        print_failure(file, {:failure, :error, error, stacktrace})
-
-        {file, on}
-      end
-
-    IO.puts """
-
-    Compilation failed because of a deadlock between files.
-    The following files depended on the following modules:
-    """
-
-    max =
-      deadlock
-      |> Enum.map(& &1 |> elem(0) |> String.length)
-      |> Enum.max
-
-    for {file, mod} <- deadlock do
-      IO.puts ["  ", String.pad_leading(file, max), " => " | inspect(mod)]
-    end
-
-    IO.puts ""
-    exit({:shutdown, 1})
-  end
-
-  defp handle_failure(ref, reason, queued) do
+  defp handle_failure(ref, reason, entries, waiting, queued) do
     if file = find_failure(ref, queued) do
       print_failure(file, reason)
-      for {pid, _, _, _} <- queued do
-        Process.exit(pid, :kill)
+      if all_missing?(entries, waiting, queued) do
+        collect_failures(queued, length(queued) - 1)
       end
       exit({:shutdown, 1})
     end
@@ -291,12 +196,12 @@ defmodule Kernel.ParallelCompiler do
 
   defp find_failure(ref, queued) do
     case List.keyfind(queued, ref, 1) do
-      {_child, ^ref, file, _timer_ref} -> file
+      {_child, ^ref, file} -> file
       _ -> nil
     end
   end
 
-  defp print_failure(_file, {:shutdown, _}) do
+  defp print_failure(_file, {:compiled, _}) do
     :ok
   end
 
@@ -310,35 +215,40 @@ defmodule Kernel.ParallelCompiler do
     IO.puts Exception.format(:exit, reason, [])
   end
 
-  @elixir_internals [:elixir, :elixir_exp, :elixir_compiler, :elixir_module, :elixir_clauses,
-                     :elixir_translator, :elixir_expand, :elixir_lexical, :elixir_exp_clauses,
-                     :elixir_def, :elixir_map, Kernel.ErrorHandler]
+  @elixir_internals [:elixir, :elixir_exp, :elixir_compiler, :elixir_module, :elixir_translator,
+                     :elixir_expand, :elixir_lexical]
 
-  defp prune_stacktrace([{mod, _, _, _} | t]) when mod in @elixir_internals do
+  defp prune_stacktrace([{mod, _, _, _}|t]) when mod in @elixir_internals do
     prune_stacktrace(t)
   end
 
-  defp prune_stacktrace([h | t]) do
-    [h | prune_stacktrace(t)]
+  defp prune_stacktrace([h|t]) do
+    [h|prune_stacktrace(t)]
   end
 
   defp prune_stacktrace([]) do
     []
   end
 
-  defp cancel_waiting_timer(queued, child_pid) do
-    case List.keyfind(queued, child_pid, 0) do
-      {^child_pid, _ref, _file, timer_ref} ->
-        Process.cancel_timer(timer_ref)
-        # Let's flush the message in case it arrived before we canceled the
-        # timeout.
-        receive do
-          {:timed_out, ^child_pid} -> :ok
-        after
-          0 -> :ok
+  defp all_missing?(entries, waiting, queued) do
+    entries == [] and waiting != [] and
+      length(waiting) == length(queued)
+  end
+
+  defp collect_failures(_queued, 0), do: :ok
+
+  defp collect_failures(queued, remaining) do
+    receive do
+      {:DOWN, down_ref, :process, _down_pid, reason} ->
+        if file = find_failure(down_ref, queued) do
+          print_failure(file, reason)
+          collect_failures(queued, remaining - 1)
+        else
+          collect_failures(queued, remaining)
         end
-      nil ->
-        :ok
+    after
+      # Give up if no failure appears in 5 seconds
+      5000 -> :ok
     end
   end
 end

lib/elixir/lib/kernel/parallel_require.ex

@@ -3,54 +3,48 @@ defmodule Kernel.ParallelRequire do
   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 will be invoked with each file, or a keyword list of `callbacks` can be provided:
-
-    * `:each_file` - invoked with each file
-
-    * `:each_module` - invoked with file, module name, and binary code
+  A callback that is invoked every time a file is required
+  can be optionally given as argument.
 
   Returns the modules generated by each required file.
   """
-  def files(files, callbacks \\ [])
-
-  def files(files, callback) when is_function(callback, 1) do
-    files(files, [each_file: callback])
-  end
-
-  def files(files, callbacks) when is_list(callbacks) do
-    compiler_pid = self()
-    :elixir_code_server.cast({:reset_warnings, compiler_pid})
+  def files(files, callback \\ default_callback) do
     schedulers = max(:erlang.system_info(:schedulers_online), 2)
-    result = spawn_requires(files, [], callbacks, schedulers, [])
-
-    # In case --warning-as-errors is enabled and there was a warning,
-    # compilation status will be set to error.
-    case :elixir_code_server.call({:compilation_status, compiler_pid}) do
-      :ok ->
-        result
-      :error ->
-        IO.puts :stderr, "\nExecution failed due to warnings while using the --warnings-as-errors option"
-        exit({:shutdown, 1})
-    end
+    spawn_requires(files, [], callback, schedulers, [])
   end
 
-  defp spawn_requires([], [], _callbacks, _schedulers, result), do: result
+  defp spawn_requires([], [], _callback, _schedulers, result), do: result
 
-  defp spawn_requires([], waiting, callbacks, schedulers, result) do
-    wait_for_messages([], waiting, callbacks, schedulers, result)
+  defp spawn_requires([], waiting, callback, schedulers, result) do
+    wait_for_messages([], waiting, callback, schedulers, result)
   end
 
-  defp spawn_requires(files, waiting, callbacks, schedulers, result) when length(waiting) >= schedulers do
-    wait_for_messages(files, waiting, callbacks, schedulers, result)
+  defp spawn_requires(files, waiting, callback, schedulers, result) when length(waiting) >= schedulers do
+    wait_for_messages(files, waiting, callback, schedulers, result)
   end
 
-  defp spawn_requires([h | t], waiting, callbacks, schedulers, result) do
-    parent = self()
+  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)
+
     {pid, ref} = :erlang.spawn_monitor fn ->
-      :erlang.put(:elixir_compiler_pid, parent)
+      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)
 
       exit(try do
         new = Code.require_file(h) || []
@@ -61,48 +55,26 @@ defmodule Kernel.ParallelRequire do
       end)
     end
 
-    spawn_requires(t, [{pid, ref} | waiting], callbacks, schedulers, result)
+    spawn_requires(t, [{pid, ref}|waiting], callback, schedulers, result)
   end
 
-  defp wait_for_messages(files, waiting, callbacks, schedulers, result) do
+  defp wait_for_messages(files, waiting, callback, schedulers, result) do
     receive do
       {:DOWN, ref, :process, pid, status} ->
         tuple = {pid, ref}
         if tuple in waiting do
-          waiting = List.delete(waiting, tuple)
-
           case status do
             {:required, mods, file} ->
-              if each_file_callback = callbacks[:each_file] do
-                each_file_callback.(file)
-              end
-
-              spawn_requires(files, waiting, callbacks, schedulers, mods ++ result)
-
+              callback.(file)
+              result  = mods ++ result
+              waiting = List.delete(waiting, tuple)
             {:failure, kind, reason, stacktrace} ->
               :erlang.raise(kind, reason, stacktrace)
-
             other ->
               :erlang.raise(:exit, other, [])
           end
-        else
-          spawn_requires(files, waiting, callbacks, schedulers, result)
         end
-
-      {:module_available, child, ref, file, module, binary} ->
-        if each_module_callback = callbacks[:each_module] do
-          each_module_callback.(file, module, binary)
-        end
-
-        send(child, {ref, :ack})
-        spawn_requires(files, waiting, callbacks, schedulers, result)
-
-      {:struct_available, _} ->
-        spawn_requires(files, waiting, callbacks, schedulers, result)
-
-      {:waiting, _, child, ref, _, _} ->
-        send(child, {ref, :not_found})
-        spawn_requires(files, waiting, callbacks, schedulers, result)
+        spawn_requires(files, waiting, callback, schedulers, result)
     end
   end
 end

lib/elixir/lib/kernel/typespec.ex

@@ -1,5 +1,211 @@
 defmodule Kernel.Typespec do
-  @moduledoc false
+  @moduledoc ~S"""
+  Provides macros and functions for working with typespecs.
+
+  Elixir comes with a notation for declaring types and specifications. Elixir is
+  dynamically typed, as such typespecs are never used by the compiler to
+  optimize or modify code. Still, using typespecs is useful as documentation and
+  tools such as [Dialyzer](http://www.erlang.org/doc/man/dialyzer.html) can
+  analyze the code with typespecs to find bugs.
+
+  The attributes `@type`, `@opaque`, `@typep`, `@spec` and `@callback` available
+  in modules are handled by the equivalent macros defined by this module. See
+  sub-sections "Defining a type" and "Defining a specification" below.
+
+  ## Types and their syntax
+
+  The type syntax provided by Elixir is fairly similar to the one in
+  [Erlang](http://www.erlang.org/doc/reference_manual/typespec.html).
+
+  Most of the built-in types provided in Erlang (for example, `pid()`) are
+  expressed the same way: `pid()` or simply `pid`. Parametrized types are also
+  supported (`list(integer)`) and so are remote types (`Enum.t`).
+
+  Integers and atom literals are allowed as types (ex. `1`, `:atom` or
+  `false`). All other types are built of unions of predefined types. Certain
+  shorthands are allowed, such as `[...]`, `<<>>` and `{...}`.
+
+  ### Predefined types
+
+      Type :: any         # the top type, the set of all terms
+            | none        # the bottom type, contains no terms
+            | pid
+            | port
+            | reference
+            | Atom
+            | Bitstring
+            | float
+            | Fun
+            | Integer
+            | List
+            | Map
+            | Tuple
+            | Union
+            | UserDefined # Described in section "Defining a type"
+
+      Atom :: atom
+            | ElixirAtom # `:foo`, `:bar`, ...
+
+      Bitstring :: <<>>
+                 | << _ :: M >>             # M is a positive integer
+                 | << _ :: _ * N >>         # N is a positive integer
+                 | << _ :: M, _ :: _ * N >>
+
+      Fun :: (... -> any)    # any function
+           | (... -> Type)   # any arity, returning Type
+           | (() -> Type))
+           | (TList -> Type)
+
+      Integer :: integer
+               | ElixirInteger                # ..., -1, 0, 1, ... 42 ...
+               | ElixirInteger..ElixirInteger # an integer range
+
+      List :: list(Type)                        # proper list ([]-terminated)
+            | improper_list(Type1, Type2)       # Type1=contents, Type2=termination
+            | maybe_improper_list(Type1, Type2) # Type1 and Type2 as above
+            | nonempty_list(Type)               # proper non-empty list
+            | []                                # empty list
+            | [Type]                            # shorthand for list(Type)
+            | [...]                             # shorthand for nonempty_list()
+            | [Type, ...]                       # shorthand for nonempty_list(Type)
+            | [Keyword]
+
+      Map :: map()            # map of any size
+           | %{}              # map of any size
+           | %Struct{}        # struct (see defstruct/1)
+           | %Struct{Keyword}
+           | %{Keyword}
+           | %{Pairs}
+
+      Tuple :: tuple                 # a tuple of any size
+             | {}                    # empty tuple
+             | {TList}
+             | record(Atom)          # record (see Record)
+             | record(Atom, Keyword)
+
+      Keyword :: ElixirAtom: Type
+               | ElixirAtom: Type, Keyword
+
+      Pairs :: Type => Type
+             | Type => Type, Pairs
+
+      TList :: Type
+             | Type, TList
+
+      Union :: Type | Type
+
+  ### 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:
+
+      ((...) -> any)
+      (... -> any)
+
+  Anonymous function with arity of zero:
+
+      (() -> type)
+
+  Anonymous function with some arity:
+
+      ((type, type) -> type)
+      (type, type -> type)
+
+  ## Built-in types
+
+  Built-in type         | Defined as
+  :-------------------- | :---------
+  `term`                | `any`
+  `binary`              | `<< _ :: _ * 8 >>`
+  `bitstring`           | `<< _ :: _ * 1 >>`
+  `boolean`             | `false` \| `true`
+  `byte`                | `0..255`
+  `char`                | `0..0x10ffff`
+  `number`              | `integer` \| `float`
+  `char_list`           | `[char]`
+  `list`                | `[any]`
+  `maybe_improper_list` | `maybe_improper_list(any, any)`
+  `nonempty_list`       | `nonempty_list(any)`
+  `iodata`              | `iolist` \| `binary`
+  `iolist`              | `maybe_improper_list(byte` \| `binary` \| `iolist, binary` \| `[])`
+  `module`              | `atom` \| `tuple`
+  `mfa`                 | `{atom, atom, arity}`
+  `arity`               | `0..255`
+  `node`                | `atom`
+  `timeout`             | `:infinity` \| `non_neg_integer`
+  `no_return`           | `none`
+  `fun`                 | `(... -> any)`
+
+
+  Some built-in types cannot be expressed with valid syntax according to the
+  language defined above.
+
+  Built-in type     | Can be interpreted as
+  :---------------- | :--------------------
+  `non_neg_integer` | `0..`
+  `pos_integer`     | `1..`
+  `neg_integer`     | `..-1`
+
+  Types defined in other modules are referred to as "remote types", they are
+  referenced as `Module.type_name` (ex. `Enum.t` or `String.t`).
+
+  ## Defining a type
+
+      @type type_name :: type
+      @typep type_name :: type
+      @opaque type_name :: type
+
+  A type defined with `@typep` is private. An opaque type, defined with
+  `@opaque` is a type where the internal structure of the type will not be
+  visible, but the type is still public.
+
+  Types can be parametrised by defining variables as parameters, these variables
+  can then be used to define the type.
+
+      @type dict(key, value) :: [{key, value}]
+
+  ## Defining a specification
+
+      @spec function_name(type1, type2) :: return_type
+      @callback function_name(type1, type2) :: return_type
+
+  Callbacks are used to define the callbacks functions of behaviours (see
+  `Behaviour`).
+
+  Guards can be used to restrict type variables given as arguments to the
+  function.
+
+      @spec function(arg) :: [arg] when arg: atom
+
+  Type variables with no restriction can also be defined.
+
+      @spec function(arg) :: [arg] when arg: var
+
+  Specifications can be overloaded just like ordinary functions.
+
+      @spec function(integer) :: atom
+      @spec function(atom)    :: integer
+
+  ## Notes
+
+  Elixir discourages the use of type `string` as it might be confused with
+  binaries which are referred to as "strings" in Elixir (as opposed to character
+  lists). In order to use the type that is called `string` in Erlang, one has to
+  use the `char_list` type which is a synonym for `string`. If you use `string`,
+  you'll get a warning from the compiler.
+
+  If you want to refer to the "string" type (the one operated on by functions in
+  the `String` module), use `String.t` type instead.
+  """
 
   @doc """
   Defines a type.
@@ -76,28 +282,6 @@ defmodule Kernel.Typespec do
     end
   end
 
-
-  @doc """
-  Defines a macro callback.
-  This macro is responsible for handling the attribute `@macrocallback`.
-
-  ## Examples
-
-      @macrocallback add(number, number) :: Macro.t
-
-  """
-  defmacro defmacrocallback(spec) do
-    quote do
-      Kernel.Typespec.defspec(:macrocallback, unquote(Macro.escape(spec, unquote: true)), __ENV__)
-    end
-  end
-
-  defmacro defoptional_callbacks(callbacks) do
-    quote do
-      Module.store_typespec(__ENV__.module, :optional_callbacks, {__ENV__.line, unquote(callbacks)})
-    end
-  end
-
   @doc """
   Defines a `type`, `typep` or `opaque` by receiving a typespec expression.
   """
@@ -109,7 +293,7 @@ defmodule Kernel.Typespec do
   Defines a `spec` by receiving a typespec expression.
   """
   def define_spec(kind, expr, env) do
-    defspec(kind, expr, env)
+    Module.store_typespec(env.module, kind, {kind, expr, env})
   end
 
   @doc """
@@ -118,9 +302,10 @@ defmodule Kernel.Typespec do
   for modules being compiled.
   """
   def defines_type?(module, name, arity) do
-    finder = fn {_kind, expr, _caller} ->
+    finder = fn {_kind, expr, _doc, _caller} ->
       type_to_signature(expr) == {name, arity}
     end
+
     :lists.any(finder, Module.get_attribute(module, :type)) or
     :lists.any(finder, Module.get_attribute(module, :opaque))
   end
@@ -150,7 +335,6 @@ defmodule Kernel.Typespec do
   @doc """
   Converts a spec clause back to Elixir AST.
   """
-  def spec_to_ast(name, spec)
   def spec_to_ast(name, {:type, line, :fun, [{:type, _, :product, args}, result]}) do
     meta = [line: line]
     body = {name, meta, Enum.map(args, &typespec_to_ast/1)}
@@ -198,11 +382,10 @@ defmodule Kernel.Typespec do
   @doc """
   Converts a type clause back to Elixir AST.
   """
-  def type_to_ast(type)
   def type_to_ast({{:record, record}, fields, args}) when is_atom(record) do
     fields = for field <- fields, do: typespec_to_ast(field)
     args = for arg <- args, do: typespec_to_ast(arg)
-    type = {:{}, [], [record | fields]}
+    type = {:{}, [], [record|fields]}
     quote do: unquote(record)(unquote_splicing(args)) :: unquote(type)
   end
 
@@ -211,13 +394,23 @@ defmodule Kernel.Typespec do
     quote do: unquote(name)(unquote_splicing(args)) :: unquote(typespec_to_ast(type))
   end
 
-  @doc false
-  # TODO: Remove on v2.0
+  @doc """
+  Returns all type docs available from the module's beam code.
+
+  The result is returned as a list of tuples where the first element is the pair of type
+  name and arity and the second element is the documentation.
+
+  The module must have a corresponding beam file which can be
+  located by the runtime system.
+  """
+  @spec beam_typedocs(module | binary) :: [tuple] | nil
   def beam_typedocs(module) when is_atom(module) or is_binary(module) do
-    IO.write :stderr, "Kernel.Typespec.beam_typedocs/1 is deprecated, please use Code.get_docs/2 instead\n" <>
-                      Exception.format_stacktrace
-    if docs = Code.get_docs(module, :type_docs) do
-      for {tuple, _, _, doc} <- docs, do: {tuple, doc}
+    case abstract_code(module) do
+      {:ok, abstract_code} ->
+        type_docs = for {:attribute, _, :typedoc, tup} <- abstract_code, do: tup
+        :lists.flatten(type_docs)
+      _ ->
+        nil
     end
   end
 
@@ -319,66 +512,27 @@ defmodule Kernel.Typespec do
     do: {name, 0}
   def type_to_signature({:::, _, [{name, _, args}, _]}) when is_atom(name),
     do: {name, length(args)}
-  def type_to_signature(_),
-    do: :error
 
   ## Macro callbacks
 
-  @doc false
-  def defspec(kind, expr, caller) when kind in [:callback, :macrocallback] do
-    case spec_to_signature(expr) do
-      {name, arity} ->
-        store_callbackdoc(caller, caller.module, kind, name, arity)
-      :error ->
-        :error
-    end
-    Module.store_typespec(caller.module, kind, {kind, expr, caller})
-  end
-
   @doc false
   def defspec(kind, expr, caller) do
     Module.store_typespec(caller.module, kind, {kind, expr, caller})
   end
 
-  defp store_callbackdoc(caller, module, kind, name, arity) do
-    table = :elixir_module.data_table(module)
-    {line, doc} = get_doc_info(table, :doc, caller)
-    :ets.insert(table, {{:callbackdoc, {name, arity}}, line, kind, doc})
-  end
-
-  defp get_doc_info(table, attr, caller) do
-    case :ets.take(table, attr) do
-      [{^attr, {line, doc}}] -> {line, doc}
-      [] -> {caller.line, nil}
-    end
-  end
-
   @doc false
   def deftype(kind, expr, caller) do
     module = caller.module
-    case type_to_signature(expr) do
-      {name, arity} -> store_typedoc(caller, caller.module, kind, name, arity)
-      :error -> :error
-    end
-    Module.store_typespec(module, kind, {kind, expr, caller})
-  end
+    doc    = Module.get_attribute(module, :typedoc)
 
-  defp store_typedoc(caller, module, kind, name, arity) do
-    table = :elixir_module.data_table(module)
-    {line, doc} = get_doc_info(table, :typedoc, caller)
-
-    if kind == :typep && doc do
-      :elixir_errors.warn(caller.line, caller.file, "type #{name}/#{arity} is private, " <>
-                          "@typedoc's are always discarded for private types")
-    end
-
-    :ets.insert(table, {{:typedoc, {name, arity}}, line, kind, doc})
+    Module.delete_attribute(module, :typedoc)
+    Module.store_typespec(module, kind, {kind, expr, doc, caller})
   end
 
   ## Translation from Elixir AST to typespec AST
 
   @doc false
-  def translate_type(kind, {:::, _, [{name, _, args}, definition]}, caller) when is_atom(name) and name != ::: do
+  def translate_type(kind, {:::, _, [{name, _, args}, definition]}, doc, caller) when is_atom(name) and name != ::: do
     args =
       if is_atom(args) do
         []
@@ -386,11 +540,12 @@ defmodule Kernel.Typespec do
         for(arg <- args, do: variable(arg))
       end
 
-    vars  = for {:var, _, var} <- args, do: var
-    spec  = typespec(definition, vars, caller)
-    vars  = for {:var, _, _} = var <- args, do: var
-    type  = {name, spec, vars}
-    arity = length(vars)
+    vars   = for {:var, _, var} <- args, do: var
+    spec   = typespec(definition, vars, caller)
+
+    vars   = for {:var, _, _} = var <- args, do: var
+    type   = {name, spec, vars}
+    arity  = length(vars)
 
     {kind, export} =
       case kind do
@@ -399,28 +554,19 @@ defmodule Kernel.Typespec do
         :opaque -> {:opaque, true}
       end
 
-    if elixir_builtin_type?(name, arity) do
-      :elixir_errors.handle_file_error(caller.file,
-        {caller.line, :erl_lint, {:builtin_type, {name, arity}}})
+    if not export and doc do
+      :elixir_errors.warn(caller.line, caller.file, "type #{name}/#{arity} is private, " <>
+                          "@typedoc's are always discarded for private types")
     end
 
-    {{kind, {name, arity}, type}, caller.line, export}
+    {{kind, {name, arity}, type}, caller.line, export, doc}
   end
 
-  def translate_type(_kind, other, caller) do
+  def translate_type(_kind, other, _doc, caller) do
     type_spec = Macro.to_string(other)
     compile_error caller, "invalid type specification: #{type_spec}"
   end
 
-  defp elixir_builtin_type?(:as_boolean, 1), do: true
-  defp elixir_builtin_type?(:struct, 0), do: true
-  defp elixir_builtin_type?(:charlist, 0), do: true
-  # TODO: Deprecate char_list type by v1.5
-  defp elixir_builtin_type?(:char_list, 0), do: true
-  defp elixir_builtin_type?(:keyword, 0), do: true
-  defp elixir_builtin_type?(:keyword, 1), do: true
-  defp elixir_builtin_type?(_, _), do: false
-
   @doc false
   def translate_spec(kind, {:when, _meta, [spec, guard]}, caller) do
     translate_spec(kind, spec, guard, caller)
@@ -430,68 +576,31 @@ defmodule Kernel.Typespec do
     translate_spec(kind, spec, [], caller)
   end
 
-  defp translate_spec(kind, {:::, meta, [{name, _, args}, return]}, guard, caller)
-      when is_atom(name) and name != ::: do
-    translate_spec(kind, meta, name, args, return, guard, caller)
-  end
-
-  defp translate_spec(_kind, {name, _meta, _args} = spec, _guard, caller) when is_atom(name) and name != ::: do
-    spec = Macro.to_string(spec)
-    compile_error caller, "type specification missing return type: #{spec}"
-  end
-
-  defp translate_spec(_kind, spec, _guard, caller) do
-    spec = Macro.to_string(spec)
-    compile_error caller, "invalid type specification: #{spec}"
-  end
-
-  defp translate_spec(kind, meta, name, args, return, guard, caller) when is_atom(args),
-    do: translate_spec(kind, meta, name, [], return, guard, caller)
-  defp translate_spec(:macrocallback, meta, name, args, return, guard, caller),
-    do: translate_spec(:callback, meta, :"MACRO-#{name}", macro_args(args), return, guard, caller)
-  defp translate_spec(kind, meta, name, args, return, guard, caller) do
-    ensure_no_defaults!(args)
+  defp translate_spec(kind, {:::, meta, [{name, _, args}, return]}, guard, caller) when is_atom(name) and name != ::: do
+    if is_atom(args), do: args = []
 
     unless Keyword.keyword?(guard) do
-      compile_error caller, "expected keywords as guard in type specification, " <>
-                            "got: #{Macro.to_string(guard)}"
+      guard = Macro.to_string(guard)
+      compile_error caller, "expected keywords as guard in function type specification, got: #{guard}"
     end
 
     vars = Keyword.keys(guard)
-    spec = {:type, line(meta), :fun, fn_args(meta, args, return, vars, caller)}
+    constraints = guard_to_constraints(guard, vars, meta, caller)
 
-    spec =
-      case guard_to_constraints(guard, vars, meta, caller) do
-        [] -> spec
-        constraints -> {:type, line(meta), :bounded_fun, [spec, constraints]}
-      end
+    spec = {:type, line(meta), :fun, fn_args(meta, args, return, vars, caller)}
+    if constraints != [] do
+      spec = {:type, line(meta), :bounded_fun, [spec, constraints]}
+    end
 
     arity = length(args)
     {{kind, {name, arity}, spec}, caller.line}
   end
 
-  defp macro_args(args) do
-    [quote(do: {line :: Macro.Env.line, env :: Macro.Env.t}) | args]
+  defp translate_spec(_kind, spec, _guard, caller) do
+    spec = Macro.to_string(spec)
+    compile_error caller, "invalid function type specification: #{spec}"
   end
 
-  defp ensure_no_defaults!(args) do
-    :lists.foreach fn
-      {:::, _, [left, right]} ->
-        ensure_not_default(left)
-        ensure_not_default(right)
-        left
-      other ->
-        ensure_not_default(other)
-        other
-    end, args
-  end
-
-  defp ensure_not_default({:\\, _, [_, _]}) do
-    raise ArgumentError, "default arguments \\\\ not supported in type spec"
-  end
-
-  defp ensure_not_default(_), do: :ok
-
   defp guard_to_constraints(guard, vars, meta, caller) do
     line = line(meta)
 
@@ -501,7 +610,7 @@ defmodule Kernel.Typespec do
       {name, type}, acc ->
         constraint = [{:atom, line, :is_subtype}, [{:var, line, name}, typespec(type, vars, caller)]]
         type = {:type, line, :constraint, constraint}
-        [type | acc]
+        [type|acc]
     end, [], guard) |> :lists.reverse
   end
 
@@ -535,10 +644,6 @@ defmodule Kernel.Typespec do
     []
   end
 
-  defp typespec_to_ast({:user_type, line, name, args}) do
-    typespec_to_ast({:type, line, name, args})
-  end
-
   defp typespec_to_ast({:type, line, :tuple, :any}) do
     {:tuple, [line: line], []}
   end
@@ -571,20 +676,9 @@ defmodule Kernel.Typespec do
     [typespec_to_ast(arg), {:..., [line: line], nil}]
   end
 
-  defp typespec_to_ast({:type, line, :map, :any}) do
-    {:map, [line: line], []}
-  end
-
   defp typespec_to_ast({:type, line, :map, fields}) do
-    fields = Enum.map fields, fn
-      {:type, _, :map_field_assoc, :any} ->
-        {:..., [line: line], nil}
-      {:type, _, :map_field_exact, [{:atom, _, k}, v]} ->
-        {k, typespec_to_ast(v)}
-      {:type, _, :map_field_exact, [k, v]} ->
-        {{:required, [], [typespec_to_ast(k)]}, typespec_to_ast(v)}
-      {:type, _, :map_field_assoc, [k, v]} ->
-        {{:optional, [], [typespec_to_ast(k)]}, typespec_to_ast(v)}
+    fields = Enum.map fields, fn {:type, _, :map_field_assoc, k, v} ->
+      {typespec_to_ast(k), typespec_to_ast(v)}
     end
 
     {struct, fields} = Keyword.pop(fields, :__struct__)
@@ -599,13 +693,13 @@ defmodule Kernel.Typespec do
 
   defp typespec_to_ast({:type, line, :binary, [arg1, arg2]}) do
     [arg1, arg2] = for arg <- [arg1, arg2], do: typespec_to_ast(arg)
-    case {typespec_to_ast(arg1), typespec_to_ast(arg2)} do
-      {arg1, 0} ->
+    cond do
+      arg2 == 0 ->
         quote line: line, do: <<_ :: unquote(arg1)>>
-      {0, arg2} ->
+      arg1 == 0 ->
         quote line: line, do: <<_ :: _ * unquote(arg2)>>
-      {arg1, arg2} ->
-        quote line: line, do: <<_ :: unquote(arg1), _ :: _ * unquote(arg2)>>
+      true ->
+        quote line: line, do: <<_ :: unquote(arg1) * unquote(arg2)>>
     end
   end
 
@@ -649,24 +743,14 @@ defmodule Kernel.Typespec do
   end
 
   # Special shortcut(s)
-  # TODO: Deprecate char_list type by v1.5
-  defp typespec_to_ast({:remote_type, line, [{:atom, _, :elixir}, {:atom, _, type}, []]})
-      when type in [:charlist, :char_list] do
-    typespec_to_ast({:type, line, :charlist, []})
-  end
-
-  defp typespec_to_ast({:remote_type, line, [{:atom, _, :elixir}, {:atom, _, :struct}, []]}) do
-    typespec_to_ast({:type, line, :struct, []})
+  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, [{:atom, _, :elixir}, {:atom, _, :keyword}, args]}) do
-    typespec_to_ast({:type, line, :keyword, args})
-  end
-
   defp typespec_to_ast({:remote_type, line, [mod, name, args]}) do
     args = for arg <- args, do: typespec_to_ast(arg)
     dot  = {:., [line: line], [typespec_to_ast(mod), typespec_to_ast(name)]}
@@ -699,9 +783,9 @@ defmodule Kernel.Typespec do
 
   defp erl_to_ex_var(var) do
     case Atom.to_string(var) do
-      <<"_", c::binary-1, rest::binary>> ->
+      <<"_", c :: binary-size(1), rest :: binary>> ->
         String.to_atom("_#{String.downcase(c)}#{rest}")
-      <<c::binary-1, rest::binary>> ->
+      <<c :: binary-size(1), rest :: binary>> ->
         String.to_atom("#{String.downcase(c)}#{rest}")
     end
   end
@@ -727,52 +811,19 @@ defmodule Kernel.Typespec do
     {:type, line(meta), :binary, [{:integer, line(meta), 0}, {:integer, line(meta), 0}]}
   end
 
-  defp typespec({:<<>>, meta, [{:::, unit_meta, [{:_, _, ctx1}, {:*, _, [{:_, _, ctx2}, unit]}]}]}, _, _)
-      when is_atom(ctx1) and is_atom(ctx2) and is_integer(unit) do
-    {:type, line(meta), :binary, [{:integer, line(meta), 0}, {:integer, line(unit_meta), unit}]}
+  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, [{:::, size_meta, [{:_, _, ctx}, size]}]}, _, _)
-      when is_atom(ctx) and is_integer(size) do
-    {:type, line(meta), :binary, [{:integer, line(size_meta), size}, {:integer, line(meta), 0}]}
-  end
-
-  defp typespec({:<<>>, meta, [{:::, size_meta, [{:_, _, ctx1}, size]}, {:::, unit_meta, [{:_, _, ctx2}, {:*, _, [{:_, _, ctx3}, unit]}]}]}, _, _)
-      when is_atom(ctx1) and is_atom(ctx2) and is_atom(ctx3) and is_integer(size) and is_integer(unit) do
-    {:type, line(meta), :binary, [{:integer, line(size_meta), size}, {:integer, line(unit_meta), unit}]}
+  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 maps and structs
-  defp typespec({:map, meta, args}, _vars, _caller) when args == [] or is_atom(args) do
-    {:type, line(meta), :map, :any}
-  end
-
-  defp typespec({:%{}, meta, fields} = map, vars, caller) do
-    fields =
-      :lists.map(fn
-        :... ->
-          {:type, line(meta), :map_field_assoc, :any}
-        {k, v} when is_atom(k) ->
-          {:type, line(meta), :map_field_exact, [typespec(k, vars, caller), typespec(v, vars, caller)]}
-        {{:required, meta2, [k]}, v} ->
-          {:type, line(meta2), :map_field_exact, [typespec(k, vars, caller), typespec(v, vars, caller)]}
-        {{:optional, meta2, [k]}, v} ->
-          {:type, line(meta2), :map_field_assoc, [typespec(k, vars, caller), typespec(v, vars, caller)]}
-        {k, v} ->
-          # TODO: Emit warnings on v1.5
-          # :elixir_errors.warn(caller.line, caller.file,
-          #   "invalid map specification. %{foo => bar} is deprecated in favor of " <>
-          #   "%{required(foo) => bar} and %{optional(foo) => bar}. required/1 is an " <>
-          #   "OTP 19 only feature, if you are targeting OTP 18 use optional/1.")
-          {:type, line(meta), :map_field_assoc, [typespec(k, vars, caller), typespec(v, vars, caller)]}
-        {:|, _, [_, _]} ->
-          compile_error(caller,
-            "invalid map specification. When using the | operator in the map key, " <>
-            "make sure to wrap the key type in parentheses: #{Macro.to_string(map)}")
-        _ ->
-          compile_error(caller, "invalid map specification: #{Macro.to_string(map)}")
-      end, fields)
-
+  defp typespec({:%{}, meta, fields}, vars, caller) do
+    fields = :lists.map(fn {k, v} ->
+      {:type, line(meta), :map_field_assoc, typespec(k, vars, caller), typespec(v, vars, caller)}
+    end, fields)
     {:type, line(meta), :map, fields}
   end
 
@@ -787,16 +838,11 @@ defmodule Kernel.Typespec do
         module.__struct__
       end
 
-    struct = struct |> Map.from_struct |> Map.to_list
-
-    unless Keyword.keyword?(fields) do
-      compile_error(caller, "expected key-value pairs in struct #{Macro.to_string(name)}")
-    end
-
-    types =
+    struct =
       :lists.map(fn {field, _} ->
-        {field, Keyword.get(fields, field, quote(do: term()))}
-      end, struct)
+        {field, quote do: term()}
+      end, Map.to_list(struct))
+
 
     :lists.foreach(fn {field, _} ->
       unless Keyword.has_key?(struct, field) do
@@ -804,7 +850,8 @@ defmodule Kernel.Typespec do
       end
     end, fields)
 
-    typespec({:%{}, meta, [__struct__: module] ++ types}, vars, caller)
+    fields = Keyword.merge(struct, [__struct__: module] ++ fields)
+    typespec({:%{}, meta, fields}, vars, caller)
   end
 
   # Handle records
@@ -815,9 +862,9 @@ defmodule Kernel.Typespec do
   defp typespec({:record, meta, [atom, fields]}, vars, caller) do
     case Macro.expand({atom, [], [{atom, [], []}]}, caller) do
       keyword when is_list(keyword) ->
-        types =
+        keyword =
           :lists.map(fn {field, _} ->
-            Keyword.get(fields, field, quote(do: term()))
+            {field, quote do: term()}
           end, keyword)
 
         :lists.foreach(fn {field, _} ->
@@ -826,7 +873,10 @@ defmodule Kernel.Typespec do
           end
         end, fields)
 
-        typespec({:{}, meta, [atom | types]}, vars, caller)
+        fields = Keyword.merge(keyword, fields)
+        types = Keyword.values(fields)
+
+        typespec({:{}, meta, [atom|types]}, vars, caller)
       _ ->
         compile_error(caller, "unknown record #{inspect atom}")
     end
@@ -834,8 +884,7 @@ defmodule Kernel.Typespec do
 
   # Handle ranges
   defp typespec({:.., meta, args}, vars, caller) do
-    args = for arg <- args, do: typespec(arg, vars, caller)
-    {:type, line(meta), :range, args}
+    typespec({:range, meta, args}, vars, caller)
   end
 
   # Handle special forms
@@ -844,9 +893,7 @@ defmodule Kernel.Typespec do
   end
 
   defp typespec({:__aliases__, _, _} = alias, vars, caller) do
-    # We set a function name to avoid tracking
-    # aliases in typespecs as compile time dependencies.
-    atom = Macro.expand(alias, %{caller | function: {:typespec, 0}})
+    atom = Macro.expand alias, caller
     typespec(atom, vars, caller)
   end
 
@@ -858,7 +905,7 @@ defmodule Kernel.Typespec do
 
   # Handle type operator
   defp typespec({:::, meta, [var, expr]}, vars, caller) do
-    left  = typespec(var, [elem(var, 0) | vars], caller)
+    left  = typespec(var, [elem(var, 0)|vars], caller)
     right = typespec(expr, vars, caller)
     {:ann_type, line(meta), [left, right]}
   end
@@ -868,19 +915,6 @@ defmodule Kernel.Typespec do
     {:op, line(meta), op, {:integer, line(meta), integer}}
   end
 
-  # Handle remote calls in the form of @module_attribute.type.
-  # These are not handled by the general remote type clause as calling
-  # Macro.expand/2 on the remote does not expand module attributes (but expands
-  # things like __MODULE__).
-  defp typespec({{:., meta, [{:@, _, [{attr, _, _}]}, name]}, _, args} = orig, vars, caller) do
-    remote = Module.get_attribute(caller.module, attr)
-    unless is_atom(remote) and remote != nil do
-      message = "invalid remote in typespec: #{Macro.to_string(orig)} (@#{attr} is #{inspect remote})"
-      compile_error(caller, message)
-    end
-    remote_type({typespec(remote, vars, caller), meta, typespec(name, vars, caller), args}, vars, caller)
-  end
-
   # Handle remote calls
   defp typespec({{:., meta, [remote, name]}, _, args} = orig, vars, caller) do
     remote = Macro.expand remote, caller
@@ -921,38 +955,22 @@ defmodule Kernel.Typespec do
   # Handle local calls
   defp typespec({type, meta, arguments}, vars, caller) when type in [:string, :nonempty_string] do
     :elixir_errors.warn caller.line, caller.file, "#{type}() type use is discouraged. For character lists, use " <>
-      "charlist() type, for strings, String.t()\n#{Exception.format_stacktrace(Macro.Env.stacktrace(caller))}"
+      "char_list() type, for strings, String.t()\n#{Exception.format_stacktrace(Macro.Env.stacktrace(caller))}"
     arguments = for arg <- arguments, do: typespec(arg, vars, caller)
     {:type, line(meta), type, arguments}
   end
 
-  # TODO: Deprecate char_list type by v1.5
-  defp typespec({type, _meta, []}, vars, caller) when type in [:charlist, :char_list] do
-    typespec((quote do: :elixir.charlist()), vars, caller)
-  end
-
-  defp typespec({:struct, _meta, []}, vars, caller) do
-    typespec((quote do: :elixir.struct()), vars, caller)
+  defp typespec({:char_list, _meta, []}, vars, caller) do
+    typespec((quote do: :elixir.char_list()), vars, caller)
   end
 
   defp typespec({:as_boolean, _meta, [arg]}, vars, caller) do
     typespec((quote do: :elixir.as_boolean(unquote(arg))), vars, caller)
   end
 
-  defp typespec({:keyword, _meta, args}, vars, caller) when length(args) <= 1 do
-    typespec((quote do: :elixir.keyword(unquote_splicing(args))), vars, caller)
-  end
-
-  defp typespec({:fun, meta, args}, vars, caller) do
-    args = for arg <- args, do: typespec(arg, vars, caller)
-    {:type, line(meta), :fun, args}
-  end
-
   defp typespec({name, meta, arguments}, vars, caller) do
     arguments = for arg <- arguments, do: typespec(arg, vars, caller)
-    arity = length(arguments)
-    type = if :erl_internal.is_type(name, arity), do: :type, else: :user_type
-    {type, line(meta), name, arguments}
+    {:type, line(meta), name, arguments}
   end
 
   # Handle literals
@@ -981,7 +999,7 @@ defmodule Kernel.Typespec do
   end
 
   defp typespec(list, vars, caller) when is_list(list) do
-    [h | t] = :lists.reverse(list)
+    [h|t] = :lists.reverse(list)
     union = :lists.foldl(fn(x, acc) ->
       {:|, [], [validate_kw(x, list, caller), acc]}
     end, validate_kw(h, list, caller), t)
@@ -1003,7 +1021,7 @@ defmodule Kernel.Typespec do
     {:remote_type, line(meta), [ remote, name, arguments ]}
   end
 
-  defp collect_union({:|, _, [a, b]}), do: [a | collect_union(b)]
+  defp collect_union({:|, _, [a, b]}), do: [a|collect_union(b)]
   defp collect_union(v), do: [v]
 
   defp validate_kw({key, _} = t, _, _caller) when is_atom(key), do: t
@@ -1031,8 +1049,8 @@ defmodule Kernel.Typespec do
     {:var, line(meta), name}
   end
 
-  defp unpack_typespec_kw([{:type, _, :tuple, [{:atom, _, atom}, type]} | t], acc) do
-    unpack_typespec_kw(t, [{atom, typespec_to_ast(type)} | acc])
+  defp unpack_typespec_kw([{:type, _, :tuple, [{:atom, _, atom}, type]}|t], acc) do
+    unpack_typespec_kw(t, [{atom, typespec_to_ast(type)}|acc])
   end
 
   defp unpack_typespec_kw([], acc) do

lib/elixir/lib/kernel/utils.ex

@@ -1,94 +0,0 @@
-import Kernel, except: [destructure: 2, defdelegate: 2, defstruct: 2]
-
-defmodule Kernel.Utils do
-  @moduledoc false
-
-  def destructure(list, count) when is_list(list), do: destructure_list(list, count)
-  def destructure(nil, count), do: destructure_nil(count)
-
-  defp destructure_list(_, 0), do: []
-  defp destructure_list([], count), do: destructure_nil(count)
-  defp destructure_list([h | t], count), do: [h | destructure_list(t, count - 1)]
-
-  defp destructure_nil(0), do: []
-  defp destructure_nil(count), do: [nil | destructure_nil(count - 1)]
-
-  def defdelegate(fun, opts) do
-    append_first = Keyword.get(opts, :append_first, false)
-
-    {name, args} =
-      case Macro.decompose_call(fun) do
-        {_, _} = pair -> pair
-        _ -> raise ArgumentError, "invalid syntax in defdelegate #{Macro.to_string(fun)}"
-      end
-
-    as_args_list = normalize_args(args)
-    as = Keyword.get(opts, :as, name)
-    :lists.map(fn as_args ->
-      formal_args = make_formal_args(as_args)
-      as_args = case append_first do
-        true  -> tl(as_args) ++ [hd(as_args)]
-        false -> as_args
-      end
-      {name, formal_args, as, as_args}
-    end, as_args_list)
-  end
-
-  defp make_formal_args(args) do
-    fun = &match?({name, _, mod} when is_atom(name) and is_atom(mod), &1)
-    :lists.filter(fun, args)
-  end
-
-  defp normalize_args(raw_args) do
-    :lists.foldr(fn
-      ({:\\, _, [arg, default_arg]}, [as_args | _] = as_args_list) ->
-        new_as_args = [default_arg | as_args]
-        [new_as_args | add_arg(as_args_list, arg)]
-      (arg, as_args_list) ->
-        add_arg(as_args_list, arg)
-    end, [[]], raw_args)
-  end
-
-  defp add_arg(as_args_list, {name, _, mod} = arg) when is_atom(name) and is_atom(mod),
-    do: :lists.map(&([arg | &1]), as_args_list)
-  defp add_arg(_, code) do
-    raise ArgumentError,
-      "defdelegate/2 only accepts function parameters, got: #{Macro.to_string(code)}"
-  end
-
-  def defstruct(module, fields) do
-    case fields do
-      fs when is_list(fs) ->
-        :ok
-      other ->
-        raise ArgumentError, "struct fields definition must be list, got: #{inspect other}"
-    end
-
-    fields = :lists.map(fn
-      {key, val} when is_atom(key) ->
-        try do
-          Macro.escape(val)
-        rescue
-          e in [ArgumentError] ->
-            raise ArgumentError, "invalid value for struct field #{key}, " <> Exception.message(e)
-        else
-          _ -> {key, val}
-        end
-      key when is_atom(key) ->
-        {key, nil}
-      other ->
-        raise ArgumentError, "struct field names must be atoms, got: #{inspect other}"
-    end, fields)
-
-    {:maps.put(:__struct__, module, :maps.from_list(fields)),
-     List.wrap(Module.get_attribute(module, :enforce_keys)),
-     Module.get_attribute(module, :derive)}
-  end
-
-  def announce_struct(module) do
-    case :erlang.get(:elixir_compiler_pid) do
-      :undefined -> :ok
-      pid -> send(pid, {:struct_available, module})
-    end
-  end
-end

lib/elixir/lib/keyword.ex

@@ -1,15 +1,13 @@
 defmodule Keyword do
   @moduledoc """
-  A set of functions for working with keywords.
-
-  A keyword is a list of two-element tuples where the first
-  element of the tuple is an atom and the second element
-  can be any value.
+  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 key-value store. However most of the functions in this module
-  behave exactly as a dictionary so they work similarly to
-  the functions you would find in the `Map` module.
+  a dictionary. However most of the functions in this module
+  behave exactly as a dictionary and mimic the API defined
+  by the `Dict` behaviour.
 
   For example, `Keyword.get/3` will get the first entry matching
   the given key, regardless if duplicated entries exist.
@@ -22,13 +20,12 @@ defmodule Keyword do
   a given key and `delete_first/2` deletes just one of the existing
   entries.
 
-  The functions in Keyword do not guarantee any property when
-  it comes to ordering. However, since a keyword list is simply a
-  list, all the operations defined in `Enum` and `List` can be
-  applied too, specially when ordering is required.
+  Since a keyword list is simply a list, all the operations defined
+  in `Enum` and `List` can be applied.
   """
 
   @compile :inline_list_funcs
+  @behaviour Dict
 
   @type key :: atom
   @type value :: any
@@ -37,62 +34,42 @@ defmodule Keyword do
   @type t(value) :: [{key, value}]
 
   @doc """
-  Returns `true` if `term` is a keyword list; otherwise returns `false`.
-
-  ## Examples
-
-      iex> Keyword.keyword?([])
-      true
-      iex> Keyword.keyword?([a: 1])
-      true
-      iex> Keyword.keyword?([{Foo, 1}])
-      true
-      iex> Keyword.keyword?([{}])
-      false
-      iex> Keyword.keyword?([:key])
-      false
-      iex> Keyword.keyword?(%{})
-      false
-
+  Checks if the given argument is a keyword list or not.
   """
   @spec keyword?(term) :: boolean
-  def keyword?(term)
+  def keyword?([{key, _value} | rest]) when is_atom(key) do
+    keyword?(rest)
+  end
 
-  def keyword?([{key, _value} | rest]) when is_atom(key), do: keyword?(rest)
   def keyword?([]),     do: true
   def keyword?(_other), do: false
 
   @doc """
   Returns an empty keyword list, i.e. an empty list.
-
-  ## Examples
-
-      iex> Keyword.new()
-      []
-
   """
-  @spec new :: []
-  def new, do: []
+  @spec new :: t
+  def new do
+    []
+  end
 
   @doc """
   Creates a keyword from an enumerable.
 
   Duplicated entries are removed, the latest one prevails.
-  Unlike `Enum.into(enumerable, [])`, `Keyword.new(enumerable)`
-  guarantees the keys are unique.
+  Unlike `Enum.into(enumerable, [])`,
+  `Keyword.new(enumerable)` guarantees the keys are unique.
 
   ## Examples
 
       iex> Keyword.new([{:b, 1}, {:a, 2}])
-      [b: 1, a: 2]
-
-      iex> Keyword.new([{:a, 1}, {:a, 2}, {:a, 3}])
-      [a: 3]
+      [a: 2, b: 1]
 
   """
   @spec new(Enum.t) :: t
   def new(pairs) do
-    new(pairs, fn pair -> pair end)
+    Enum.reduce pairs, [], fn {k, v}, keywords ->
+      put(keywords, k, v)
+    end
   end
 
   @doc """
@@ -104,46 +81,37 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.new([:a, :b], fn(x) -> {x, x} end)
+      iex> Keyword.new([:a, :b], fn (x) -> {x, x} end) |> Enum.sort
       [a: :a, b: :b]
 
   """
-  @spec new(Enum.t, (term -> {key, value})) :: t
+  @spec new(Enum.t, ({key, value} -> {key, value})) :: t
   def new(pairs, transform) do
-    fun = fn el, acc ->
-      {k, v} = transform.(el)
-      put_new(acc, k, v)
+    Enum.reduce pairs, [], fn i, keywords ->
+      {k, v} = transform.(i)
+      put(keywords, k, v)
     end
-    :lists.foldl(fun, [], Enum.reverse(pairs))
   end
 
   @doc """
   Gets the value for a specific `key`.
 
-  If `key` does not exist, return the default value
-  (`nil` if no default value).
+  If `key` does not exist, return the default value (`nil` if no default value).
 
   If duplicated entries exist, the first one is returned.
   Use `get_values/2` to retrieve all entries.
 
   ## Examples
 
-      iex> Keyword.get([], :a)
-      nil
       iex> Keyword.get([a: 1], :a)
       1
+
       iex> Keyword.get([a: 1], :b)
       nil
+
       iex> Keyword.get([a: 1], :b, 3)
       3
 
-  With duplicated keys:
-
-      iex> Keyword.get([a: 1, a: 2], :a, 3)
-      1
-      iex> Keyword.get([a: 1, a: 2], :b, 3)
-      3
-
   """
   @spec get(t, key) :: value
   @spec get(t, key, value) :: value
@@ -154,144 +122,6 @@ defmodule Keyword do
     end
   end
 
-  @doc """
-  Gets the value for a specific `key`.
-
-  If `key` does not exist, lazily evaluates `fun` and returns its result.
-
-  This is useful if the default value is very expensive to calculate or
-  generally difficult to setup and teardown again.
-
-  If duplicated entries exist, the first one is returned.
-  Use `get_values/2` to retrieve all entries.
-
-  ## Examples
-
-      iex> keyword = [a: 1]
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   13
-      ...> end
-      iex> Keyword.get_lazy(keyword, :a, fun)
-      1
-      iex> Keyword.get_lazy(keyword, :b, fun)
-      13
-
-  """
-  @spec get_lazy(t, key, (() -> value)) :: value
-  def get_lazy(keywords, key, fun)
-      when is_list(keywords) and is_atom(key) and is_function(fun, 0) do
-    case :lists.keyfind(key, 1, keywords) do
-      {^key, value} -> value
-      false -> fun.()
-    end
-  end
-
-  @doc """
-  Gets the value from `key` and updates it, all in one pass.
-
-  This `fun` argument receives the value of `key` (or `nil` if `key`
-  is not present) and must return a two-element tuple: the "get" value
-  (the retrieved value, which can be operated on before being returned)
-  and the new value to be stored under `key`. The `fun` may also
-  return `:pop`, implying the current value shall be removed from the
-  keyword list and returned.
-
-  The returned value is a tuple with the "get" value returned by
-  `fun` and a new keyword list with the updated value under `key`.
-
-  ## Examples
-
-      iex> Keyword.get_and_update([a: 1], :a, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      {1, [a: "new value!"]}
-
-      iex> Keyword.get_and_update([a: 1], :b, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      {nil, [b: "new value!", a: 1]}
-
-      iex> Keyword.get_and_update([a: 1], :a, fn _ -> :pop end)
-      {1, []}
-
-      iex> Keyword.get_and_update([a: 1], :b, fn _ -> :pop end)
-      {nil, [a: 1]}
-
-  """
-  @spec get_and_update(t, key, (value -> {get, value} | :pop)) :: {get, t} when get: term
-  def get_and_update(keywords, key, fun)
-    when is_list(keywords) and is_atom(key),
-    do: get_and_update(keywords, [], key, fun)
-
-  defp get_and_update([{key, current} | t], acc, key, fun) do
-    case fun.(current) do
-      {get, value} -> {get, :lists.reverse(acc, [{key, value} | t])}
-      :pop         -> {current, :lists.reverse(acc, t)}
-    end
-  end
-
-  defp get_and_update([h | t], acc, key, fun),
-    do: get_and_update(t, [h | acc], key, fun)
-
-  defp get_and_update([], acc, key, fun) do
-    case fun.(nil) do
-      {get, update} -> {get, [{key, update} | :lists.reverse(acc)]}
-      :pop -> {nil, :lists.reverse(acc)}
-    end
-  end
-
-  @doc """
-  Gets the value from `key` and updates it. Raises if there is no `key`.
-
-  This `fun` argument receives the value of `key` and must return a
-  two-element tuple: the "get" value (the retrieved value, which can be
-  operated on before being returned) and the new value to be stored under
-  `key`.
-
-  The returned value is a tuple with the "get" value returned by `fun` and a new
-  keyword list with the updated value under `key`.
-
-  ## Examples
-
-      iex> Keyword.get_and_update!([a: 1], :a, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      {1, [a: "new value!"]}
-
-      iex> Keyword.get_and_update!([a: 1], :b, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      ** (KeyError) key :b not found in: [a: 1]
-
-      iex> Keyword.get_and_update!([a: 1], :a, fn _ ->
-      ...>   :pop
-      ...> end)
-      {1, []}
-
-  """
-  @spec get_and_update!(t, key, (value -> {get, value})) :: {get, t} | no_return when get: term
-  def get_and_update!(keywords, key, fun) do
-    get_and_update!(keywords, key, fun, [])
-  end
-
-  defp get_and_update!([{key, value} | keywords], key, fun, acc) do
-    case fun.(value) do
-      {get, value} ->
-        {get, :lists.reverse(acc, [{key, value} | delete(keywords, key)])}
-      :pop ->
-        {value, :lists.reverse(acc, keywords)}
-    end
-  end
-
-  defp get_and_update!([{_, _} = e | keywords], key, fun, acc) do
-    get_and_update!(keywords, key, fun, [e | acc])
-  end
-
-  defp get_and_update!([], key, _fun, acc) when is_atom(key) do
-    raise(KeyError, key: key, term: acc)
-  end
-
   @doc """
   Fetches the value for a specific `key` and returns it in a tuple.
 
@@ -301,6 +131,7 @@ defmodule Keyword do
 
       iex> Keyword.fetch([a: 1], :a)
       {:ok, 1}
+
       iex> Keyword.fetch([a: 1], :b)
       :error
 
@@ -314,14 +145,15 @@ defmodule Keyword do
   end
 
   @doc """
-  Fetches the value for specific `key`.
-
+  Fetches the value for specific `key`. 
+  
   If `key` does not exist, a `KeyError` is raised.
 
   ## Examples
 
       iex> Keyword.fetch!([a: 1], :a)
       1
+
       iex> Keyword.fetch!([a: 1], :b)
       ** (KeyError) key :b not found in: [a: 1]
 
@@ -339,34 +171,32 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.get_values([], :a)
-      []
-      iex> Keyword.get_values([a: 1], :a)
-      [1]
       iex> Keyword.get_values([a: 1, a: 2], :a)
-      [1, 2]
+      [1,2]
 
   """
   @spec get_values(t, key) :: [value]
   def get_values(keywords, key) when is_list(keywords) and is_atom(key) do
     fun = fn
-      {^key, val} -> {true, val}
+      {k, v} when k === key -> {true, v}
       {_, _} -> false
     end
+
     :lists.filtermap(fun, keywords)
   end
 
   @doc """
-  Returns all keys from the keyword list.
-
+  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]
+      [:a,:b]
+
       iex> Keyword.keys([a: 1, b: 2, a: 3])
-      [:a, :b, :a]
+      [:a,:b,:a]
 
   """
   @spec keys(t) :: [key]
@@ -377,14 +207,10 @@ defmodule Keyword do
   @doc """
   Returns all values from the keyword list.
 
-  Values from duplicated keys will be kept in the final list of values.
-
   ## Examples
 
       iex> Keyword.values([a: 1, b: 2])
-      [1, 2]
-      iex> Keyword.values([a: 1, b: 2, a: 3])
-      [1, 2, 3]
+      [1,2]
 
   """
   @spec values(t) :: [value]
@@ -401,12 +227,12 @@ defmodule Keyword do
 
       iex> Keyword.delete([a: 1, b: 2], :a, 1)
       [b: 2]
+
       iex> Keyword.delete([a: 1, b: 2, a: 3], :a, 3)
       [a: 1, b: 2]
-      iex> Keyword.delete([a: 1], :a, 5)
-      [a: 1]
-      iex> Keyword.delete([a: 1], :b, 5)
-      [a: 1]
+
+      iex> Keyword.delete([b: 2], :a, 5)
+      [b: 2]
 
   """
   @spec delete(t, key, value) :: t
@@ -425,8 +251,10 @@ defmodule Keyword do
 
       iex> Keyword.delete([a: 1, b: 2], :a)
       [b: 2]
+
       iex> Keyword.delete([a: 1, b: 2, a: 3], :a)
       [b: 2]
+
       iex> Keyword.delete([b: 2], :a)
       [b: 2]
 
@@ -445,6 +273,7 @@ defmodule Keyword do
 
       iex> Keyword.delete_first([a: 1, b: 2, a: 3], :a)
       [b: 2, a: 3]
+
       iex> Keyword.delete_first([b: 2], :a)
       [b: 2]
 
@@ -462,46 +291,16 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.put([a: 1], :b, 2)
-      [b: 2, a: 1]
       iex> Keyword.put([a: 1, b: 2], :a, 3)
       [a: 3, b: 2]
+
       iex> Keyword.put([a: 1, b: 2, a: 4], :a, 3)
       [a: 3, b: 2]
 
   """
   @spec put(t, key, value) :: t
   def put(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    [{key, value} | delete(keywords, key)]
-  end
-
-  @doc """
-  Evaluates `fun` and puts the result under `key`
-  in keyword list unless `key` is already present.
-
-  This is useful if the value is very expensive to calculate or
-  generally difficult to setup and teardown again.
-
-  ## Examples
-
-      iex> keyword = [a: 1]
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   3
-      ...> end
-      iex> Keyword.put_new_lazy(keyword, :a, fun)
-      [a: 1]
-      iex> Keyword.put_new_lazy(keyword, :b, fun)
-      [b: 3, a: 1]
-
-  """
-  @spec put_new_lazy(t, key, (() -> value)) :: t
-  def put_new_lazy(keywords, key, fun)
-      when is_list(keywords) and is_atom(key) and is_function(fun, 0) do
-    case :lists.keyfind(key, 1, keywords) do
-      {^key, _} -> keywords
-      false -> [{key, fun.()} | keywords]
-    end
+    [{key, value}|delete(keywords, key)]
   end
 
   @doc """
@@ -512,6 +311,7 @@ defmodule Keyword do
 
       iex> Keyword.put_new([a: 1], :b, 2)
       [b: 2, a: 1]
+
       iex> Keyword.put_new([a: 1, b: 2], :a, 3)
       [a: 1, b: 2]
 
@@ -520,13 +320,13 @@ defmodule Keyword do
   def put_new(keywords, key, value) when is_list(keywords) and is_atom(key) do
     case :lists.keyfind(key, 1, keywords) do
       {^key, _} -> keywords
-      false -> [{key, value} | keywords]
+      false -> [{key, value}|keywords]
     end
   end
 
   @doc """
-  Checks if two keywords are equal.
-
+  Checks if two keywords are equal. 
+  
   Two keywords are considered to be equal if they contain
   the same keys and those keys contain the same values.
 
@@ -534,10 +334,6 @@ defmodule Keyword do
 
       iex> Keyword.equal?([a: 1, b: 2], [b: 2, a: 1])
       true
-      iex> Keyword.equal?([a: 1, b: 2], [b: 1, a: 2])
-      false
-      iex> Keyword.equal?([a: 1, b: 2, a: 3], [b: 2, a: 3, a: 1])
-      true
 
   """
   @spec equal?(t, t) :: boolean
@@ -546,74 +342,46 @@ defmodule Keyword do
   end
 
   @doc """
-  Merges two keyword lists into one.
-
-  All keys, including duplicated keys, given in `keywords2` will be added
-  to `keywords1`, overriding any existing one.
-
-  There are no guarantees about the order of keys in the returned keyword.
+  Merges two keyword lists into one. 
+  
+  If they have duplicated keys, the one given in the second argument wins.
 
   ## Examples
 
-      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4])
-      [b: 2, a: 3, d: 4]
-
-      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4, a: 5])
-      [b: 2, a: 3, d: 4, a: 5]
+      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4]) |> Enum.sort
+      [a: 3, b: 2, d: 4]
 
   """
   @spec merge(t, t) :: t
-  def merge(keywords1, keywords2) when is_list(keywords1) and is_list(keywords2) do
-    fun = fn {k, _v} -> not has_key?(keywords2, k) end
-    :lists.filter(fun, keywords1) ++ keywords2
+  def merge(d1, d2) when is_list(d1) and is_list(d2) do
+    fun = fn {k, _v} -> not has_key?(d2, k) end
+    d2 ++ :lists.filter(fun, d1)
   end
 
   @doc """
-  Merges two keyword lists into one.
-
-  All keys, including duplicated keys, given in `keywords2` will be added
-  to `keywords1`. The given function will be invoked to solve conflicts.
-
-  If `keywords2` has duplicate keys, the given function will be invoked
-  for each matching pair in `keywords1`.
-
-  There are no guarantees about the order of keys in the returned keyword.
+  Merges two keyword lists into one. 
+  
+  If they have duplicated keys, 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
-      ...> end)
-      [b: 2, a: 4, d: 4]
-
-      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4, a: 5], fn :a, v1, v2 ->
+      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4], fn (_k, v1, v2) ->
       ...>  v1 + v2
       ...> end)
-      [b: 2, a: 4, d: 4, a: 5]
-
-      iex> Keyword.merge([a: 1, b: 2, a: 3], [a: 3, d: 4, a: 5], fn :a, v1, v2 ->
-      ...>  v1 + v2
-      ...> end)
-      [b: 2, a: 4, d: 4, a: 8]
+      [a: 4, b: 2, d: 4]
 
   """
   @spec merge(t, t, (key, value, value -> value)) :: t
-  def merge(keywords1, keywords2, fun) when is_list(keywords1) and is_list(keywords2) do
-    do_merge(keywords2, [], keywords1, keywords1, fun)
+  def merge(d1, d2, fun) when is_list(d1) and is_list(d2) do
+    do_merge(d2, d1, fun)
   end
 
-  defp do_merge([{k, v2} | t], acc, rest, original, fun) do
-    case :lists.keyfind(k, 1, original) do
-      {^k, v1} ->
-        do_merge(t, [{k, fun.(k, v1, v2)} | acc],
-                 delete(rest, k), :lists.keydelete(k, 1, original), fun)
-      false ->
-        do_merge(t, [{k, v2} | acc], rest, original, 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, rest, _original, _fun) do
-    rest ++ :lists.reverse(acc)
+  defp do_merge([], acc, _fun) do
+    acc
   end
 
   @doc """
@@ -623,6 +391,7 @@ defmodule Keyword do
 
       iex> Keyword.has_key?([a: 1], :a)
       true
+
       iex> Keyword.has_key?([a: 1], :b)
       false
 
@@ -633,8 +402,8 @@ defmodule Keyword do
   end
 
   @doc """
-  Updates the `key` with the given function.
-
+  Updates the `key` with the given function. 
+  
   If the `key` does not exist, raises `KeyError`.
 
   If there are duplicated keys, they are all removed and only the first one
@@ -644,8 +413,6 @@ defmodule Keyword do
 
       iex> Keyword.update!([a: 1], :a, &(&1 * 2))
       [a: 2]
-      iex> Keyword.update!([a: 1, a: 2], :a, &(&1 * 2))
-      [a: 2]
 
       iex> Keyword.update!([a: 1], :b, &(&1 * 2))
       ** (KeyError) key :b not found in: [a: 1]
@@ -656,12 +423,12 @@ defmodule Keyword do
     update!(keywords, key, fun, keywords)
   end
 
-  defp update!([{key, value} | keywords], key, fun, _dict) do
-    [{key, fun.(value)} | delete(keywords, key)]
+  defp update!([{key, value}|keywords], key, fun, _dict) do
+    [{key, fun.(value)}|delete(keywords, key)]
   end
 
-  defp update!([{_, _} = e | keywords], key, fun, dict) do
-    [e | update!(keywords, key, fun, dict)]
+  defp update!([{_, _} = e|keywords], key, fun, dict) do
+    [e|update!(keywords, key, fun, dict)]
   end
 
   defp update!([], key, _fun, dict) when is_atom(key) do
@@ -669,8 +436,8 @@ defmodule Keyword do
   end
 
   @doc """
-  Updates the `key` in `keywords` with the given function.
-
+  Updates the `key` with the given function. 
+  
   If the `key` does not exist, inserts the given `initial` value.
 
   If there are duplicated keys, they are all removed and only the first one
@@ -680,21 +447,18 @@ defmodule Keyword do
 
       iex> Keyword.update([a: 1], :a, 13, &(&1 * 2))
       [a: 2]
-      iex> Keyword.update([a: 1, a: 2], :a, 13, &(&1 * 2))
-      [a: 2]
+
       iex> Keyword.update([a: 1], :b, 11, &(&1 * 2))
       [a: 1, b: 11]
 
   """
   @spec update(t, key, value, (value -> value)) :: t
-  def update(keywords, key, initial, fun)
-
-  def update([{key, value} | keywords], key, _initial, fun) do
-    [{key, fun.(value)} | delete(keywords, key)]
+  def update([{key, value}|keywords], key, _initial, fun) do
+    [{key, fun.(value)}|delete(keywords, key)]
   end
 
-  def update([{_, _} = e | keywords], key, initial, fun) do
-    [e | update(keywords, key, initial, fun)]
+  def update([{_, _} = e|keywords], key, initial, fun) do
+    [e|update(keywords, key, initial, fun)]
   end
 
   def update([], key, initial, _fun) when is_atom(key) do
@@ -703,27 +467,30 @@ defmodule Keyword do
 
   @doc """
   Takes all entries corresponding to the given keys and extracts them into a
-  separate keyword list.
-
+  separate keyword list. 
+  
   Returns a tuple with the new list and the old list with removed keys.
 
-  Keys for which there are no entries in the keyword list are ignored.
+  Keys for which there are no entires in the keyword list are ignored.
 
   Entries with duplicated keys end up in the same keyword list.
 
   ## Examples
 
-      iex> Keyword.split([a: 1, b: 2, c: 3], [:a, :c, :e])
-      {[a: 1, c: 3], [b: 2]}
-      iex> Keyword.split([a: 1, b: 2, c: 3, a: 4], [:a, :c, :e])
-      {[a: 1, c: 3, a: 4], [b: 2]}
+      iex> d = [a: 1, b: 2, c: 3, d: 4]
+      iex> Keyword.split(d, [:a, :c, :e])
+      {[a: 1, c: 3], [b: 2, d: 4]}
+
+      iex> d = [a: 1, b: 2, c: 3, d: 4, a: 5]
+      iex> Keyword.split(d, [:a, :c, :e])
+      {[a: 1, c: 3, a: 5], [b: 2, d: 4]}
 
   """
   def split(keywords, keys) when is_list(keywords) do
     fun = fn {k, v}, {take, drop} ->
       case k in keys do
-        true  -> {[{k, v} | take], drop}
-        false -> {take, [{k, v} | drop]}
+        true  -> {[{k, v}|take], drop}
+        false -> {take, [{k, v}|drop]}
       end
     end
 
@@ -740,9 +507,12 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.take([a: 1, b: 2, c: 3], [:a, :c, :e])
+      iex> d = [a: 1, b: 2, c: 3, d: 4]
+      iex> Keyword.take(d, [:a, :c, :e])
       [a: 1, c: 3]
-      iex> Keyword.take([a: 1, b: 2, c: 3, a: 5], [:a, :c, :e])
+
+      iex> d = [a: 1, b: 2, c: 3, d: 4, a: 5]
+      iex> Keyword.take(d, [:a, :c, :e])
       [a: 1, c: 3, a: 5]
 
   """
@@ -757,9 +527,12 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.drop([a: 1, b: 2, c: 3], [:b, :d])
+      iex> d = [a: 1, b: 2, c: 3, d: 4]
+      iex> Keyword.drop(d, [:b, :d])
       [a: 1, c: 3]
-      iex> Keyword.drop([a: 1, b: 2, b: 3, c: 3, a: 5], [:b, :d])
+
+      iex> d = [a: 1, b: 2, b: 3, c: 3, d: 4, a: 5]
+      iex> Keyword.drop(d, [:b, :d])
       [a: 1, c: 3, a: 5]
 
   """
@@ -768,108 +541,72 @@ defmodule Keyword do
   end
 
   @doc """
-  Returns and removes all values associated with `key` in the keyword list.
+  Returns the first value associated with `key` in the keyword
+  list as well as the keyword list without `key`.
 
   All duplicated keys are removed. See `pop_first/3` for
   removing only the first entry.
 
   ## Examples
 
-      iex> Keyword.pop([a: 1], :a)
-      {1, []}
-      iex> Keyword.pop([a: 1], :b)
-      {nil, [a: 1]}
-      iex> Keyword.pop([a: 1], :b, 3)
-      {3, [a: 1]}
-      iex> Keyword.pop([a: 1, a: 2], :a)
-      {1, []}
+      iex> Keyword.pop [a: 1], :a
+      {1,[]}
+
+      iex> Keyword.pop [a: 1], :b
+      {nil,[a: 1]}
+
+      iex> Keyword.pop [a: 1], :b, 3
+      {3,[a: 1]}
+
+      iex> Keyword.pop [a: 1], :b, 3
+      {3,[a: 1]}
+
+      iex> Keyword.pop [a: 1, a: 2], :a
+      {1,[]}
 
   """
-  @spec pop(t, key, value) :: {value, t}
   def pop(keywords, key, default \\ nil) when is_list(keywords) do
-    case fetch(keywords, key) do
-      {:ok, value} ->
-        {value, delete(keywords, key)}
-      :error ->
-        {default, keywords}
-    end
+    {get(keywords, key, default), delete(keywords, key)}
   end
 
   @doc """
-  Lazily returns and removes all values associated with `key` in the keyword list.
-
-  This is useful if the default value is very expensive to calculate or
-  generally difficult to setup and teardown again.
-
-  All duplicated keys are removed. See `pop_first/3` for
-  removing only the first entry.
-
-  ## Examples
-
-      iex> keyword = [a: 1]
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   13
-      ...> end
-      iex> Keyword.pop_lazy(keyword, :a, fun)
-      {1, []}
-      iex> Keyword.pop_lazy(keyword, :b, fun)
-      {13, [a: 1]}
-
-  """
-  @spec pop_lazy(t, key, (() -> value)) :: {value, t}
-  def pop_lazy(keywords, key, fun)
-      when is_list(keywords) and is_function(fun, 0) do
-    case fetch(keywords, key) do
-      {:ok, value} ->
-        {value, delete(keywords, key)}
-      :error ->
-        {fun.(), keywords}
-    end
-  end
-
-  @doc """
-  Returns and removes the first value associated with `key` in the keyword list.
+  Returns the first value associated with `key` in the keyword
+  list as well as the keyword list without that particular occurrence
+  of `key`.
 
   Duplicated keys are not removed.
 
   ## Examples
 
       iex> Keyword.pop_first [a: 1], :a
-      {1, []}
+      {1,[]}
+
       iex> Keyword.pop_first [a: 1], :b
-      {nil, [a: 1]}
+      {nil,[a: 1]}
+
       iex> Keyword.pop_first [a: 1], :b, 3
-      {3, [a: 1]}
+      {3,[a: 1]}
+
+      iex> Keyword.pop_first [a: 1], :b, 3
+      {3,[a: 1]}
+
       iex> Keyword.pop_first [a: 1, a: 2], :a
-      {1, [a: 2]}
+      {1,[a: 2]}
 
   """
-  @spec pop_first(t, key, value) :: {value, t}
   def pop_first(keywords, key, default \\ nil) when is_list(keywords) do
-    case :lists.keytake(key, 1, keywords) do
-      {:value, {^key, value}, rest} -> {value, rest}
-      false -> {default, keywords}
-    end
+    {get(keywords, key, default), delete_first(keywords, key)}
   end
 
-  @doc """
-  Returns the keyword list itself.
+  # Dict callbacks
 
-  ## Examples
-
-      iex> Keyword.to_list([a: 1])
-      [a: 1]
-
-  """
-  def to_list(keyword) when is_list(keyword) do
-    keyword
+  @doc false
+  def size(keyword) do
+    length(keyword)
   end
 
   @doc false
-  # TODO: Remove on 2.0
-  def size(keyword) do
-    IO.warn "Keyword.size/1 is deprecated, please use Kernel.length/1"
-    length(keyword)
+  def to_list(keyword) do
+    keyword
   end
 end

lib/elixir/lib/list.ex

@@ -1,45 +1,19 @@
 defmodule List do
   @moduledoc """
-  Specialized functions that only work on lists.
+  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.
 
-  In general, favor using the `Enum` API instead of `List`.
-
-  Index access for list is linear. Negative indexes are also
+  Some functions in this module expect an index. Index
+  access for list is linear. Negative indexes are also
   supported but they imply the list will be iterated twice,
-  one to calculate the proper index and another to perform the
+  one to calculate the proper index and another to the
   operation.
 
   A decision was taken to delegate most functions to
   Erlang's standard library but follow Elixir's convention
-  of receiving the subject (in this case, a list) as the
+  of receiving the target (in this case, a list) as the
   first argument.
-
-  ## Charlists
-
-  If a list is made of non-negative integers, it can also
-  be called as a charlist. Elixir uses single quotes to
-  define charlists:
-
-      iex> 'héllo'
-      [104, 233, 108, 108, 111]
-
-  In particular, charlists may be printed back in single
-  quotes if they contain only ASCII-printable codepoints:
-
-      iex> 'abc'
-      'abc'
-
-  The rationale behind this behaviour is to better support
-  Erlang libraries which may return text as charlists
-  instead of Elixir strings. One example of such functions
-  is `Application.loaded_applications`:
-
-      Application.loaded_applications
-      #=>  [{:stdlib, 'ERTS  CXC 138 10', '2.6'},
-            {:compiler, 'ERTS  CXC 138 10', '6.0.1'},
-            {:elixir, 'elixir', '1.0.0'},
-            {:kernel, 'ERTS  CXC 138 10', '4.1'},
-            {:logger, 'logger', '1.0.0'}]
   """
 
   @compile :inline_list_funcs
@@ -52,7 +26,7 @@ defmodule List do
   ## Examples
 
       iex> List.delete([1, 2, 3], 1)
-      [2, 3]
+      [2,3]
 
       iex> List.delete([1, 2, 2, 3], 2)
       [1, 2, 3]
@@ -69,11 +43,10 @@ defmodule List do
   ## Examples
 
       iex> List.duplicate("hello", 3)
-      ["hello", "hello", "hello"]
+      ["hello","hello","hello"]
 
       iex> List.duplicate([1, 2], 2)
-      [[1, 2], [1, 2]]
-
+      [[1,2],[1,2]]
 
   """
   @spec duplicate(elem, non_neg_integer) :: [elem] when elem: var
@@ -87,7 +60,7 @@ defmodule List do
   ## Examples
 
       iex> List.flatten([1, [[2], 3]])
-      [1, 2, 3]
+      [1,2,3]
 
   """
   @spec flatten(deep_list) :: list when deep_list: [any | deep_list]
@@ -103,7 +76,7 @@ defmodule List do
   ## Examples
 
       iex> List.flatten([1, [[2], 3]], [4, 5])
-      [1, 2, 3, 4, 5]
+      [1,2,3,4,5]
 
   """
   @spec flatten(deep_list, [elem]) :: [elem] when elem: var, deep_list: [elem | deep_list]
@@ -112,15 +85,15 @@ defmodule List do
   end
 
   @doc """
-  Folds (reduces) the given list from the left with
+  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)
+      iex> List.foldl([5, 5], 10, fn (x, acc) -> x + acc end)
       20
 
-      iex> List.foldl([1, 2, 3, 4], 0, fn(x, acc) -> x - acc end)
+      iex> List.foldl([1, 2, 3, 4], 0, fn (x, acc) -> x - acc end)
       2
 
   """
@@ -130,12 +103,12 @@ defmodule List do
   end
 
   @doc """
-  Folds (reduces) the given list from the right with
+  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)
+      iex> List.foldr([1, 2, 3, 4], 0, fn (x, acc) -> x - acc end)
       -2
 
   """
@@ -160,8 +133,8 @@ defmodule List do
 
   """
   @spec first([elem]) :: nil | elem when elem: var
-  def first([]),      do: nil
-  def first([h | _]), do: h
+  def first([]),    do: nil
+  def first([h|_]), do: h
 
   @doc """
   Returns the last element in `list` or `nil` if `list` is empty.
@@ -179,14 +152,14 @@ defmodule List do
 
   """
   @spec last([elem]) :: nil | elem when elem: var
-  def last([]),      do: nil
-  def last([h]),     do: h
-  def last([_ | t]), do: last(t)
+  def last([]),    do: nil
+  def last([h]),   do: h
+  def last([_|t]), do: last(t)
 
   @doc """
   Receives a list of tuples and returns the first tuple
   where the item at `position` in the tuple matches the
-  given `key`.
+  given `item`.
 
   ## Examples
 
@@ -208,7 +181,7 @@ defmodule List do
   @doc """
   Receives a list of tuples and returns `true` if there is
   a tuple where the item at `position` in the tuple matches
-  the given `key`.
+  the given `item`.
 
   ## Examples
 
@@ -282,7 +255,7 @@ defmodule List do
   @doc """
   Receives a list of tuples and deletes the first tuple
   where the item at `position` matches the
-  given `key`. Returns the new list.
+  given `item`. Returns the new list.
 
   ## Examples
 
@@ -301,33 +274,6 @@ defmodule List do
     :lists.keydelete(key, position + 1, list)
   end
 
-  @doc """
-  Receives a `list` of tuples and returns the first tuple
-  where the element at `position` in the tuple matches the
-  given `key`, as well as the `list` without found tuple.
-
-  If such a tuple is not found, `nil` will be returned.
-
-  ## Examples
-
-      iex> List.keytake([a: 1, b: 2], :a, 0)
-      {{:a, 1}, [b: 2]}
-
-      iex> List.keytake([a: 1, b: 2], 2, 1)
-      {{:b, 2}, [a: 1]}
-
-      iex> List.keytake([a: 1, b: 2], :c, 0)
-      nil
-
-  """
-  @spec keytake([tuple], any, non_neg_integer) :: {tuple, [tuple]} | nil
-  def keytake(list, key, position) do
-    case :lists.keytake(key, position + 1, list) do
-      {:value, item, list} -> {item, list}
-      false                -> nil
-    end
-  end
-
   @doc """
   Wraps the argument in a list.
   If the argument is already a list, returns the list.
@@ -339,7 +285,7 @@ defmodule List do
       ["hello"]
 
       iex> List.wrap([1, 2, 3])
-      [1, 2, 3]
+      [1,2,3]
 
       iex> List.wrap(nil)
       []
@@ -475,7 +421,7 @@ defmodule List do
       iex> List.delete_at([1, 2, 3], 0)
       [2, 3]
 
-      iex> List.delete_at([1, 2, 3], 10)
+      iex List.delete_at([1, 2, 3], 10)
       [1, 2, 3]
 
       iex> List.delete_at([1, 2, 3], -1)
@@ -492,9 +438,9 @@ defmodule List do
   end
 
   @doc """
-  Converts a charlist to an atom.
+  Converts a char list to an atom.
 
-  Currently Elixir does not support conversions from charlists
+  Currently Elixir does not support conversions from char lists
   which contains Unicode codepoints greater than 0xFF.
 
   Inlined by the compiler.
@@ -505,37 +451,26 @@ defmodule List do
       :elixir
 
   """
-  @spec to_atom(charlist) :: atom
-  def to_atom(charlist) do
-    :erlang.list_to_atom(charlist)
+  @spec to_atom(char_list) :: atom
+  def to_atom(char_list) do
+    :erlang.list_to_atom(char_list)
   end
 
   @doc """
-  Converts a charlist to an existing atom. Raises an `ArgumentError`
-  if the atom does not exist.
+  Converts a char list to an existing atom.
 
-  Currently Elixir does not support conversions from charlists
+  Currently Elixir does not support conversions from char lists
   which contains Unicode codepoints greater than 0xFF.
 
   Inlined by the compiler.
-
-  ## Examples
-
-      iex> _ = :my_atom
-      iex> List.to_existing_atom('my_atom')
-      :my_atom
-
-      iex> List.to_existing_atom('this_atom_will_never_exist')
-      ** (ArgumentError) argument error
-
   """
-  @spec to_existing_atom(charlist) :: atom
-  def to_existing_atom(charlist) do
-    :erlang.list_to_existing_atom(charlist)
+  @spec to_existing_atom(char_list) :: atom
+  def to_existing_atom(char_list) do
+    :erlang.list_to_existing_atom(char_list)
   end
 
   @doc """
-  Returns the float whose text representation is `charlist`.
+  Returns the float whose text representation is `char_list`.
 
   Inlined by the compiler.
 
@@ -545,13 +480,13 @@ defmodule List do
       2.2017764
 
   """
-  @spec to_float(charlist) :: float
-  def to_float(charlist) do
-    :erlang.list_to_float(charlist)
+  @spec to_float(char_list) :: float
+  def to_float(char_list) do
+    :erlang.list_to_float(char_list)
   end
 
   @doc """
-  Returns an integer whose text representation is `charlist`.
+  Returns an integer whose text representation is `char_list`.
 
   Inlined by the compiler.
 
@@ -561,13 +496,13 @@ defmodule List do
       123
 
   """
-  @spec to_integer(charlist) :: integer
-  def to_integer(charlist) do
-    :erlang.list_to_integer(charlist)
+  @spec to_integer(char_list) :: integer
+  def to_integer(char_list) do
+    :erlang.list_to_integer(char_list)
   end
 
   @doc """
-  Returns an integer whose text representation is `charlist` in base `base`.
+  Returns an integer whose text representation is `char_list` in base `base`.
 
   Inlined by the compiler.
 
@@ -577,9 +512,9 @@ defmodule List do
       1023
 
   """
-  @spec to_integer(charlist, 2..36) :: integer
-  def to_integer(charlist, base) do
-    :erlang.list_to_integer(charlist, base)
+  @spec to_integer(char_list, 2..36) :: integer
+  def to_integer(char_list, base) do
+    :erlang.list_to_integer(char_list, base)
   end
 
   @doc """
@@ -602,9 +537,9 @@ defmodule List do
   Converts a list of integers representing codepoints, lists or
   strings into a string.
 
-  Notice that this function expects a list of integers representing
+  Notice that this function expect a list of integer representing
   UTF-8 codepoints. If you have a list of bytes, you must instead use
-  the [`:binary` module](http://www.erlang.org/doc/man/binary.html).
+  [the `:binary` module](http://erlang.org/doc/man/binary.html).
 
   ## Examples
 
@@ -617,24 +552,7 @@ defmodule List do
   """
   @spec to_string(:unicode.charlist) :: String.t
   def to_string(list) when is_list(list) do
-    try do
-      :unicode.characters_to_binary(list)
-    rescue
-      ArgumentError ->
-        raise ArgumentError, """
-        cannot convert the given list to a string.
-
-        To be converted to a string, a list must contain only:
-
-          * strings
-          * integers representing Unicode codepoints
-          * or a list containing one of these three elements
-
-        Please check the given list or call inspect/1 to get the list representation, got:
-
-        #{inspect list}
-        """
-    else
+    case :unicode.characters_to_binary(list) do
       result when is_binary(result) ->
         result
 
@@ -658,40 +576,40 @@ defmodule List do
     list
   end
 
-  defp do_replace_at([_old | rest], 0, value) do
-    [value | rest]
+  defp do_replace_at([_old|rest], 0, value) do
+    [ value | rest ]
   end
 
-  defp do_replace_at([h | t], index, value) do
-    [h | do_replace_at(t, index - 1, value)]
+  defp do_replace_at([h|t], index, value) do
+    [ h | do_replace_at(t, index - 1, value) ]
   end
 
   # insert_at
 
   defp do_insert_at([], _index, value) do
-    [value]
+    [ value ]
   end
 
   defp do_insert_at(list, index, value) when index <= 0 do
-    [value | list]
+    [ value | list ]
   end
 
-  defp do_insert_at([h | t], index, value) do
-    [h | do_insert_at(t, index - 1, value)]
+  defp do_insert_at([h|t], index, value) do
+    [ h | do_insert_at(t, index - 1, value) ]
   end
 
   # update_at
 
-  defp do_update_at([value | list], 0, fun) do
-    [fun.(value) | list]
+  defp do_update_at([value|list], 0, fun) do
+    [ fun.(value) | list ]
   end
 
   defp do_update_at(list, index, _fun) when index < 0 do
     list
   end
 
-  defp do_update_at([h | t], index, fun) do
-    [h | do_update_at(t, index - 1, fun)]
+  defp do_update_at([h|t], index, fun) do
+    [ h | do_update_at(t, index - 1, fun) ]
   end
 
   defp do_update_at([], _index, _fun) do
@@ -704,7 +622,7 @@ defmodule List do
     []
   end
 
-  defp do_delete_at([_ | t], 0) do
+  defp do_delete_at([_|t], 0) do
     t
   end
 
@@ -712,18 +630,19 @@ defmodule List do
     list
   end
 
-  defp do_delete_at([h | t], index) do
-    [h | do_delete_at(t, index - 1)]
+  defp do_delete_at([h|t], index) do
+    [h | do_delete_at(t, index-1)]
   end
 
   # zip
 
   defp do_zip(list, acc) do
     converter = fn x, acc -> do_zip_each(to_list(x), acc) end
-    case :lists.mapfoldl(converter, [], list) do
-      {_, nil} -> :lists.reverse(acc)
-      {mlist, heads} ->
-        do_zip(mlist, [to_tuple(:lists.reverse(heads)) | acc])
+    {mlist, heads} = :lists.mapfoldl converter, [], list
+
+    case heads do
+      nil -> :lists.reverse acc
+      _   -> do_zip mlist, [:erlang.list_to_tuple(:lists.reverse(heads))|acc]
     end
   end
 
@@ -731,8 +650,8 @@ defmodule List do
     {nil, nil}
   end
 
-  defp do_zip_each([h | t], acc) do
-    {t, [h | acc]}
+  defp do_zip_each([h|t], acc) do
+    {t, [h|acc]}
   end
 
   defp do_zip_each([], _) do

lib/elixir/lib/list/chars.ex

@@ -3,54 +3,54 @@ defprotocol List.Chars do
   The List.Chars protocol is responsible for
   converting a structure to a list (only if applicable).
   The only function required to be implemented is
-  `to_charlist` which does the conversion.
+  `to_char_list` which does the conversion.
 
-  The `to_charlist` function automatically imported
+  The `to_char_list` function automatically imported
   by Kernel invokes this protocol.
   """
 
-  def to_charlist(term)
-
-  # TODO: Deprecate by v1.5
-  @doc false
-  Kernel.def to_char_list(term) do
-    __MODULE__.to_charlist(term)
-  end
+  def to_char_list(thing)
 end
 
 defimpl List.Chars, for: Atom do
-  def to_charlist(atom), do: Atom.to_charlist(atom)
+  def to_char_list(atom), do: Atom.to_char_list(atom)
 end
 
 defimpl List.Chars, for: BitString do
   @doc """
-  Returns the given binary `term` converted to a charlist.
+  Returns the given binary converted to a char list.
   """
-  def to_charlist(term) when is_binary(term) do
-    String.to_charlist(term)
+  def to_char_list(thing) when is_binary(thing) do
+    String.to_char_list(thing)
   end
 
-  def to_charlist(term) do
+  def to_char_list(thing) do
     raise Protocol.UndefinedError,
              protocol: @protocol,
-                value: term,
-          description: "cannot convert a bitstring to a charlist"
+                value: thing,
+          description: "cannot convert a bitstring to a char list"
   end
 end
 
 defimpl List.Chars, for: List do
-  # Note that same inlining is used for the rewrite rule.
-  def to_charlist(list), do: list
+  def to_char_list(list), do: list
 end
 
 defimpl List.Chars, for: Integer do
-  def to_charlist(term) do
-    Integer.to_charlist(term)
+  def to_char_list(thing) do
+    Integer.to_char_list(thing)
   end
 end
 
 defimpl List.Chars, for: Float do
-  def to_charlist(term) do
-    :io_lib_format.fwrite_g(term)
+  @digits 20
+  @limit  :math.pow(10, @digits)
+
+  def to_char_list(thing) when thing > @limit do
+    Float.to_char_list(thing, scientific: @digits)
+  end
+
+  def to_char_list(thing) do
+    Float.to_char_list(thing, compact: true, decimals: @digits)
   end
 end

lib/elixir/lib/macro.ex

@@ -1,62 +1,14 @@
 import Kernel, except: [to_string: 1]
 
 defmodule Macro do
-  @moduledoc ~S"""
+  @moduledoc """
   Conveniences for working with macros.
-
-  ## Custom Sigils
-
-  To create a custom sigil, define a function with the name
-  `sigil_{identifier}` that takes two arguments. The first argument will be
-  the string, the second will be a charlist containing any modifiers. If the
-  sigil is lower case (such as `sigil_x`) then the string argument will allow
-  interpolation. If the sigil is upper case (such as `sigil_X`) then the string
-  will not be interpolated.
-
-  Valid modifiers include only lower and upper case letters. Other characters
-  will cause a syntax error.
-
-  The module containing the custom sigil must be imported before the sigil
-  syntax can be used.
-
-  ### Examples
-
-      defmodule MySigils do
-        defmacro sigil_x(term, [?r]) do
-          quote do
-            unquote(term) |> String.reverse()
-          end
-        end
-        defmacro sigil_x(term, _modifiers) do
-          term
-        end
-        defmacro sigil_X(term, [?r]) do
-          quote do
-            unquote(term) |> String.reverse()
-          end
-        end
-        defmacro sigil_X(term, _modifiers) do
-          term
-        end
-      end
-
-      import MySigils
-
-      ~x(with #{"inter" <> "polation"})
-      #=>"with interpolation"
-
-      ~x(with #{"inter" <> "polation"})r
-      #=>"noitalopretni htiw"
-
-      ~X(without #{"interpolation"})
-      #=>"without \#{"interpolation"}"
-
-      ~X(without #{"interpolation"})r
-      #=>"}\"noitalopretni\"{# tuohtiw"
   """
 
   @typedoc "Abstract Syntax Tree (AST)"
   @type t :: expr | {t, t} | atom | number | binary | pid | fun | [t]
+
+  @typedoc "Expr node (remaining ones are literals)"
   @type expr :: {expr | atom, Keyword.t, atom | [t]}
 
   @binary_ops [:===, :!==,
@@ -89,11 +41,12 @@ defmodule Macro do
       o when o in [:==, :!=, :=~, :===, :!==] -> {:left, 150}
       o when o in [:<, :<=, :>=, :>]          -> {:left, 160}
       o when o in [:|>, :<<<, :>>>, :<~, :~>,
-                :<<~, :~>>, :<~>, :<|>, :^^^] -> {:left, 170}
+                   :<<~, :~>>, :<~>, :<|>]    -> {:left, 170}
       :in                                     -> {:left, 180}
       o when o in [:++, :--, :.., :<>]        -> {:right, 200}
       o when o in [:+, :-]                    -> {:left, 210}
       o when o in [:*, :/]                    -> {:left, 220}
+      :^^^                                    -> {:left, 250}
       :.                                      -> {:left, 310}
     end
   end
@@ -101,30 +54,7 @@ defmodule Macro do
   @doc """
   Breaks a pipeline expression into a list.
 
-  The AST for a pipeline (a sequence of applications of `|>`) is similar to the
-  AST of a sequence of binary operators or function applications: the top-level
-  expression is the right-most `:|>` (which is the last one to be executed), and
-  its left-hand and right-hand sides are its arguments:
-
-      quote do: 100 |> div(5) |> div(2)
-      #=> {:|>, _, [arg1, arg2]}
-
-  In the example above, the `|>` pipe is the right-most pipe; `arg1` is the AST
-  for `100 |> div(5)`, and `arg2` is the AST for `div(2)`.
-
-  It's often useful to have the AST for such a pipeline as a list of function
-  applications. This function does exactly that:
-
-      Macro.unpipe(quote do: 100 |> div(5) |> div(2))
-      #=> [{100, 0}, {{:div, [], [5]}, 0}, {{:div, [], [2]}, 0}]
-
-  We get a list that follows the pipeline directly: first the `100`, then the
-  `div(5)` (more precisely, its AST), then `div(2)`. The `0` as the second
-  element of the tuples is the position of the previous element in the pipeline
-  inside the current function application: `{{:div, [], [5]}, 0}` means that the
-  previous element (`100`) will be inserted as the 0th (first) argument to the
-  `div/2` function, so that the AST for that function will become `{:div, [],
-  [100, 5]}` (`div(100, 5)`).
+  Raises if the pipeline is ill-formed.
   """
   @spec unpipe(Macro.t) :: [Macro.t]
   def unpipe(expr) do
@@ -136,7 +66,7 @@ defmodule Macro do
   end
 
   defp unpipe(other, acc) do
-    [{other, 0} | acc]
+    [{other, 0}|acc]
   end
 
   @doc """
@@ -146,32 +76,7 @@ defmodule Macro do
   def pipe(expr, call_args, position)
 
   def pipe(expr, {:&, _, _} = call_args, _integer) do
-    raise ArgumentError, bad_pipe(expr, call_args)
-  end
-
-  def pipe(expr, {tuple_or_map, _, _} = call_args, _integer) when tuple_or_map in [:{}, :%{}] do
-    raise ArgumentError, bad_pipe(expr, call_args)
-  end
-
-  # Without this, `Macro |> Env == Macro.Env`.
-  def pipe(expr, {:__aliases__, _, _} = call_args, _integer) do
-    raise ArgumentError, bad_pipe(expr, call_args)
-  end
-
-  def pipe(expr, {call, _, [_, _]} = call_args, _integer)
-      when call in unquote(@binary_ops) do
-    raise ArgumentError, "cannot pipe #{to_string expr} into #{to_string call_args}, " <>
-                         "the #{to_string call} operator can only take two arguments"
-  end
-
-  # {:fn, _, _} is what we get when we pipe into an anonymous function without
-  # calling it, e.g., `:foo |> (fn x -> x end)`.
-  def pipe(expr, {:fn, _, _}, _integer) do
-    expr_str = to_string(expr)
-    raise ArgumentError,
-      "cannot pipe #{expr_str} into an anonymous function without" <>
-      " calling the function; use something like (fn ... end).() or" <>
-      " define the anonymous function as a regular private function"
+    bad_pipe(expr, call_args)
   end
 
   def pipe(expr, {call, line, atom}, integer) when is_atom(atom) do
@@ -183,24 +88,18 @@ defmodule Macro do
   end
 
   def pipe(expr, call_args, _integer) do
-    raise ArgumentError, bad_pipe(expr, call_args)
+    bad_pipe(expr, call_args)
   end
 
   defp bad_pipe(expr, call_args) do
-    "cannot pipe #{to_string expr} into #{to_string call_args}, " <>
-    "can only pipe into local calls foo(), remote calls Foo.bar() or anonymous functions calls foo.()"
+    raise ArgumentError, "cannot pipe #{to_string expr} into #{to_string call_args}, " <>
+      "can only pipe into local calls foo(), remote calls Foo.bar() or anonymous functions calls foo.()"
   end
 
-  @doc false
-  def pipe_warning({call, _, _}) when call in unquote(@unary_ops) do
-    "piping into a unary operator is deprecated. You could use e.g. Kernel.+(5) instead of +5"
-  end
-  def pipe_warning(_), do: nil
-
   @doc """
   Applies the given function to the node metadata if it contains one.
 
-  This is often useful when used with `Macro.prewalk/2` to remove
+  This is often useful when used with `Macro.prewalk/1` to remove
   information like lines and hygienic counters from the expression
   for either storage or comparison.
 
@@ -224,7 +123,7 @@ defmodule Macro do
   end
 
   @doc """
-  Generates an AST node representing the variable given
+  Genrates a AST node representing the variable given
   by the atoms `var` and `context`.
 
   ## Examples
@@ -248,56 +147,6 @@ defmodule Macro do
     {var, [], context}
   end
 
-  @doc """
-  Performs a depth-first traversal of quoted expressions
-  using an accumulator.
-  """
-  @spec traverse(t, any, (t, any -> {t, any}), (t, any -> {t, any})) :: {t, any}
-  def traverse(ast, acc, pre, post) when is_function(pre, 2) and is_function(post, 2) do
-    {ast, acc} = pre.(ast, acc)
-    do_traverse(ast, acc, pre, post)
-  end
-
-  defp do_traverse({form, meta, args}, acc, pre, post) when is_atom(form) do
-    {args, acc} = do_traverse_args(args, acc, pre, post)
-    post.({form, meta, args}, acc)
-  end
-
-  defp do_traverse({form, meta, args}, acc, pre, post) do
-    {form, acc} = pre.(form, acc)
-    {form, acc} = do_traverse(form, acc, pre, post)
-    {args, acc} = do_traverse_args(args, acc, pre, post)
-    post.({form, meta, args}, acc)
-  end
-
-  defp do_traverse({left, right}, acc, pre, post) do
-    {left, acc} = pre.(left, acc)
-    {left, acc} = do_traverse(left, acc, pre, post)
-    {right, acc} = pre.(right, acc)
-    {right, acc} = do_traverse(right, acc, pre, post)
-    post.({left, right}, acc)
-  end
-
-  defp do_traverse(list, acc, pre, post) when is_list(list) do
-    {list, acc} = do_traverse_args(list, acc, pre, post)
-    post.(list, acc)
-  end
-
-  defp do_traverse(x, acc, _pre, post) do
-    post.(x, acc)
-  end
-
-  defp do_traverse_args(args, acc, _pre, _post) when is_atom(args) do
-    {args, acc}
-  end
-
-  defp do_traverse_args(args, acc, pre, post) when is_list(args) do
-    Enum.map_reduce(args, acc, fn x, acc ->
-      {x, acc} = pre.(x, acc)
-      do_traverse(x, acc, pre, post)
-    end)
-  end
-
   @doc """
   Performs a depth-first, pre-order traversal of quoted expressions.
   """
@@ -312,7 +161,43 @@ defmodule Macro do
   """
   @spec prewalk(t, any, (t, any -> {t, any})) :: {t, any}
   def prewalk(ast, acc, fun) when is_function(fun, 2) do
-    traverse(ast, acc, fun, fn x, a -> {x, a} end)
+    {ast, acc} = fun.(ast, acc)
+    do_prewalk(ast, acc, fun)
+  end
+
+  defp do_prewalk({form, meta, args}, acc, fun) do
+    unless is_atom(form) do
+      {form, acc} = fun.(form, acc)
+      {form, acc} = do_prewalk(form, acc, fun)
+    end
+
+    unless is_atom(args) do
+      {args, acc} = Enum.map_reduce(args, acc, fn x, acc ->
+        {x, acc} = fun.(x, acc)
+        do_prewalk(x, acc, fun)
+      end)
+    end
+
+    {{form, meta, args}, acc}
+  end
+
+  defp do_prewalk({left, right}, acc, fun) do
+    {left, acc} = fun.(left, acc)
+    {left, acc} = do_prewalk(left, acc, fun)
+    {right, acc} = fun.(right, acc)
+    {right, acc} = do_prewalk(right, acc, fun)
+    {{left, right}, acc}
+  end
+
+  defp do_prewalk(list, acc, fun) when is_list(list) do
+    Enum.map_reduce(list, acc, fn x, acc ->
+      {x, acc} = fun.(x, acc)
+      do_prewalk(x, acc, fun)
+    end)
+  end
+
+  defp do_prewalk(x, acc, _fun) do
+    {x, acc}
   end
 
   @doc """
@@ -329,7 +214,34 @@ defmodule Macro do
   """
   @spec postwalk(t, any, (t, any -> {t, any})) :: {t, any}
   def postwalk(ast, acc, fun) when is_function(fun, 2) do
-    traverse(ast, acc, fn x, a -> {x, a} end, fun)
+    do_postwalk(ast, acc, fun)
+  end
+
+  defp do_postwalk({form, meta, args}, acc, fun) do
+    unless is_atom(form) do
+      {form, acc} = do_postwalk(form, acc, fun)
+    end
+
+    unless is_atom(args) do
+      {args, acc} = Enum.map_reduce(args, acc, &do_postwalk(&1, &2, fun))
+    end
+
+    fun.({form, meta, args}, acc)
+  end
+
+  defp do_postwalk({left, right}, acc, fun) do
+    {left, acc} = do_postwalk(left, acc, fun)
+    {right, acc} = do_postwalk(right, acc, fun)
+    fun.({left, right}, acc)
+  end
+
+  defp do_postwalk(list, acc, fun) when is_list(list) do
+    {list, acc} = Enum.map_reduce(list, acc, &do_postwalk(&1, &2, fun))
+    fun.(list, acc)
+  end
+
+  defp do_postwalk(x, acc, fun) do
+    fun.(x, acc)
   end
 
   @doc """
@@ -340,25 +252,23 @@ defmodule Macro do
 
   ## Examples
 
-      iex> Macro.decompose_call(quote(do: foo))
+      iex> Macro.decompose_call(quote do: foo)
       {:foo, []}
 
-      iex> Macro.decompose_call(quote(do: foo()))
+      iex> Macro.decompose_call(quote do: foo())
       {:foo, []}
 
-      iex> Macro.decompose_call(quote(do: foo(1, 2, 3)))
+      iex> Macro.decompose_call(quote do: foo(1, 2, 3))
       {:foo, [1, 2, 3]}
 
-      iex> Macro.decompose_call(quote(do: Elixir.M.foo(1, 2, 3)))
+      iex> Macro.decompose_call(quote do: Elixir.M.foo(1, 2, 3))
       {{:__aliases__, [], [:Elixir, :M]}, :foo, [1, 2, 3]}
 
-      iex> Macro.decompose_call(quote(do: 42))
+      iex> Macro.decompose_call(quote do: 42)
       :error
 
   """
   @spec decompose_call(Macro.t) :: {atom, [Macro.t]} | {Macro.t, atom, [Macro.t]} | :error
-  def decompose_call(ast)
-
   def decompose_call({{:., _, [remote, function]}, _, args}) when is_tuple(remote) or is_atom(remote),
     do: {remote, function, args}
 
@@ -376,7 +286,7 @@ defmodule Macro do
   into a syntax tree.
 
   One may pass `unquote: true` to `escape/2`
-  which leaves `unquote/1` statements unescaped, effectively
+  which leaves `unquote` statements unescaped, effectively
   unquoting the contents on escape.
 
   ## Examples
@@ -400,24 +310,8 @@ defmodule Macro do
   @doc """
   Validates the given expressions are valid quoted expressions.
 
-  Checks the `type:Macro.t` for the specification of a valid
+  Check the `type:Macro.t` for the specification of a valid
   quoted expression.
-
-  It returns `:ok` if the expression is valid. Otherwise it returns a tuple in the form of
-  `{:error, remainder}` where `remainder` is the invalid part of the quoted expression.
-
-  ## Examples
-
-      iex> Macro.validate({:two_element, :tuple})
-      :ok
-      iex> Macro.validate({:three, :element, :tuple})
-      {:error, {:three, :element, :tuple}}
-
-      iex> Macro.validate([1, 2, 3])
-      :ok
-      iex> Macro.validate([1, 2, 3, {4}])
-      {:error, {4}}
-
   """
   @spec validate(term) :: :ok | {:error, term}
   def validate(expr) do
@@ -448,16 +342,15 @@ defmodule Macro do
   defp find_invalid(other), do: {:error, other}
 
   @doc ~S"""
-  Unescapes the given chars.
+  Unescape the given chars.
 
   This is the unescaping behaviour used by default in Elixir
   single- and double-quoted strings. Check `unescape_string/2`
   for information on how to customize the escaping map.
 
   In this setup, Elixir will escape the following: `\0`, `\a`, `\b`,
-  `\d`, `\e`, `\f`, `\n`, `\r`, `\s`, `\t` and `\v`. Bytes can be
-  given as hexadecimals via `\xNN` and Unicode Codepoints as
-  `\uNNNN` escapes.
+  `\d`, `\e`, `\f`, `\n`, `\r`, `\s`, `\t` and `\v`. Hexadecimals
+  are also supported via `\xNN` and `\x{NN...}` syntax.
 
   This function is commonly used on sigil implementations
   (like `~r`, `~s` and others) which receive a raw, unescaped
@@ -477,7 +370,7 @@ defmodule Macro do
   end
 
   @doc ~S"""
-  Unescapes the given chars according to the map given.
+  Unescape the given chars according to the map given.
 
   Check `unescape_string/1` if you want to use the same map
   as Elixir single- and double-quoted strings.
@@ -500,15 +393,13 @@ defmodule Macro do
       def unescape_map(?t), do: ?\t
       def unescape_map(?v), do: ?\v
       def unescape_map(?x), do: true
-      def unescape_map(?u), do: true
       def unescape_map(e),  do: e
 
   If the `unescape_map` function returns `false`. The char is
-  not escaped and `\` is kept in the charlist.
+  not escaped and `\` is kept in the char list.
 
-  Hexadecimals and Unicode codepoints will be escaped if the map
-  function returns `true` for `?x`. Unicode codepoints if the map
-  function returns `true` for `?u`.
+  Hexadecimals will be escaped if the map function returns `true`
+  for `?x`.
 
   ## Examples
 
@@ -523,7 +414,7 @@ defmodule Macro do
   end
 
   @doc """
-  Unescapes the given tokens according to the default map.
+  Unescape the given tokens according to the default map.
 
   Check `unescape_string/1` and `unescape_string/2` for more
   information about unescaping.
@@ -539,7 +430,7 @@ defmodule Macro do
   end
 
   @doc """
-  Unescapes the given tokens according to the given map.
+  Unescape the given tokens according to the given map.
 
   Check `unescape_tokens/1` and `unescape_string/2` for more information.
   """
@@ -553,7 +444,7 @@ defmodule Macro do
 
   ## Examples
 
-      iex> Macro.to_string(quote(do: foo.bar(1, 2, 3)))
+      iex> Macro.to_string(quote do: foo.bar(1, 2, 3))
       "foo.bar(1, 2, 3)"
 
   """
@@ -582,20 +473,11 @@ defmodule Macro do
   end
 
   # Bits containers
-  def to_string({:<<>>, _, parts} = ast, fun) do
-    if interpolated?(ast) do
-      fun.(ast, interpolate(ast, fun))
-    else
-      result = Enum.map_join(parts, ", ", fn(part) ->
-        str = bitpart_to_string(part, fun)
-        if :binary.first(str) == ?< or :binary.last(str) == ?> do
-          "(" <> str <> ")"
-        else
-          str
-        end
-      end)
-      fun.(ast, "<<" <> result <> ">>")
-    end
+  def to_string({:<<>>, _, args} = ast, fun) do
+    fun.(ast, case Enum.map_join(args, ", ", &to_string(&1, fun)) do
+      "<" <> rest -> "<< <" <> rest  <> " >>"
+      rest -> "<<" <> rest <> ">>"
+    end)
   end
 
   # Tuple containers
@@ -631,25 +513,18 @@ defmodule Macro do
     fun.(ast, "fn\n  " <> block <> "\nend")
   end
 
-  # Ranges
-  def to_string({:.., _, args} = ast, fun) do
-    range = Enum.map_join(args, "..", &to_string(&1, fun))
-    fun.(ast, range)
-  end
-
   # left -> right
-  def to_string([{:->, _, _} | _] = ast, fun) do
+  def to_string([{:->, _, _}|_] = ast, fun) do
     fun.(ast, "(" <> arrow_to_string(ast, fun, true) <> ")")
   end
 
   # left when right
   def to_string({:when, _, [left, right]} = ast, fun) do
-    right =
-      if right != [] and Keyword.keyword?(right) do
-        kw_list_to_string(right, fun)
-      else
-        fun.(ast, op_to_string(right, fun, :when, :right))
-      end
+    if right != [] and Keyword.keyword?(right) do
+      right = kw_list_to_string(right, fun)
+    else
+      right = fun.(ast, op_to_string(right, fun, :when, :right))
+    end
 
     fun.(ast, op_to_string(left, fun, :when, :left) <> " when " <> right)
   end
@@ -665,21 +540,6 @@ defmodule Macro do
     fun.(ast, "(" <> Enum.map_join(left, ", ", &to_string(&1, fun)) <> ") when " <> to_string(right, fun))
   end
 
-  # Capture
-  def to_string({:&, _, [{:/, _, [{name, _, ctx}, arity]}]} = ast, fun)
-      when is_atom(name) and is_atom(ctx) and is_integer(arity) do
-    fun.(ast, "&" <> Atom.to_string(name) <> "/" <> to_string(arity, fun))
-  end
-
-  def to_string({:&, _, [{:/, _, [{{:., _, [mod, name]}, _, []}, arity]}]} = ast, fun)
-      when is_atom(name) and is_integer(arity) do
-    fun.(ast, "&" <> to_string(mod, fun) <> "." <> Atom.to_string(name) <> "/" <> to_string(arity, fun))
-  end
-
-  def to_string({:&, _, [arg]} = ast, fun) when not is_integer(arg) do
-    fun.(ast, "&(" <> to_string(arg, fun) <> ")")
-  end
-
   # Unary ops
   def to_string({unary, _, [{binary, _, [_, _]} = arg]} = ast, fun)
       when unary in unquote(@unary_ops) and binary in unquote(@binary_ops) do
@@ -695,11 +555,6 @@ defmodule Macro do
   end
 
   # Access
-  def to_string({{:., _, [Access, :get]}, _, [{op, _, _} = left, right]} = ast, fun)
-      when op in unquote(@binary_ops) do
-    fun.(ast, "(" <> to_string(left, fun) <> ")" <> to_string([right], fun))
-  end
-
   def to_string({{:., _, [Access, :get]}, _, [left, right]} = ast, fun) do
     fun.(ast, to_string(left, fun) <> to_string([right], fun))
   end
@@ -717,7 +572,7 @@ defmodule Macro do
     end
   end
 
-  # Two-element tuples
+  # Two-item tuples
   def to_string({left, right}, fun) do
     to_string({:{}, [], [left, right]}, fun)
   end
@@ -739,73 +594,23 @@ defmodule Macro do
   # All other structures
   def to_string(other, fun), do: fun.(other, inspect(other, []))
 
-  defp bitpart_to_string({:::, _, [left, right]} = ast, fun) do
-    result =
-      op_to_string(left, fun, :::, :left) <>
-      "::" <>
-      bitmods_to_string(right, fun, :::, :right)
-    fun.(ast, result)
-  end
-
-  defp bitpart_to_string(ast, fun) do
-    to_string(ast, fun)
-  end
-
-  defp bitmods_to_string({:-, _, [left, right]} = ast, fun, _, _) do
-    result =
-      bitmods_to_string(left, fun, :-, :left) <>
-      "-" <>
-      bitmods_to_string(right, fun, :-, :right)
-    fun.(ast, result)
-  end
-
-  defp bitmods_to_string(other, fun, parent_op, side) do
-    op_to_string(other, fun, parent_op, side)
-  end
-
   # Block keywords
   @kw_keywords [:do, :catch, :rescue, :after, :else]
 
-  defp kw_blocks?([{:do, _} | _] = kw) do
+  defp kw_blocks?([_|_] = kw) do
     Enum.all?(kw, &match?({x, _} when x in unquote(@kw_keywords), &1))
   end
   defp kw_blocks?(_), do: false
 
-  # Check if we have an interpolated string.
-  defp interpolated?({:<<>>, _, [_ | _] = parts}) do
-    Enum.all?(parts, fn
-      {:::, _, [{{:., _, [Kernel, :to_string]}, _, [_]},
-                {:binary, _, _}]} -> true
-      binary when is_binary(binary) -> true
-      _ -> false
-    end)
-  end
-
-  defp interpolated?(_) do
-    false
-  end
-
-  defp interpolate({:<<>>, _, parts}, fun) do
-    parts = Enum.map_join(parts, "", fn
-      {:::, _, [{{:., _, [Kernel, :to_string]}, _, [arg]}, {:binary, _, _}]} ->
-        "\#{" <> to_string(arg, fun) <> "}"
-      binary when is_binary(binary) ->
-        binary = inspect(binary, [])
-        :binary.part(binary, 1, byte_size(binary) - 2)
-    end)
-
-    <<?", parts::binary, ?">>
-  end
-
   defp module_to_string(atom, _fun) when is_atom(atom), do: inspect(atom, [])
   defp module_to_string(other, fun), do: call_to_string(other, fun)
 
-  defp sigil_call({func, _, [{:<<>>, _, _} = bin, args]} = ast, fun) when is_atom(func) and is_list(args) do
+  defp sigil_call({func, _, [{:<<>>, _, [string]}, args]} = ast, fun) when is_list(args) do
     sigil =
       case Atom.to_string(func) do
         <<"sigil_", name>> ->
           "~" <> <<name>> <>
-          interpolate(bin, fun) <>
+          fun.(string, inspect(string, [])) <>
           sigil_args(args, fun)
         _ ->
           nil
@@ -820,16 +625,10 @@ defmodule Macro do
   defp sigil_args([], _fun),   do: ""
   defp sigil_args(args, fun), do: fun.(args, List.to_string(args))
 
-  defp call_to_string(atom, _fun) when is_atom(atom),
-    do: Atom.to_string(atom)
-  defp call_to_string({:., _, [{:&, _, [val]} = arg]}, fun) when not is_integer(val),
-    do: "(" <> module_to_string(arg, fun) <> ")."
-  defp call_to_string({:., _, [arg]}, fun),
-    do: module_to_string(arg, fun) <> "."
-  defp call_to_string({:., _, [left, right]}, fun),
-    do: module_to_string(left, fun) <> "." <> call_to_string(right, fun)
-  defp call_to_string(other, fun),
-    do: to_string(other, fun)
+  defp call_to_string(atom, _fun) when is_atom(atom), do: Atom.to_string(atom)
+  defp call_to_string({:., _, [arg]}, fun),           do: module_to_string(arg, fun) <> "."
+  defp call_to_string({:., _, [left, right]}, fun),   do: module_to_string(left, fun) <> "." <> call_to_string(right, fun)
+  defp call_to_string(other, fun),                    do: to_string(other, fun)
 
   defp call_to_string_with_args(target, args, fun) do
     target = call_to_string(target, fun)
@@ -841,12 +640,9 @@ defmodule Macro do
     {list, last} = :elixir_utils.split_last(args)
 
     if last != [] and Keyword.keyword?(last) do
-      prefix =
-        case list do
-          [] -> ""
-          _  -> Enum.map_join(list, ", ", &to_string(&1, fun)) <> ", "
-        end
-      prefix <> kw_list_to_string(last, fun)
+      args = Enum.map_join(list, ", ", &to_string(&1, fun))
+      if list != [], do: args = args <> ", "
+      args <> kw_list_to_string(last, fun)
     else
       Enum.map_join(args, ", ", &to_string(&1, fun))
     end
@@ -866,7 +662,7 @@ defmodule Macro do
     Atom.to_string(key) <> "\n  " <> block <> "\n"
   end
 
-  defp block_to_string([{:->, _, _} | _] = block, fun) do
+  defp block_to_string([{:->, _, _}|_] = block, fun) do
     Enum.map_join(block, "\n", fn({:->, _, [left, right]}) ->
       left = comma_join_or_empty_paren(left, fun, false)
       left <> "->\n  " <> adjust_new_lines block_to_string(right, fun), "\n  "
@@ -976,7 +772,7 @@ defmodule Macro do
   Consider the implementation below:
 
       defmacro defmodule_with_length(name, do: block) do
-        length = length(Atom.to_charlist(name))
+        length = length(Atom.to_char_list(name))
 
         quote do
           defmodule unquote(name) do
@@ -1016,7 +812,7 @@ defmodule Macro do
 
       defmacro defmodule_with_length(name, do: block) do
         expanded = Macro.expand(name, __CALLER__)
-        length   = length(Atom.to_charlist(expanded))
+        length   = length(Atom.to_char_list(expanded))
 
         quote do
           defmodule unquote(name) do
@@ -1034,15 +830,15 @@ defmodule Macro do
   defp do_expand_once({:__aliases__, _, _} = original, env) do
     case :elixir_aliases.expand(original, env.aliases, env.macro_aliases, env.lexical_tracker) do
       receiver when is_atom(receiver) ->
-        :elixir_lexical.record_remote(receiver, env.function, env.lexical_tracker)
+        :elixir_lexical.record_remote(receiver, env.lexical_tracker)
         {receiver, true}
       aliases ->
-        aliases = :lists.map(&elem(do_expand_once(&1, env), 0), aliases)
+        aliases = for alias <- aliases, do: elem(do_expand_once(alias, env), 0)
 
         case :lists.all(&is_atom/1, aliases) do
           true ->
             receiver = :elixir_aliases.concat(aliases)
-            :elixir_lexical.record_remote(receiver, env.function, env.lexical_tracker)
+            :elixir_lexical.record_remote(receiver, env.lexical_tracker)
             {receiver, true}
           false ->
             {original, false}
@@ -1050,6 +846,14 @@ defmodule Macro do
     end
   end
 
+  # Expand @ calls
+  defp do_expand_once({:@, _, [{name, _, args}]} = original, env) when is_atom(args) or args == [] do
+    case (module = env.module) && Module.open?(module) do
+      true  -> {escape(Module.get_attribute(module, name)), true}
+      false -> {original, false}
+    end
+  end
+
   # Expand pseudo-variables
   defp do_expand_once({:__MODULE__, _, atom}, env) when is_atom(atom),
     do: {env.module, true}
@@ -1098,7 +902,7 @@ defmodule Macro do
 
       case expand do
         {:ok, receiver, quoted} ->
-          next = :erlang.unique_integer()
+          next = :elixir_counter.next
           {:elixir_quote.linify_with_context_counter(0, {receiver, next}, quoted), true}
         {:ok, _receiver, _name, _args} ->
           {original, false}
@@ -1119,7 +923,7 @@ defmodule Macro do
 
         case expand do
           {:ok, receiver, quoted} ->
-            next = :erlang.unique_integer()
+            next = :elixir_counter.next
             {:elixir_quote.linify_with_context_counter(0, {receiver, next}, quoted), true}
           :error ->
             {original, false}
@@ -1135,7 +939,7 @@ defmodule Macro do
   be expanded.
 
   This function uses `expand_once/2` under the hood. Check
-  it out for more information and examples.
+  `expand_once/2` for more information and examples.
   """
   def expand(tree, env) do
     expand_until({tree, true}, env)
@@ -1148,125 +952,4 @@ defmodule Macro do
   defp expand_until({tree, false}, _env) do
     tree
   end
-
-  @doc """
-  Converts the given atom or binary to underscore format.
-
-  If an atom is given, it is assumed to be an Elixir module,
-  so it is converted to a binary and then processed.
-
-  This function was designed to underscore language identifiers/tokens,
-  that's why it belongs to the `Macro` module. Do not use it as a general
-  mechanism for underscoring strings as it does not support Unicode or
-  characters that are not valid in Elixir identifiers.
-
-  ## Examples
-
-      iex> Macro.underscore "FooBar"
-      "foo_bar"
-
-      iex> Macro.underscore "Foo.Bar"
-      "foo/bar"
-
-      iex> Macro.underscore Foo.Bar
-      "foo/bar"
-
-  In general, `underscore` can be thought of as the reverse of
-  `camelize`, however, in some cases formatting may be lost:
-
-      iex> Macro.underscore "SAPExample"
-      "sap_example"
-
-      iex> Macro.camelize "sap_example"
-      "SapExample"
-
-      iex> Macro.camelize "hello_10"
-      "Hello10"
-
-  """
-  def underscore(atom) when is_atom(atom) do
-    "Elixir." <> rest = Atom.to_string(atom)
-    underscore(rest)
-  end
-
-  def underscore(""), do: ""
-
-  def underscore(<<h, t::binary>>) do
-    <<to_lower_char(h)>> <> do_underscore(t, h)
-  end
-
-  defp do_underscore(<<h, t, rest::binary>>, _)
-      when (h >= ?A and h <= ?Z) and not (t >= ?A and t <= ?Z) and t != ?. do
-    <<?_, to_lower_char(h), t>> <> do_underscore(rest, t)
-  end
-
-  defp do_underscore(<<h, t::binary>>, prev)
-      when (h >= ?A and h <= ?Z) and not (prev >= ?A and prev <= ?Z) do
-    <<?_, to_lower_char(h)>> <> do_underscore(t, h)
-  end
-
-  defp do_underscore(<<?., t::binary>>, _) do
-    <<?/>> <> underscore(t)
-  end
-
-  defp do_underscore(<<h, t::binary>>, _) do
-    <<to_lower_char(h)>> <> do_underscore(t, h)
-  end
-
-  defp do_underscore(<<>>, _) do
-    <<>>
-  end
-
-  @doc """
-  Converts the given string to CamelCase format.
-
-  This function was designed to camelize language identifiers/tokens,
-  that's why it belongs to the `Macro` module. Do not use it as a general
-  mechanism for camelizing strings as it does not support Unicode or
-  characters that are not valid in Elixir identifiers.
-
-  ## Examples
-
-      iex> Macro.camelize "foo_bar"
-      "FooBar"
-
-  """
-  @spec camelize(String.t) :: String.t
-  def camelize(string)
-
-  def camelize(""),
-    do: ""
-
-  def camelize(<<?_, t::binary>>),
-    do: camelize(t)
-
-  def camelize(<<h, t::binary>>),
-    do: <<to_upper_char(h)>> <> do_camelize(t)
-
-  defp do_camelize(<<?_, ?_, t::binary>>),
-    do: do_camelize(<<?_, t::binary >>)
-
-  defp do_camelize(<<?_, h, t::binary>>) when h >= ?a and h <= ?z,
-    do: <<to_upper_char(h)>> <> do_camelize(t)
-
-  defp do_camelize(<<?_, h, t::binary>>) when h >= ?0 and h <= ?9,
-    do: <<h>> <> do_camelize(t)
-
-  defp do_camelize(<<?_>>),
-    do: <<>>
-
-  defp do_camelize(<<?/, t::binary>>),
-    do: <<?.>> <> camelize(t)
-
-  defp do_camelize(<<h, t::binary>>),
-    do: <<h>> <> do_camelize(t)
-
-  defp do_camelize(<<>>),
-    do: <<>>
-
-  defp to_upper_char(char) when char >= ?a and char <= ?z, do: char - 32
-  defp to_upper_char(char), do: char
-
-  defp to_lower_char(char) when char >= ?A and char <= ?Z, do: char + 32
-  defp to_lower_char(char), do: char
 end

lib/elixir/lib/macro/env.ex

@@ -24,13 +24,13 @@ defmodule Macro.Env do
     * `module` - the current module name
     * `file` - the current file name as a binary
     * `line` - the current line as an integer
-    * `function` - a tuple as `{atom, integer}`, where the first
-      element is the function name and the second its arity; returns
+    * `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
     * `context` - the context of the environment; it can be `nil`
-      (default context), inside a guard or inside a match
-    * `aliases` -  a list of two-element tuples, where the first
-      element is the aliased name and the second one the actual name
+      (default context), inside a guard or inside an assign
+    * `aliases` -  a list of two item tuples, where the first
+      item is the aliased name and the second the actual name
     * `requires` - the list of required modules
     * `functions` - a list of functions imported from each module
     * `macros` - a list of macros imported from each module
@@ -39,8 +39,8 @@ defmodule Macro.Env do
     * `vars` - a list keeping all defined variables as `{var, context}`
     * `export_vars` - a list keeping all variables to be exported in a
       construct (may be `nil`)
-    * `lexical_tracker` - PID of the lexical tracker which is responsible for
-      keeping user info
+    * `lexical_tracker` - PID of the lexical tracker which is responsible to
+      keep user info
     * `local` - the module to expand local functions to
   """
 
@@ -91,19 +91,14 @@ defmodule Macro.Env do
       context_modules: [],
       vars: [],
       export_vars: nil,
-      lexical_tracker: nil}
-  end
-
-  def __struct__(kv) do
-    Enum.reduce kv, __struct__(), fn {k, v}, acc -> :maps.update(k, v, acc) end
+      lexical_tracker: nil,
+      local: nil}
   end
 
   @doc """
   Returns a keyword list containing the file and line
   information as keys.
   """
-  @spec location(t) :: Keyword.t
-  def location(env)
   def location(%{__struct__: Macro.Env, file: file, line: line}) do
     [file: file, line: line]
   end
@@ -112,22 +107,17 @@ defmodule Macro.Env do
   Returns whether the compilation environment is currently
   inside a guard.
   """
-  @spec in_guard?(t) :: boolean
-  def in_guard?(env)
   def in_guard?(%{__struct__: Macro.Env, context: context}), do: context == :guard
 
   @doc """
   Returns whether the compilation environment is currently
   inside a match clause.
   """
-  @spec in_match?(t) :: boolean
-  def in_match?(env)
   def in_match?(%{__struct__: Macro.Env, context: context}), do: context == :match
 
   @doc """
   Returns the environment stacktrace.
   """
-  @spec stacktrace(t) :: list
   def stacktrace(%{__struct__: Macro.Env} = env) do
     cond do
       is_nil(env.module) ->

lib/elixir/lib/map.ex

@@ -1,366 +1,37 @@
 defmodule Map do
   @moduledoc """
-  A set of functions for working with maps.
+  A Dict implementation that works on maps.
 
-  Maps are key-value stores where keys can be any value and
-  are compared using the match operator (`===`). Maps can be
-  created with the `%{}` special form defined in the
-  `Kernel.SpecialForms` module.
+  Maps are key-value stores where keys are compared using
+  the match operator (`===`). Maps can be created with
+  the `%{}` special form defined in the `Kernel.SpecialForms`
+  module.
+
+  For more information about the functions in this module and
+  their APIs, please consult the `Dict` module.
   """
 
-  @type key :: any
-  @type value :: any
+  use Dict
+
+  defdelegate [keys(map), values(map), size(map), merge(map1, map2), to_list(map)], to: :maps
+
   @compile {:inline, fetch: 2, put: 3, delete: 2, has_key?: 2}
 
-  @doc """
-  Returns all keys from `map`.
-
-  ## Examples
-
-      iex> Map.keys(%{a: 1, b: 2})
-      [:a, :b]
-
-  """
-  @spec keys(map) :: [key]
-  defdelegate keys(map), to: :maps
-
-  @doc """
-  Returns all values from `map`.
-
-  ## Examples
-
-      iex> Map.values(%{a: 1, b: 2})
-      [1, 2]
-
-  """
-  @spec values(map) :: [value]
-  defdelegate values(map), to: :maps
-
-  @doc """
-  Converts `map` to a list.
-
-  ## Examples
-
-      iex> Map.to_list(%{a: 1})
-      [a: 1]
-      iex> Map.to_list(%{1 => 2})
-      [{1, 2}]
-
-  """
-  @spec to_list(map) :: [{term, term}]
-  defdelegate to_list(map), to: :maps
-
   @doc """
   Returns a new empty map.
-
-  ## Examples
-
-      iex> Map.new
-      %{}
-
   """
-  @spec new :: map
   def new, do: %{}
 
-  @doc """
-  Creates a map from an `enumerable`.
-
-  Duplicated keys are removed; the latest one prevails.
-
-  ## Examples
-
-      iex> Map.new([{:b, 1}, {:a, 2}])
-      %{a: 2, b: 1}
-      iex> Map.new([a: 1, a: 2, a: 3])
-      %{a: 3}
-
-  """
-  @spec new(Enum.t) :: map
-  def new(enumerable)
-  def new(%{__struct__: _} = struct), do: new_from_enum(struct)
-  def new(%{} = map), do: map
-  def new(enum), do: new_from_enum(enum)
-
-  defp new_from_enum(enumerable) do
-    enumerable
-    |> Enum.to_list
-    |> :maps.from_list
-  end
-
-  @doc """
-  Creates a map from an `enumerable` via the transformation function.
-
-  Duplicated keys are removed; the latest one prevails.
-
-  ## Examples
-
-      iex> Map.new([:a, :b], fn x -> {x, x} end)
-      %{a: :a, b: :b}
-
-  """
-  @spec new(Enum.t, (term -> {key, value})) :: map
-  def new(enumerable, transform) do
-    enumerable
-    |> Enum.to_list
-    |> do_new_transform(transform, [])
-  end
-
-  defp do_new_transform([], _fun, acc) do
-    acc
-    |> :lists.reverse
-    |> :maps.from_list
-  end
-  defp do_new_transform([item | rest], fun, acc) do
-    do_new_transform(rest, fun, [fun.(item) | acc])
-  end
-
-  @doc """
-  Returns whether a given `key` exists in the given `map`.
-
-  ## Examples
-
-      iex> Map.has_key?(%{a: 1}, :a)
-      true
-      iex> Map.has_key?(%{a: 1}, :b)
-      false
-
-  """
-  @spec has_key?(map, key) :: boolean
   def has_key?(map, key), do: :maps.is_key(key, map)
 
-  @doc """
-  Fetches the value for a specific `key` and returns it in a tuple.
-
-  If the `key` does not exist, returns `:error`.
-
-  ## Examples
-
-      iex> Map.fetch(%{a: 1}, :a)
-      {:ok, 1}
-      iex> Map.fetch(%{a: 1}, :b)
-      :error
-
-  """
-  @spec fetch(map, key) :: {:ok, value} | :error
   def fetch(map, key), do: :maps.find(key, map)
 
-  @doc """
-  Fetches the value for specific `key`.
-
-  If `key` does not exist, a `KeyError` is raised.
-
-  ## Examples
-
-      iex> Map.fetch!(%{a: 1}, :a)
-      1
-      iex> Map.fetch!(%{a: 1}, :b)
-      ** (KeyError) key :b not found in: %{a: 1}
-
-  """
-  @spec fetch!(map, key) :: value | no_return
-  def fetch!(map, key) do
-    case fetch(map, key) do
-      {:ok, value} -> value
-      :error -> raise KeyError, key: key, term: map
-    end
-  end
-
-  @doc """
-  Puts the given `value` under `key` unless the entry `key`
-  already exists.
-
-  ## Examples
-
-      iex> Map.put_new(%{a: 1}, :b, 2)
-      %{b: 2, a: 1}
-      iex> Map.put_new(%{a: 1, b: 2}, :a, 3)
-      %{a: 1, b: 2}
-
-  """
-  @spec put_new(map, key, value) :: map
-  def put_new(map, key, value) do
-    case has_key?(map, key) do
-      true  -> map
-      false -> put(map, key, value)
-    end
-  end
-
-  @doc """
-  Evaluates `fun` and puts the result under `key`
-  in map unless `key` is already present.
-
-  This is useful if the value is very expensive to calculate or
-  generally difficult to setup and teardown again.
-
-  ## Examples
-
-      iex> map = %{a: 1}
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   3
-      ...> end
-      iex> Map.put_new_lazy(map, :a, fun)
-      %{a: 1}
-      iex> Map.put_new_lazy(map, :b, fun)
-      %{a: 1, b: 3}
-
-  """
-  @spec put_new_lazy(map, key, (() -> value)) :: map
-  def put_new_lazy(map, key, fun) when is_function(fun, 0) do
-    case has_key?(map, key) do
-      true  -> map
-      false -> put(map, key, fun.())
-    end
-  end
-
-  @doc """
-  Takes all entries corresponding to the given keys and
-  returns them in a new map.
-
-  ## Examples
-
-      iex> Map.take(%{a: 1, b: 2, c: 3}, [:a, :c, :e])
-      %{a: 1, c: 3}
-
-  """
-  @spec take(map, Enumerable.t) :: map
-  def take(map, keys) do
-    keys
-    |> Enum.to_list
-    |> do_take(map, [])
-  end
-
-  defp do_take([], _map, acc), do: :maps.from_list(acc)
-  defp do_take([key | rest], map, acc) do
-    acc = case fetch(map, key) do
-      {:ok, value} -> [{key, value} | acc]
-      :error -> acc
-    end
-    do_take(rest, map, acc)
-  end
-
-  @doc """
-  Gets the value for a specific `key`.
-
-  If `key` does not exist, return the default value
-  (`nil` if no default value).
-
-  ## Examples
-
-      iex> Map.get(%{}, :a)
-      nil
-      iex> Map.get(%{a: 1}, :a)
-      1
-      iex> Map.get(%{a: 1}, :b)
-      nil
-      iex> Map.get(%{a: 1}, :b, 3)
-      3
-
-  """
-  @spec get(map, key) :: value
-  @spec get(map, key, value) :: value
-  def get(map, key, default \\ nil) do
-    case fetch(map, key) do
-      {:ok, value} -> value
-      :error -> default
-    end
-  end
-
-  @doc """
-  Gets the value for a specific `key`.
-
-  If `key` does not exist, lazily evaluates `fun` and returns its result.
-
-  This is useful if the default value is very expensive to calculate or
-  generally difficult to setup and teardown again.
-
-  ## Examples
-
-      iex> map = %{a: 1}
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   13
-      ...> end
-      iex> Map.get_lazy(map, :a, fun)
-      1
-      iex> Map.get_lazy(map, :b, fun)
-      13
-
-  """
-  @spec get_lazy(map, key, (() -> value)) :: value
-  def get_lazy(map, key, fun) when is_function(fun, 0) do
-    case fetch(map, key) do
-      {:ok, value} -> value
-      :error -> fun.()
-    end
-  end
-
-  @doc """
-  Puts the given `value` under `key`.
-
-  ## Examples
-
-      iex> Map.put(%{a: 1}, :b, 2)
-      %{a: 1, b: 2}
-      iex> Map.put(%{a: 1, b: 2}, :a, 3)
-      %{a: 3, b: 2}
-
-  """
-  @spec put(map, key, value) :: map
   def put(map, key, val) do
     :maps.put(key, val, map)
   end
 
-  @doc """
-  Deletes the entries in `map` for a specific `key`.
-
-  If the `key` does not exist, returns `map` unchanged.
-
-  ## Examples
-
-      iex> Map.delete(%{a: 1, b: 2}, :a)
-      %{b: 2}
-      iex> Map.delete(%{b: 2}, :a)
-      %{b: 2}
-
-  """
-  @spec delete(map, key) :: map
   def delete(map, key), do: :maps.remove(key, map)
 
-  @doc """
-  Merges two maps into one.
-
-  All keys in `map2` will be added to `map1`, overriding any existing one.
-
-  If you have a struct and you would like to merge a set of keys into the
-  struct, do not use this function, as it would merge all keys on the right
-  side into the struct, even if the key is not part of the struct. Instead,
-  use `Kernel.struct/2`.
-
-  ## Examples
-
-      iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4})
-      %{a: 3, b: 2, d: 4}
-
-  """
-  @spec merge(map, map) :: map
-  defdelegate merge(map1, map2), to: :maps
-
-  @doc """
-  Merges two maps into one.
-
-  All keys in `map2` will be added to `map1`. The given function will
-  be invoked with the key, value1 and value2 to solve conflicts.
-
-  ## Examples
-
-      iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4}, fn _k, v1, v2 ->
-      ...>   v1 + v2
-      ...> end)
-      %{a: 4, b: 2, d: 4}
-
-  """
-  @spec merge(map, map, (key, value, value -> value)) :: map
   def merge(map1, map2, callback) do
     :maps.fold fn k, v2, acc ->
       update(acc, k, v2, fn(v1) -> callback.(k, v1, v2) end)
@@ -368,250 +39,7 @@ defmodule Map do
   end
 
   @doc """
-  Updates the `key` in `map` with the given function.
-
-  If the `key` does not exist, inserts the given `initial` value.
-
-  ## Examples
-
-      iex> Map.update(%{a: 1}, :a, 13, &(&1 * 2))
-      %{a: 2}
-      iex> Map.update(%{a: 1}, :b, 11, &(&1 * 2))
-      %{a: 1, b: 11}
-
-  """
-  @spec update(map, key, value, (value -> value)) :: map
-  def update(map, key, initial, fun) do
-    case fetch(map, key) do
-      {:ok, value} ->
-        put(map, key, fun.(value))
-      :error ->
-        put(map, key, initial)
-    end
-  end
-
-  @doc """
-  Returns and removes the value associated with `key` in `map`.
-
-  ## Examples
-
-      iex> Map.pop(%{a: 1}, :a)
-      {1, %{}}
-      iex> Map.pop(%{a: 1}, :b)
-      {nil, %{a: 1}}
-      iex> Map.pop(%{a: 1}, :b, 3)
-      {3, %{a: 1}}
-
-  """
-  @spec pop(map, key, value) :: {value, map}
-  def pop(map, key, default \\ nil) do
-    case map do
-      %{^key => value} -> {value, delete(map, key)}
-      %{} -> {default, map}
-    end
-  end
-
-  @doc """
-  Lazily returns and removes the value associated with `key` in `map`.
-
-  This is useful if the default value is very expensive to calculate or
-  generally difficult to setup and teardown again.
-
-  ## Examples
-
-      iex> map = %{a: 1}
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   13
-      ...> end
-      iex> Map.pop_lazy(map, :a, fun)
-      {1, %{}}
-      iex> Map.pop_lazy(map, :b, fun)
-      {13, %{a: 1}}
-
-  """
-  @spec pop_lazy(map, key, (() -> value)) :: {value, map}
-  def pop_lazy(map, key, fun) when is_function(fun, 0) do
-    case fetch(map, key) do
-      {:ok, value} -> {value, delete(map, key)}
-      :error -> {fun.(), map}
-    end
-  end
-
-  @doc """
-  Drops the given `keys` from `map`.
-
-  ## Examples
-
-      iex> Map.drop(%{a: 1, b: 2, c: 3}, [:b, :d])
-      %{a: 1, c: 3}
-
-  """
-  @spec drop(map, Enumerable.t) :: map
-  def drop(map, keys) do
-    keys
-    |> Enum.to_list
-    |> drop_list(map)
-  end
-
-  defp drop_list([], acc), do: acc
-  defp drop_list([key | rest], acc) do
-    drop_list(rest, Map.delete(acc, key))
-  end
-
-  @doc """
-  Takes all entries corresponding to the given `keys` and extracts them into a
-  separate `map`.
-
-  Returns a tuple with the new map and the old map with removed keys.
-
-  Keys for which there are no entries in `map` are ignored.
-
-  ## Examples
-
-      iex> Map.split(%{a: 1, b: 2, c: 3}, [:a, :c, :e])
-      {%{a: 1, c: 3}, %{b: 2}}
-
-  """
-  @spec split(map, Enumerable.t) :: {map, map}
-  def split(map, keys) do
-    keys
-    |> Enum.to_list
-    |> do_split([], map)
-  end
-
-  defp do_split([], inc, exc) do
-    {:maps.from_list(inc), exc}
-  end
-  defp do_split([key | rest], inc, exc) do
-    case fetch(exc, key) do
-      {:ok, value} ->
-        do_split(rest, [{key, value} | inc], delete(exc, key))
-      :error ->
-        do_split(rest, inc, exc)
-    end
-  end
-
-  @doc """
-  Updates the `key` with the given function.
-
-  If the `key` does not exist, raises `KeyError`.
-
-  ## Examples
-
-      iex> Map.update!(%{a: 1}, :a, &(&1 * 2))
-      %{a: 2}
-
-      iex> Map.update!(%{a: 1}, :b, &(&1 * 2))
-      ** (KeyError) key :b not found
-
-  """
-  @spec update!(map, key, (value -> value)) :: map | no_return
-  def update!(%{} = map, key, fun) do
-    case fetch(map, key) do
-      {:ok, value} ->
-        put(map, key, fun.(value))
-      :error ->
-        :erlang.error({:badkey, key})
-    end
-  end
-
-  def update!(map, _key, _fun), do: :erlang.error({:badmap, map})
-
-  @doc """
-  Gets the value from `key` and updates it, all in one pass.
-
-  This `fun` argument receives the value of `key` (or `nil` if `key`
-  is not present) and must return a two-element tuple: the "get" value
-  (the retrieved value, which can be operated on before being returned)
-  and the new value to be stored under `key`. The `fun` may also
-  return `:pop`, implying the current value shall be removed
-  from `map` and returned.
-
-  The returned value is a tuple with the "get" value returned by
-  `fun` and a new map with the updated value under `key`.
-
-  ## Examples
-
-      iex> Map.get_and_update(%{a: 1}, :a, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      {1, %{a: "new value!"}}
-
-      iex> Map.get_and_update(%{a: 1}, :b, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      {nil, %{b: "new value!", a: 1}}
-
-      iex> Map.get_and_update(%{a: 1}, :a, fn _ -> :pop end)
-      {1, %{}}
-
-      iex> Map.get_and_update(%{a: 1}, :b, fn _ -> :pop end)
-      {nil, %{a: 1}}
-
-  """
-  @spec get_and_update(map, key, (value -> {get, value} | :pop)) :: {get, map} when get: term
-  def get_and_update(%{} = map, key, fun) do
-    current =
-      case :maps.find(key, map) do
-        {:ok, value} -> value
-        :error -> nil
-      end
-
-    case fun.(current) do
-      {get, update} -> {get, :maps.put(key, update, map)}
-      :pop          -> {current, :maps.remove(key, map)}
-    end
-  end
-
-  def get_and_update(map, _key, _fun), do: :erlang.error({:badmap, map})
-
-  @doc """
-  Gets the value from `key` and updates it. Raises if there is no `key`.
-
-  This `fun` argument receives the value of `key` and must return a
-  two-element tuple: the "get" value (the retrieved value, which can be
-  operated on before being returned) and the new value to be stored under
-  `key`.
-
-  The returned value is a tuple with the "get" value returned by `fun` and a
-  new map with the updated value under `key`.
-
-  ## Examples
-
-      iex> Map.get_and_update!(%{a: 1}, :a, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      {1, %{a: "new value!"}}
-
-      iex> Map.get_and_update!(%{a: 1}, :b, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      ** (KeyError) key :b not found
-
-      iex> Map.get_and_update!(%{a: 1}, :a, fn _ ->
-      ...>   :pop
-      ...> end)
-      {1, %{}}
-
-  """
-  @spec get_and_update!(map, key, (value -> {get, value})) :: {get, map} | no_return when get: term
-  def get_and_update!(%{} = map, key, fun) do
-    case :maps.find(key, map) do
-      {:ok, value} ->
-        case fun.(value) do
-          {get, update} -> {get, :maps.put(key, update, map)}
-          :pop          -> {value, :maps.remove(key, map)}
-        end
-      :error ->
-        :erlang.error({:badkey, key})
-    end
-  end
-
-  def get_and_update!(map, _key, _fun), do: :erlang.error({:badmap, map})
-
-  @doc """
-  Converts a `struct` to map.
+  Converts a struct to map.
 
   It accepts the struct module or a struct itself and
   simply removes the `__struct__` field from the struct.
@@ -629,7 +57,6 @@ defmodule Map do
       #=> %{name: "john"}
 
   """
-  @spec from_struct(atom | struct) :: map
   def from_struct(struct) when is_atom(struct) do
     :maps.remove(:__struct__, struct.__struct__)
   end
@@ -638,27 +65,5 @@ defmodule Map do
     :maps.remove(:__struct__, struct)
   end
 
-  @doc """
-  Checks if two maps are equal.
-
-  Two maps are considered to be equal if they contain
-  the same keys and those keys contain the same values.
-
-  ## Examples
-
-      iex> Map.equal?(%{a: 1, b: 2}, %{b: 2, a: 1})
-      true
-      iex> Map.equal?(%{a: 1, b: 2}, %{b: 1, a: 2})
-      false
-
-  """
-  @spec equal?(map, map) :: boolean
   def equal?(%{} = map1, %{} = map2), do: map1 === map2
-
-  @doc false
-  # TODO: Remove on 2.0
-  def size(map) do
-    IO.warn "Map.size/1 is deprecated, please use Kernel.map_size/1"
-    map_size(map)
-  end
 end

lib/elixir/lib/map_set.ex

@@ -1,346 +0,0 @@
-defmodule MapSet do
-  @moduledoc """
-  A set of functions for working with sets.
-
-  The `MapSet` is represented internally as a struct,
-  therefore `%MapSet{}` can be used whenever there is a
-  need to match on any `MapSet`. Note though the struct
-  fields are private and must not be accessed directly.
-  Instead, use the functions in this module.
-  """
-
-  @opaque t :: %__MODULE__{map: map}
-  @type value :: term
-  defstruct map: %{}
-
-  @doc """
-  Returns a new set.
-
-  ## Examples
-
-      iex> MapSet.new
-      #MapSet<[]>
-
-  """
-  @spec new :: t
-  def new(), do: %MapSet{}
-
-  @doc """
-  Creates a set from an enumerable.
-
-  ## Examples
-
-      iex> MapSet.new([:b, :a, 3])
-      #MapSet<[3, :a, :b]>
-      iex> MapSet.new([3, 3, 3, 2, 2, 1])
-      #MapSet<[1, 2, 3]>
-
-  """
-  @spec new(Enum.t) :: t
-  def new(%__MODULE__{} = mapset), do: mapset
-  def new(enumerable) do
-    map =
-      enumerable
-      |> Enum.to_list
-      |> do_new([])
-
-    %MapSet{map: map}
-  end
-
-  @doc """
-  Creates a mapset from an enumerable via the transformation function.
-
-  ## Examples
-
-      iex> MapSet.new([1, 2, 1], fn x -> 2 * x end)
-      #MapSet<[2, 4]>
-
-  """
-  @spec new(Enum.t, (term -> term)) :: t
-  def new(enumerable, transform) do
-    map =
-      enumerable
-      |> Enum.to_list
-      |> do_new_transform(transform, [])
-
-    %MapSet{map: map}
-  end
-
-  defp do_new([], acc) do
-    acc
-    |> :lists.reverse
-    |> :maps.from_list
-  end
-  defp do_new([item | rest], acc) do
-    do_new(rest, [{item, true} | acc])
-  end
-
-  defp do_new_transform([], _fun, acc) do
-    acc
-    |> :lists.reverse
-    |> :maps.from_list
-  end
-  defp do_new_transform([item | rest], fun, acc) do
-    do_new_transform(rest, fun, [{fun.(item), true} | acc])
-  end
-
-  @doc """
-  Deletes `value` from `set`.
-
-  Returns a new set which is a copy of `set` but without `value`.
-
-  ## Examples
-
-      iex> set = MapSet.new([1, 2, 3])
-      iex> MapSet.delete(set, 4)
-      #MapSet<[1, 2, 3]>
-      iex> MapSet.delete(set, 2)
-      #MapSet<[1, 3]>
-
-  """
-  @spec delete(t, value) :: t
-  def delete(%MapSet{map: map} = set, value) do
-    %{set | map: Map.delete(map, value)}
-  end
-
-  @doc """
-  Returns a set that is `set1` without the members of `set2`.
-
-  ## Examples
-
-      iex> MapSet.difference(MapSet.new([1, 2]), MapSet.new([2, 3, 4]))
-      #MapSet<[1]>
-
-  """
-  @spec difference(t, t) :: t
-  # If the first set is less than twice the size of the second map,
-  # it is fastest to re-accumulate items in the first set that are not
-  # present in the second set.
-  def difference(%MapSet{map: map1}, %MapSet{map: map2})
-  when map_size(map1) < map_size(map2) * 2 do
-    map = map1
-    |> Map.keys
-    |> filter_not_in(map2)
-
-    %MapSet{map: map}
-  end
-
-  # If the second set is less than half the size of the first set, it's fastest
-  # to simply iterate through each item in the second set, deleting them from
-  # the first set.
-  def difference(%MapSet{map: map1}, %MapSet{map: map2}) do
-    %MapSet{map: Map.drop(map1, Map.keys(map2))}
-  end
-
-  defp filter_not_in(keys, map2, acc \\ [])
-  defp filter_not_in([], _map2, acc), do: :maps.from_list(acc)
-  defp filter_not_in([key | rest], map2, acc) do
-    acc = if Map.has_key?(map2, key) do
-      acc
-    else
-      [{key, true} | acc]
-    end
-    filter_not_in(rest, map2, acc)
-  end
-
-  @doc """
-  Checks if `set1` and `set2` have no members in common.
-
-  ## Examples
-
-      iex> MapSet.disjoint?(MapSet.new([1, 2]), MapSet.new([3, 4]))
-      true
-      iex> MapSet.disjoint?(MapSet.new([1, 2]), MapSet.new([2, 3]))
-      false
-
-  """
-  @spec disjoint?(t, t) :: boolean
-  def disjoint?(%MapSet{map: map1}, %MapSet{map: map2}) do
-    {map1, map2} = order_by_size(map1, map2)
-
-    map1
-    |> Map.keys
-    |> none_in?(map2)
-  end
-
-  defp none_in?([], _) do
-    true
-  end
-  defp none_in?([key | rest], map2) do
-    case Map.has_key?(map2, key) do
-      true -> false
-      false -> none_in?(rest, map2)
-    end
-  end
-
-  @doc """
-  Checks if two sets are equal.
-
-  The comparison between elements must be done using `===`.
-
-  ## Examples
-
-      iex> MapSet.equal?(MapSet.new([1, 2]), MapSet.new([2, 1, 1]))
-      true
-      iex> MapSet.equal?(MapSet.new([1, 2]), MapSet.new([3, 4]))
-      false
-
-  """
-  @spec equal?(t, t) :: boolean
-  def equal?(%MapSet{map: map1}, %MapSet{map: map2}) do
-    Map.equal?(map1, map2)
-  end
-
-  @doc """
-  Returns a set containing only members that `set1` and `set2` have in common.
-
-  ## Examples
-
-      iex> MapSet.intersection(MapSet.new([1, 2]), MapSet.new([2, 3, 4]))
-      #MapSet<[2]>
-
-      iex> MapSet.intersection(MapSet.new([1, 2]), MapSet.new([3, 4]))
-      #MapSet<[]>
-
-  """
-  @spec intersection(t, t) :: t
-  def intersection(%MapSet{map: map1}, %MapSet{map: map2}) do
-    {map1, map2} = order_by_size(map1, map2)
-
-    %MapSet{map: Map.take(map2, Map.keys(map1))}
-  end
-
-  @doc """
-  Checks if `set` contains `value`.
-
-  ## Examples
-
-      iex> MapSet.member?(MapSet.new([1, 2, 3]), 2)
-      true
-      iex> MapSet.member?(MapSet.new([1, 2, 3]), 4)
-      false
-
-  """
-  @spec member?(t, value) :: boolean
-  def member?(%MapSet{map: map}, value) do
-    Map.has_key?(map, value)
-  end
-
-  @doc """
-  Inserts `value` into `set` if `set` doesn't already contain it.
-
-  ## Examples
-
-      iex> MapSet.put(MapSet.new([1, 2, 3]), 3)
-      #MapSet<[1, 2, 3]>
-      iex> MapSet.put(MapSet.new([1, 2, 3]), 4)
-      #MapSet<[1, 2, 3, 4]>
-
-  """
-  @spec put(t, value) :: t
-  def put(%MapSet{map: map} = set, value) do
-    %{set | map: Map.put(map, value, true)}
-  end
-
-  @doc """
-  Returns the number of elements in `set`.
-
-  ## Examples
-
-      iex> MapSet.size(MapSet.new([1, 2, 3]))
-      3
-
-  """
-  @spec size(t) :: non_neg_integer
-  def size(%MapSet{map: map}) do
-    map_size(map)
-  end
-
-  @doc """
-  Checks if `set1`'s members are all contained in `set2`.
-
-  This function checks if `set1` is a subset of `set2`.
-
-  ## Examples
-
-      iex> MapSet.subset?(MapSet.new([1, 2]), MapSet.new([1, 2, 3]))
-      true
-      iex> MapSet.subset?(MapSet.new([1, 2, 3]), MapSet.new([1, 2]))
-      false
-
-  """
-  @spec subset?(t, t) :: boolean
-  def subset?(%MapSet{map: map1}, %MapSet{map: map2}) do
-    if map_size(map1) <= map_size(map2) do
-      map1
-      |> Map.keys
-      |> do_subset?(map2)
-    else
-      false
-    end
-  end
-
-  defp do_subset?([], _), do: true
-  defp do_subset?([key | rest], map2) do
-    if Map.has_key?(map2, key) do
-      do_subset?(rest, map2)
-    else
-      false
-    end
-  end
-
-  @doc """
-  Converts `set` to a list.
-
-  ## Examples
-
-      iex> MapSet.to_list(MapSet.new([1, 2, 3]))
-      [1, 2, 3]
-
-  """
-  @spec to_list(t) :: list
-  def to_list(%MapSet{map: map}) do
-    Map.keys(map)
-  end
-
-  @doc """
-  Returns a set containing all members of `set1` and `set2`.
-
-  ## Examples
-
-      iex> MapSet.union(MapSet.new([1, 2]), MapSet.new([2, 3, 4]))
-      #MapSet<[1, 2, 3, 4]>
-
-  """
-  @spec union(t, t) :: t
-  def union(%MapSet{map: map1}, %MapSet{map: map2}) do
-    %MapSet{map: Map.merge(map1, map2)}
-  end
-
-  defp order_by_size(map1, map2) when map_size(map1) > map_size(map2), do: {map2, map1}
-  defp order_by_size(map1, map2), do: {map1, map2}
-
-  defimpl Enumerable do
-    def reduce(set, acc, fun), do: Enumerable.List.reduce(MapSet.to_list(set), acc, fun)
-    def member?(set, val),     do: {:ok, MapSet.member?(set, val)}
-    def count(set),            do: {:ok, MapSet.size(set)}
-  end
-
-  defimpl Collectable do
-    def into(original) do
-      {original, fn
-        set, {:cont, x} -> MapSet.put(set, x)
-        set, :done -> set
-        _, :halt -> :ok
-      end}
-    end
-  end
-
-  defimpl Inspect do
-    import Inspect.Algebra
-
-    def inspect(set, opts) do
-      concat ["#MapSet<", Inspect.List.inspect(MapSet.to_list(set), opts), ">"]
-    end
-  end
-end

lib/elixir/lib/module/locals_tracker.ex

@@ -1,15 +1,15 @@
-# This is an Elixir module responsible for tracking
+# 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 one main vertex:
+# all dependencies. The graph starts with one main vertice:
 #
 # * `:local` - points to local functions
 #
-# We can also have the following vertices:
+# We also have can the following vertices:
 #
 # * `Module` - a module that was invoked via an import
 # * `{name, arity}` - a local function/arity pair
@@ -30,7 +30,7 @@
 #   * out neighbours: `Module`
 #
 # Note that since this is required for bootstrap, we can't use
-# any of the `GenServer` conveniences.
+# any of the `GenServer.Behaviour` conveniences.
 defmodule Module.LocalsTracker do
   @moduledoc false
 
@@ -121,7 +121,7 @@ defmodule Module.LocalsTracker do
     :gen_server.cast(pid, {:add_local, from, to})
   end
 
-  # Adds an import dispatch to the given target.
+  # Adds a import dispatch to the given target.
   @doc false
   def add_import(pid, function, module, target) when is_atom(module) and is_tuple(target) do
     :gen_server.cast(pid, {:add_import, function, module, target})
@@ -174,9 +174,9 @@ defmodule Module.LocalsTracker do
     reduce_unreachable(private, [], :sets.from_list(unreachable))
   end
 
-  defp reduce_unreachable([{vertex, callers} | t], acc, unreachable) do
+  defp reduce_unreachable([{vertex, callers}|t], acc, unreachable) do
     if :sets.is_subset(callers, unreachable) do
-      reduce_unreachable(t, [{vertex, callers} | acc], unreachable)
+      reduce_unreachable(t, [{vertex, callers}|acc], unreachable)
     else
       reduce_unreachable(acc ++ t, [], :sets.del_element(vertex, unreachable))
     end
@@ -195,7 +195,7 @@ defmodule Module.LocalsTracker do
     if :lists.member(tuple, reachable) do
       acc
     else
-      [{:unused_def, tuple, kind} | acc]
+      [{:unused_def, tuple, kind}|acc]
     end
   end
 
@@ -207,12 +207,12 @@ defmodule Module.LocalsTracker do
     invoked = for {n, a} <- reachable, n == name, a in min..max, do: a
 
     if invoked == [] do
-      [{:unused_def, tuple, kind} | acc]
+      [{:unused_def, tuple, kind}|acc]
     else
       case :lists.min(invoked) - min do
         0 -> acc
-        ^default -> [{:unused_args, tuple} | acc]
-        unused_args -> [{:unused_args, tuple, unused_args} | acc]
+        ^default -> [{:unused_args, tuple}|acc]
+        unused_args -> [{:unused_args, tuple, unused_args}|acc]
       end
     end
   end
@@ -244,11 +244,11 @@ defmodule Module.LocalsTracker do
   @doc false
   def handle_call({:cache_env, env}, _from, {d, cache}) do
     case cache do
-      [{i, ^env} | _] ->
+      [{i,^env}|_] ->
         {:reply, i, {d, cache}}
       t ->
         i = length(t)
-        {:reply, i, {d, [{i, env} | t]}}
+        {:reply, i, {d, [{i,env}|t]}}
     end
   end
 
@@ -267,6 +267,10 @@ defmodule Module.LocalsTracker do
     {:reply, d, state}
   end
 
+  def handle_call(request, _from, state) do
+    {:stop, {:bad_call, request}, state}
+  end
+
   @doc false
   def handle_info(_msg, state) do
     {:noreply, state}
@@ -313,6 +317,10 @@ defmodule Module.LocalsTracker do
     {:stop, :normal, state}
   end
 
+  def handle_cast(msg, state) do
+    {:stop, {:bad_cast, msg}, state}
+  end
+
   @doc false
   def terminate(_reason, _state) do
     :ok
@@ -353,7 +361,7 @@ defmodule Module.LocalsTracker do
 
   defp replace_edge!(d, from, to) do
     _ = unless :lists.member(to, :digraph.out_neighbours(d, from)) do
-      [:"$e" | _] = :digraph.add_edge(d, from, to)
+      [:"$e"|_] = :digraph.add_edge(d, from, to)
     end
     :ok
   end

lib/elixir/lib/node.ex

@@ -72,8 +72,7 @@ defmodule Node do
   The result returned when the argument is a list, is the list of nodes
   satisfying the disjunction(s) of the list elements.
 
-  For more information, see
-  [`:erlang.nodes/1`](http://www.erlang.org/doc/man/erlang.html#nodes-1).
+  See http://www.erlang.org/doc/man/erlang.html#nodes-1 for more info.
   """
   @typep state :: :visible | :hidden | :connected | :this | :known
   @spec list(state | [state]) :: [t]
@@ -87,8 +86,7 @@ defmodule Node do
   If `flag` is `true`, monitoring is turned on.
   If `flag` is `false`, monitoring is turned off.
 
-  For more information, see
-  [`:erlang.monitor_node/2`](http://www.erlang.org/doc/man/erlang.html#monitor_node-2).
+  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
@@ -99,8 +97,7 @@ defmodule Node do
   Behaves as `monitor/2` except that it allows an extra
   option to be given, namely `:allow_passive_connect`.
 
-  For more information, see
-  [`:erlang.monitor_node/3`](http://www.erlang.org/doc/man/erlang.html#monitor_node-3).
+  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
@@ -131,8 +128,7 @@ defmodule Node do
   protocols. Returns `true` if disconnection succeeds, otherwise `false`.
   If the local node is not alive, the function returns `:ignored`.
 
-  For more information, see
-  [`:erlang.disconnect_node/1`](http://www.erlang.org/doc/man/erlang.html#disconnect_node-1).
+  See http://www.erlang.org/doc/man/erlang.html#disconnect_node-1 for more info.
   """
   @spec disconnect(t) :: boolean | :ignored
   def disconnect(node) do
@@ -145,8 +141,7 @@ defmodule Node do
   Returns `true` if successful, `false` if not, and the atom
   `:ignored` if the local node is not alive.
 
-  For more information, see
-  [`:erlang.connect_node/1`](http://www.erlang.org/doc/man/net_kernel.html#connect_node-1).
+  See http://erlang.org/doc/man/net_kernel.html#connect_node-1 for more info.
   """
   @spec connect(t) :: boolean | :ignored
   def connect(node) do
@@ -157,8 +152,8 @@ defmodule Node do
   Returns the pid of a new process started by the application of `fun`
   on `node`. If `node` does not exist, a useless pid is returned.
 
-  For the list of available options, see
-  [`:erlang.spawn/2`](http://www.erlang.org/doc/man/erlang.html#spawn-2).
+  Check http://www.erlang.org/doc/man/erlang.html#spawn-2 for
+  the list of available options.
 
   Inlined by the compiler.
   """
@@ -171,10 +166,9 @@ defmodule Node do
   Returns the pid of a new process started by the application of `fun`
   on `node`.
 
-  If `node` does not exist, a useless pid is returned.
-
-  For the list of available options, see
-  [`:erlang.spawn_opt/3`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-3).
+  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.
 
   Inlined by the compiler.
   """
@@ -187,10 +181,9 @@ defmodule Node do
   Returns the pid of a new process started by the application of
   `module.function(args)` on `node`.
 
-  If `node` does not exist, a useless pid is returned.
-
-  For the list of available options, see
-  [`:erlang.spawn/4`](http://www.erlang.org/doc/man/erlang.html#spawn-4).
+  If `node` does not exist, a useless pid is returned. Check
+  http://www.erlang.org/doc/man/erlang.html#spawn-4 for the list of
+  available options.
 
   Inlined by the compiler.
   """
@@ -203,10 +196,9 @@ defmodule Node do
   Returns the pid of a new process started by the application of
   `module.function(args)` on `node`.
 
-  If `node` does not exist, a useless pid is returned.
-
-  For the list of available options, see
-  [`:erlang.spawn/5`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-5).
+  If `node` does not exist, a useless pid is returned. Check
+  http://www.erlang.org/doc/man/erlang.html#spawn_opt-5 for the list of
+  available options.
 
   Inlined by the compiler.
   """
@@ -247,7 +239,7 @@ defmodule Node do
   @doc """
   Sets the magic cookie of `node` to the atom `cookie`.
 
-  The default node is `Node.self/0`, the local node. If `node` is the local node,
+  The 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.

lib/elixir/lib/option_parser.ex

@@ -1,6 +1,6 @@
 defmodule OptionParser do
   @moduledoc """
-  This module contains functions to parse command line options.
+  This module contains functions to parse command line arguments.
   """
 
   @type argv    :: [String.t]
@@ -8,31 +8,13 @@ defmodule OptionParser do
   @type errors  :: [{String.t, String.t | nil}]
   @type options :: [switches: Keyword.t, strict: Keyword.t, aliases: Keyword.t]
 
-  defmodule ParseError do
-    defexception [:message]
-  end
-
   @doc """
   Parses `argv` into a keywords list.
 
-  It returns a three-element tuple with the form `{parsed, args, invalid}`, where:
+  It returns the parsed values, remaining arguments and the
+  invalid options.
 
-    * `parsed` is a keyword list of parsed switches with `{switch_name, value}`
-      tuples in it; `switch_name` is the atom representing the switch name while
-      `value` is the value for that switch parsed according to `opts` (see the
-      "Examples" section for more information)
-    * `args` is a list of the remaining arguments in `argv` as strings
-    * `invalid` is a list of invalid options as `{option_name, value}` where
-      `option_name` is the raw option and `value` is `nil` if the option wasn't
-      expected or the string value if the value didn't have the expected type for
-      the corresponding option
-
-  Elixir converts switches to underscored atoms, so `--source-path` becomes
-  `:source_path`. This is done to better suit Elixir conventions. However, this
-  means that switches can't contain underscores and switches that do contain
-  underscores are always returned in the list of invalid options.
-
-  Without any options, this function will try to parse all switches in the `argv`.
+  ## Examples
 
       iex> OptionParser.parse(["--debug"])
       {[debug: true], [], []}
@@ -43,85 +25,49 @@ defmodule OptionParser do
       iex> OptionParser.parse(["--source-path", "lib", "test/enum_test.exs", "--verbose"])
       {[source_path: "lib", verbose: true], ["test/enum_test.exs"], []}
 
-  Switches followed by a value will be assigned the value, as a string.
-  Switches without an argument, like `--debug` in the examples above, will
-  automatically be set to `true`.
+  By default, Elixir will try to automatically parse switches.
+  Switches without an argument, like `--debug` will automatically
+  be set to true. Switches followed by a value will be assigned
+  to the value, always as strings.
 
-  ## Options
+  Note Elixir also converts the switches to underscore atoms, as
+  `--source-path` becomes `:source_path`, to better suit Elixir
+  conventions. This means that option names on the command line cannot contain
+  underscores; such options will be reported as `:undefined` (in strict mode)
+  or `:invalid` (in basic mode).
 
-  The following options are supported:
+  ## Switches
 
-    * `:switches` or `:strict` - see the "Switch definitions" section below
-    * `:aliases` - see the "Aliases" section below
+  Many times though, it is better to explicitly list the available
+  switches and their formats. The switches can be specified via two
+  different options:
 
-  ## Switch definitions
+    * `:strict` - the switches are strict. Any switch that does not
+      exist in the switch list is treated as an error.
 
-  Often it is better to explicitly list the known
-  switches and their formats. The switches can be specified via one of two
-  options:
+    * `:switches` - defines some switches. Switches that does not
+      exist in the switch list are still attempted to be parsed.
 
-    * `:switches` - defines some switches and their types. This function
-      still attempts to parse switches that are not in this list.
-    * `:strict` - defines strict switches. Any switch in `argv` that is not
-      specified in the list is returned in the invalid options list.
+  Note only `:strict` or `:switches` may be given at once.
 
-  Both these options accept a keyword list of `{name, type}` tuples where `name`
-  is an atom defining the name of the switch and `type` is an atom that
-  specifies the type for the value of this switch (see the "Types" section below
-  for the possible types and more information about type casting).
+  For each switch, the following types are supported:
 
-  Note that you should only supply the `:switches` or `:strict` option.
-  If you supply both, an `ArgumentError` exception will be raised.
+    * `:boolean` - marks the given switch as a boolean. Boolean switches
+                   never consume the following value unless it is `true` or
+                   `false`.
+    * `:integer` - parses the switch as an integer.
+    * `:float`   - parses the switch as a float.
+    * `:string`  - returns the switch as a string.
 
-  ### Types
+  If a switch can't be parsed or is not specified in the strict case,
+  the option is returned in the invalid options list (third element
+  of the returned tuple).
 
-  Switches parsed by `OptionParser` may take zero or one arguments.
+  The following extra "types" are supported:
 
-  The following switches types take no arguments:
+    * `:keep` - keeps duplicated items in the list instead of overriding
 
-    * `:boolean` - sets the value to `true` when given (see also the
-      "Negation switches" section below)
-    * `:count` - counts the number of times the switch is given
-
-  The following switches take one argument:
-
-    * `:integer` - parses the value as an integer
-    * `:float` - parses the value as a float
-    * `:string` - parses the value as a string
-
-  If a switch can't be parsed according to the given type, it is returned
-  in the invalid options list.
-
-  ### Modifiers
-
-  Switches can be specified with modifiers, which change how
-  they behave. The following modifiers are supported:
-
-    * `:keep` - keeps duplicated items instead of overriding them; works with
-      all types except `:count`. Specifying `switch_name: :keep` assumes the
-      type of `:switch_name` will be `:string`.
-
-  Note that if you want to use `:keep` with a type other than `:string`, use a list
-  as the type for the switch. For example: `[foo: [:integer, :keep]]`.
-
-  ### Negation switches
-
-  In case a switch `SWITCH` is specified to have type `:boolean`, it may be
-  passed as `--no-SWITCH` as well which will set the option to `false`:
-
-      iex> OptionParser.parse(["--no-op", "path/to/file"], switches: [op: :boolean])
-      {[op: false], ["path/to/file"], []}
-
-  ## Aliases
-
-  A set of aliases can be specified in the `:aliases` option:
-
-      iex> OptionParser.parse(["-d"], aliases: [d: :debug])
-      {[debug: true], [], []}
-
-  ## Examples
-
-  Here are some examples of working with different types and modifiers:
+  Examples:
 
       iex> OptionParser.parse(["--unlock", "path/to/file"], strict: [unlock: :boolean])
       {[unlock: true], ["path/to/file"], []}
@@ -136,12 +82,6 @@ defmodule OptionParser do
       iex> OptionParser.parse(["--limit", "xyz"], strict: [limit: :integer])
       {[], [], [{"--limit", "xyz"}]}
 
-      iex> OptionParser.parse(["--verbose"], switches: [verbose: :count])
-      {[verbose: 1], [], []}
-
-      iex> OptionParser.parse(["-v", "-v"], aliases: [v: :verbose], strict: [verbose: :count])
-      {[verbose: 2], [], []}
-
       iex> OptionParser.parse(["--unknown", "xyz"], strict: [])
       {[], ["xyz"], [{"--unknown", nil}]}
 
@@ -149,8 +89,20 @@ defmodule OptionParser do
       ...>                    switches: [limit: :integer])
       {[limit: 3, unknown: "xyz"], [], []}
 
-      iex> OptionParser.parse(["--unlock", "path/to/file", "--unlock", "path/to/another/file"], strict: [unlock: :keep])
-      {[unlock: "path/to/file", unlock: "path/to/another/file"], [], []}
+  ## Negation switches
+
+  In case a switch is declared as boolean, it may be passed as `--no-SWITCH`
+  which will set the option to false:
+
+      iex> OptionParser.parse(["--no-op", "path/to/file"], switches: [op: :boolean])
+      {[op: false], ["path/to/file"], []}
+
+  ## Aliases
+
+  A set of aliases can be given as options too:
+
+      iex> OptionParser.parse(["-d"], aliases: [d: :debug])
+      {[debug: true], [], []}
 
   """
   @spec parse(argv, options) :: {parsed, argv, errors}
@@ -158,43 +110,6 @@ defmodule OptionParser do
     do_parse(argv, compile_config(opts), [], [], [], true)
   end
 
-  @doc """
-  The same as `parse/2` but raises an `OptionParser.ParseError`
-  exception if any invalid options are given.
-
-  If there are no errors, returns a `{parsed, rest}` tuple where:
-
-    * `parsed` is the list of parsed switches (same as in `parse/2`)
-    * `rest` is the list of arguments (same as in `parse/2`)
-
-  ## Examples
-
-      iex> OptionParser.parse!(["--debug", "path/to/file"], strict: [debug: :boolean])
-      {[debug: true], ["path/to/file"]}
-
-      iex> OptionParser.parse!(["--limit", "xyz"], strict: [limit: :integer])
-      ** (OptionParser.ParseError) 1 error found!
-      --limit : Expected type integer, got "xyz"
-
-      iex> OptionParser.parse!(["--unknown", "xyz"], strict: [])
-      ** (OptionParser.ParseError) 1 error found!
-      --unknown : Unknown option
-
-      iex> OptionParser.parse!(["-l", "xyz", "-f", "bar"],
-      ...>                     switches: [limit: :integer, foo: :integer], aliases: [l: :limit, f: :foo])
-      ** (OptionParser.ParseError) 2 errors found!
-      -l : Expected type integer, got "xyz"
-      -f : Expected type integer, got "bar"
-
-  """
-  @spec parse!(argv, options) :: {parsed, argv} | no_return
-  def parse!(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    case parse(argv, opts) do
-      {parsed, args, []} -> {parsed, args}
-      {_, _, errors} -> raise ParseError, format_errors(errors, opts)
-    end
-  end
-
   @doc """
   Similar to `parse/2` but only parses the head of `argv`;
   as soon as it finds a non-switch, it stops parsing.
@@ -215,38 +130,6 @@ defmodule OptionParser do
     do_parse(argv, compile_config(opts), [], [], [], false)
   end
 
-  @doc """
-  The same as `parse_head/2` but raises an `OptionParser.ParseError`
-  exception if any invalid options are given.
-
-  If there are no errors, returns a `{parsed, rest}` tuple where:
-
-    * `parsed` is the list of parsed switches (same as in `parse_head/2`)
-    * `rest` is the list of arguments (same as in `parse_head/2`)
-
-  ## Examples
-
-      iex> OptionParser.parse_head!(["--source", "lib", "path/to/file", "--verbose"])
-      {[source: "lib"], ["path/to/file", "--verbose"]}
-
-      iex> OptionParser.parse_head!(["--number", "lib", "test/enum_test.exs", "--verbose"], strict: [number: :integer])
-      ** (OptionParser.ParseError) 1 error found!
-      --number : Expected type integer, got "lib"
-
-      iex> OptionParser.parse_head!(["--verbose", "--source", "lib", "test/enum_test.exs", "--unlock"],
-      ...>                          strict: [verbose: :integer, source: :integer])
-      ** (OptionParser.ParseError) 2 errors found!
-      --verbose : Missing argument of type integer
-      --source : Expected type integer, got "lib"
-  """
-  @spec parse_head!(argv, options) :: {parsed, argv} | no_return
-  def parse_head!(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    case parse_head(argv, opts) do
-      {parsed, args, []} -> {parsed, args}
-      {_, _, errors} -> raise ParseError, format_errors(errors, opts)
-    end
-  end
-
   defp do_parse([], _config, opts, args, invalid, _all?) do
     {Enum.reverse(opts), Enum.reverse(args), Enum.reverse(invalid)}
   end
@@ -254,26 +137,26 @@ defmodule OptionParser do
   defp do_parse(argv, {aliases, switches, strict}=config, opts, args, invalid, all?) do
     case next(argv, aliases, switches, strict) do
       {:ok, option, value, rest} ->
-        # the option exists and it was successfully parsed
+        # the option exist and it was successfully parsed
         kinds = List.wrap Keyword.get(switches, option)
         new_opts = do_store_option(opts, option, value, kinds)
         do_parse(rest, config, new_opts, args, invalid, all?)
 
       {:invalid, option, value, rest} ->
         # the option exist but it has wrong value
-        do_parse(rest, config, opts, args, [{option, value} | invalid], all?)
+        do_parse(rest, config, opts, args, [{option, value}|invalid], all?)
 
       {:undefined, option, _value, rest} ->
         # the option does not exist (for strict cases)
-        do_parse(rest, config, opts, args, [{option, nil} | invalid], all?)
+        do_parse(rest, config, opts, args, [{option, nil}|invalid], all?)
 
-      {:error, ["--" | rest]} ->
+      {:error, ["--"|rest]} ->
         {Enum.reverse(opts), Enum.reverse(args, rest), Enum.reverse(invalid)}
 
-      {:error, [arg | rest] = remaining_args} ->
+      {:error, [arg|rest]=remaining_args} ->
         # there is no option
         if all? do
-          do_parse(rest, config, opts, [arg | args], invalid, all?)
+          do_parse(rest, config, opts, [arg|args], invalid, all?)
         else
           {Enum.reverse(opts), Enum.reverse(args, remaining_args), Enum.reverse(invalid)}
         end
@@ -284,20 +167,20 @@ defmodule OptionParser do
   Low-level function that parses one option.
 
   It accepts the same options as `parse/2` and `parse_head/2`
-  as both functions are built on top of this function. This function
+  as both functions are built on top of next. This function
   may return:
 
     * `{:ok, key, value, rest}` - the option `key` with `value` was
       successfully parsed
 
     * `{:invalid, key, value, rest}` - the option `key` is invalid with `value`
-      (returned when the value cannot be parsed according to the switch type)
+      (returned when the switch type does not match the one given via the
+      command line)
 
     * `{:undefined, key, value, rest}` - the option `key` is undefined
-      (returned in strict mode when the switch is unknown)
-
-    * `{:error, rest}` - there are no switches at the head of the given `argv`
+      (returned on strict cases and the switch is unknown)
 
+    * `{:error, rest}` - there are no switches at the top of the given argv
   """
 
   @spec next(argv, options) ::
@@ -315,35 +198,32 @@ defmodule OptionParser do
     {:error, []}
   end
 
-  defp next(["--" | _] = argv, _aliases, _switches, _strict) do
+  defp next(["--"|_]=argv, _aliases, _switches, _strict) do
     {:error, argv}
   end
 
-  defp next(["-" | _] = argv, _aliases, _switches, _strict) do
+  defp next(["-"|_]=argv, _aliases, _switches, _strict) do
     {:error, argv}
   end
 
-  defp next(["- " <> _ | _] = argv, _aliases, _switches, _strict) do
+  defp next(["- " <> _|_]=argv, _aliases, _switches, _strict) do
     {:error, argv}
   end
 
-  defp next(["-" <> option | rest] = argv, aliases, switches, strict) do
+  defp next(["-" <> option|rest], aliases, switches, strict) do
     {option, value} = split_option(option)
-    original = "-" <> option
+    opt_name_bin = "-" <> option
     tagged = tag_option(option, switches, aliases)
 
-    cond do
-      negative_number?(original) ->
-        {:error, argv}
-      strict and not option_defined?(tagged, switches) ->
-        {:undefined, original, value, rest}
-      true ->
-        {option, kinds, value} = normalize_option(tagged, value, switches)
-        {value, kinds, rest} = normalize_value(value, kinds, rest, strict)
-        case validate_option(value, kinds) do
-          {:ok, new_value} -> {:ok, option, new_value, rest}
-          :invalid         -> {:invalid, original, value, rest}
-        end
+    if strict and not option_defined?(tagged, switches) do
+      {:undefined, opt_name_bin, value, rest}
+    else
+      {opt_name, kinds, value} = normalize_option(tagged, value, switches)
+      {value, kinds, rest} = normalize_value(value, kinds, rest, strict)
+      case validate_option(value, kinds) do
+        {:ok, new_value} -> {:ok, opt_name, new_value, rest}
+        :invalid         -> {:invalid, opt_name_bin, value, rest}
+      end
     end
   end
 
@@ -352,11 +232,10 @@ defmodule OptionParser do
   end
 
   @doc """
-  Receives a key-value enumerable and converts it to argv.
+  Receives a key-value enumerable and convert it to argv.
 
-  Keys must be atoms. Keys with `nil` value are discarded,
+  Keys must be atoms. Keys with nil value are discarded,
   boolean values are converted to `--key` or `--no-key`
-  (if the value is `true` or `false`, respectively),
   and all other values are converted using `to_string/1`.
 
   ## Examples
@@ -385,9 +264,6 @@ defmodule OptionParser do
   @doc ~S"""
   Splits a string into argv chunks.
 
-  This function splits the given `string` into a list of strings in a similar
-  way to many shells.
-
   ## Examples
 
       iex> OptionParser.split("foo bar")
@@ -395,32 +271,31 @@ defmodule OptionParser do
 
       iex> OptionParser.split("foo \"bar baz\"")
       ["foo", "bar baz"]
-
   """
   @spec split(String.t) :: argv
   def split(string) do
-    do_split(String.trim_leading(string, " "), "", [], nil)
+    do_split(strip_leading_spaces(string), "", [], nil)
   end
 
-  # If we have an escaped quote, simply remove the escape
-  defp do_split(<<?\\, quote, t::binary>>, buffer, acc, quote),
+  # If we have a escaped quote, simply remove the escape
+  defp do_split(<<?\\, quote, t :: binary>>, buffer, acc, quote),
     do: do_split(t, <<buffer::binary, quote>>, acc, quote)
 
   # If we have a quote and we were not in a quote, start one
-  defp do_split(<<quote, t::binary>>, buffer, acc, nil) when quote in [?", ?'],
+  defp do_split(<<quote, t :: binary>>, buffer, acc, nil) when quote in [?", ?'],
     do: do_split(t, buffer, acc, quote)
 
   # If we have a quote and we were inside it, close it
-  defp do_split(<<quote, t::binary>>, buffer, acc, quote),
+  defp do_split(<<quote, t :: binary>>, buffer, acc, quote),
     do: do_split(t, buffer, acc, nil)
 
-  # If we have an escaped quote/space, simply remove the escape as long as we are not inside a quote
-  defp do_split(<<?\\, h, t::binary>>, buffer, acc, nil) when h in [?\s, ?', ?"],
+  # If we have a escaped quote/space, simply remove the escape as long as we are not inside a quote
+  defp do_split(<<?\\, h, t :: binary>>, buffer, acc, nil) when h in [?\s, ?', ?"],
     do: do_split(t, <<buffer::binary, h>>, acc, nil)
 
   # If we have space and we are outside of a quote, start new segment
-  defp do_split(<<?\s, t::binary>>, buffer, acc, nil),
-    do: do_split(String.trim_leading(t, " "), "", [buffer | acc], nil)
+  defp do_split(<<?\s, t :: binary>>, buffer, acc, nil),
+    do: do_split(strip_leading_spaces(t), "", [buffer|acc], nil)
 
   # All other characters are moved to buffer
   defp do_split(<<h, t::binary>>, buffer, acc, quote) do
@@ -432,21 +307,22 @@ defmodule OptionParser do
     do: Enum.reverse(acc)
 
   defp do_split(<<>>, buffer, acc, nil),
-    do: Enum.reverse([buffer | acc])
+    do: Enum.reverse([buffer|acc])
 
   # Otherwise raise
   defp do_split(<<>>, _, _acc, marker) do
     raise "argv string did not terminate properly, a #{<<marker>>} was opened but never closed"
   end
 
+  defp strip_leading_spaces(" " <> t), do: strip_leading_spaces(t)
+  defp strip_leading_spaces(t), do: t
+
   ## Helpers
 
   defp compile_config(opts) do
     aliases = opts[:aliases] || []
 
     {switches, strict} = cond do
-      opts[:switches] && opts[:strict] ->
-        raise ArgumentError, ":switches and :strict cannot be given together"
       s = opts[:switches] ->
         {s, false}
       s = opts[:strict] ->
@@ -459,36 +335,30 @@ defmodule OptionParser do
   end
 
   defp validate_option(value, kinds) do
-    {invalid?, value} =
-      cond do
-        :invalid in kinds ->
-          {true, value}
-        :boolean in kinds ->
-          case value do
-            t when t in [true, "true"] -> {false, true}
-            f when f in [false, "false"] -> {false, false}
-            _ -> {true, value}
-          end
-        :count in kinds ->
-          case value do
-            1 -> {false, value}
-            _ -> {true, value}
-          end
-        :integer in kinds ->
-          case Integer.parse(value) do
-            {value, ""} -> {false, value}
-            _ -> {true, value}
-          end
-        :float in kinds ->
-          case Float.parse(value) do
-            {value, ""} -> {false, value}
-            _ -> {true, value}
-          end
-        true ->
-          {false, value}
-      end
+    {is_invalid, value} = cond do
+      :invalid in kinds ->
+        {true, value}
+      :boolean in kinds ->
+        case value do
+          t when t in [true, "true"] -> {nil, true}
+          f when f in [false, "false"] -> {nil, false}
+          _ -> {true, value}
+        end
+      :integer in kinds ->
+        case Integer.parse(value) do
+          {value, ""} -> {nil, value}
+          _ -> {true, value}
+        end
+      :float in kinds ->
+        case Float.parse(value) do
+          {value, ""} -> {nil, value}
+          _ -> {true, value}
+        end
+      true ->
+        {nil, value}
+    end
 
-    if invalid? do
+    if is_invalid do
       :invalid
     else
       {:ok, value}
@@ -497,32 +367,15 @@ defmodule OptionParser do
 
   defp do_store_option(dict, option, value, kinds) do
     cond do
-      :count in kinds ->
-        Keyword.update(dict, option, value, & &1 + 1)
       :keep in kinds ->
-        [{option, value} | dict]
+        [{option, value}|dict]
       true ->
-        [{option, value} | Keyword.delete(dict, option)]
+        [{option, value}|Keyword.delete(dict, option)]
     end
   end
 
-  defp tag_option("-no-" <> option, switches, _aliases) do
-    cond do
-      (negated = get_option(option)) && :boolean in List.wrap(switches[negated]) ->
-        {:negated, negated}
-      option = get_option("no-" <> option) ->
-        {:default, option}
-      true ->
-        :unknown
-    end
-  end
-
-  defp tag_option("-" <> option, _switches, _aliases) do
-    if option = get_option(option) do
-      {:default, option}
-    else
-      :unknown
-    end
+  defp tag_option(<<?-, option :: binary>>, switches, _aliases) do
+    get_negated(option, switches)
   end
 
   defp tag_option(option, _switches, aliases) when is_binary(option) do
@@ -563,18 +416,15 @@ defmodule OptionParser do
   end
 
   defp normalize_value(nil, kinds, t, strict) do
+    nil_or_true = if strict, do: nil, else: true
     cond do
       :boolean in kinds ->
         {true, kinds, t}
-      :count in kinds ->
-        {1, kinds, t}
       value_in_tail?(t) ->
-        [h | t] = t
+        [h|t] = t
         {h, kinds, t}
-      kinds == [] and strict ->
-        {nil, kinds, t}
       kinds == [] ->
-        {true, kinds, t}
+        {nil_or_true, kinds, t}
       true ->
         {nil, [:invalid], t}
     end
@@ -584,11 +434,11 @@ defmodule OptionParser do
     {value, kinds, t}
   end
 
-  defp value_in_tail?(["-" | _]),        do: true
-  defp value_in_tail?(["- " <> _ | _]),  do: true
-  defp value_in_tail?(["-" <> arg | _]), do: negative_number?("-" <> arg)
-  defp value_in_tail?([]),               do: false
-  defp value_in_tail?(_),                do: true
+  defp value_in_tail?(["-"|_]),       do: true
+  defp value_in_tail?(["- " <> _|_]), do: true
+  defp value_in_tail?(["-" <> _|_]),  do: false
+  defp value_in_tail?([]),            do: false
+  defp value_in_tail?(_),             do: true
 
   defp split_option(option) do
     case :binary.split(option, "=") do
@@ -597,16 +447,17 @@ defmodule OptionParser do
     end
   end
 
-  defp to_underscore(option),
-    do: to_underscore(option, <<>>)
-  defp to_underscore("_" <> _rest, _acc),
-    do: nil
+  defp to_underscore(option), do: to_underscore(option, <<>>)
+
+  defp to_underscore("_" <> _rest, _acc), do: nil
+
   defp to_underscore("-" <> rest, acc),
     do: to_underscore(rest, acc <> "_")
+
   defp to_underscore(<<c>> <> rest, acc),
     do: to_underscore(rest, <<acc::binary, c>>)
-  defp to_underscore(<<>>, acc),
-    do: acc
+
+  defp to_underscore(<<>>, acc), do: acc
 
   defp get_option(option) do
     if str = to_underscore(option) do
@@ -614,38 +465,22 @@ defmodule OptionParser do
     end
   end
 
-  defp negative_number?(arg) do
-    match?({_, ""}, Float.parse(arg))
-  end
-
-  defp format_errors(errors, opts) do
-    types = opts[:switches] || opts[:strict]
-    info  = Enum.map(errors, &format_error(&1, opts, types))
-    total = length(errors)
-    error = if total == 1, do: "error", else: "errors"
-    "#{total} #{error} found!#{info}"
-  end
-
-  defp format_error({option, nil}, opts, types) do
-    if type = get_type(option, opts, types) do
-      "\n#{option} : Missing argument of type #{type}"
-    else
-      "\n#{option} : Unknown option"
+  defp get_negated("no-" <> rest = original, switches) do
+    cond do
+      (negated = get_option(rest)) && :boolean in List.wrap(switches[negated]) ->
+        {:negated, negated}
+      option = get_option(original) ->
+        {:default, option}
+      true ->
+        :unknown
     end
   end
 
-  defp format_error({option, value}, opts, types) do
-    type = get_type(option, opts, types)
-    "\n#{option} : Expected type #{type}, got #{inspect value}"
-  end
-
-  defp get_type(option, opts, types) do
-    option_key = option |> String.trim_leading("-") |> get_option()
-
-    if option_alias = opts[:aliases][option_key] do
-      types[option_alias]
+  defp get_negated(rest, _switches) do
+    if option = get_option(rest) do
+      {:default, option}
     else
-      types[option_key]
+      :unknown
     end
   end
 end

lib/elixir/lib/path.ex

@@ -3,13 +3,13 @@ defmodule Path do
   This module provides conveniences for manipulating or
   retrieving file system paths.
 
-  The functions in this module may receive a chardata as
+  The functions in this module may receive a char data as
   argument (i.e. a string or a list of characters / string)
   and will always return a string (encoded in UTF-8).
 
   The majority of the functions in this module do not
   interact with the file system, except for a few functions
-  that require it (like `wildcard/2` and `expand/1`).
+  that require it (like `wildcard/1` and `expand/1`).
   """
 
   alias :filename, as: FN
@@ -69,15 +69,15 @@ defmodule Path do
   end
 
   # Absolute path on current drive
-  defp absname_vr(["/" | rest], [volume | _], _relative),
-    do: absname_join([volume | rest])
+  defp absname_vr(["/"|rest], [volume|_], _relative),
+    do: absname_join([volume|rest])
 
   # Relative to current directory on current drive.
-  defp absname_vr([<<x, ?:>> | rest], [<<x, _::binary>> | _], relative),
+  defp absname_vr([<<x, ?:>>|rest], [<<x, _ :: binary>>|_], relative),
     do: absname(absname_join(rest), relative)
 
   # Relative to current directory on another drive.
-  defp absname_vr([<<x, ?:>> | name], _, _relative) do
+  defp absname_vr([<<x, ?:>>|name], _, _relative) do
     cwd =
       case :file.get_cwd([x, ?:]) do
         {:ok, dir}  -> IO.chardata_to_string(dir)
@@ -87,8 +87,8 @@ defmodule Path do
   end
 
   # Joins a list
-  defp absname_join([name1, name2 | rest]), do:
-    absname_join([absname_join(name1, name2) | rest])
+  defp absname_join([name1, name2|rest]), do:
+    absname_join([absname_join(name1, name2)|rest])
   defp absname_join([name]), do:
     do_absname_join(IO.chardata_to_string(name), <<>>, [], major_os_type())
 
@@ -96,30 +96,30 @@ defmodule Path do
   defp absname_join(left, right),
     do: do_absname_join(IO.chardata_to_string(left), relative(right), [], major_os_type())
 
-  defp do_absname_join(<<uc_letter, ?:, rest::binary>>, relativename, [], :win32) when uc_letter in ?A..?Z, do:
+  defp do_absname_join(<<uc_letter, ?:, rest :: binary>>, relativename, [], :win32) when uc_letter in ?A..?Z, do:
     do_absname_join(rest, relativename, [?:, uc_letter+?a-?A], :win32)
-  defp do_absname_join(<<?\\, rest::binary>>, relativename, result, :win32), do:
-    do_absname_join(<<?/, rest::binary>>, relativename, result, :win32)
-  defp do_absname_join(<<?/, rest::binary>>, relativename, [?., ?/ | result], os_type), do:
-    do_absname_join(rest, relativename, [?/ | result], os_type)
-  defp do_absname_join(<<?/, rest::binary>>, relativename, [?/ | result], os_type), do:
-    do_absname_join(rest, relativename, [?/ | result], os_type)
+  defp do_absname_join(<<?\\, rest :: binary>>, relativename, result, :win32), do:
+    do_absname_join(<<?/, rest :: binary>>, relativename, result, :win32)
+  defp do_absname_join(<<?/, rest :: binary>>, relativename, [?., ?/|result], os_type), do:
+    do_absname_join(rest, relativename, [?/|result], os_type)
+  defp do_absname_join(<<?/, rest :: binary>>, relativename, [?/|result], os_type), do:
+    do_absname_join(rest, relativename, [?/|result], os_type)
   defp do_absname_join(<<>>, <<>>, result, os_type), do:
     IO.iodata_to_binary(reverse_maybe_remove_dirsep(result, os_type))
-  defp do_absname_join(<<>>, relativename, [?: | rest], :win32), do:
-    do_absname_join(relativename, <<>>, [?: | rest], :win32)
-  defp do_absname_join(<<>>, relativename, [?/ | result], os_type), do:
-    do_absname_join(relativename, <<>>, [?/ | result], os_type)
+  defp do_absname_join(<<>>, relativename, [?:|rest], :win32), do:
+    do_absname_join(relativename, <<>>, [?:|rest], :win32)
+  defp do_absname_join(<<>>, relativename, [?/|result], os_type), do:
+    do_absname_join(relativename, <<>>, [?/|result], os_type)
   defp do_absname_join(<<>>, relativename, result, os_type), do:
-    do_absname_join(relativename, <<>>, [?/ | result], os_type)
-  defp do_absname_join(<<char, rest::binary>>, relativename, result, os_type), do:
-    do_absname_join(rest, relativename, [char | result], os_type)
+    do_absname_join(relativename, <<>>, [?/|result], os_type)
+  defp do_absname_join(<<char, rest :: binary>>, relativename, result, os_type), do:
+    do_absname_join(rest, relativename, [char|result], os_type)
 
   defp reverse_maybe_remove_dirsep([?/, ?:, letter], :win32), do:
     [letter, ?:, ?/]
   defp reverse_maybe_remove_dirsep([?/], _), do:
     [?/]
-  defp reverse_maybe_remove_dirsep([?/ | name], _), do:
+  defp reverse_maybe_remove_dirsep([?/|name], _), do:
     :lists.reverse(name)
   defp reverse_maybe_remove_dirsep(name, _), do:
     :lists.reverse(name)
@@ -131,7 +131,7 @@ defmodule Path do
   ## Examples
 
       Path.expand("/foo/bar/../bar")
-      #=> "/foo/bar"
+      "/foo/bar"
 
   """
   @spec expand(t) :: binary
@@ -225,36 +225,36 @@ defmodule Path do
     end
   end
 
-  defp unix_pathtype(<<?/, relative::binary>>), do:
+  defp unix_pathtype(<<?/, relative :: binary>>), do:
     {:absolute, relative}
-  defp unix_pathtype([?/ | relative]), do:
+  defp unix_pathtype([?/|relative]), do:
     {:absolute, relative}
-  defp unix_pathtype([list | rest]) when is_list(list), do:
+  defp unix_pathtype([list|rest]) when is_list(list), do:
     unix_pathtype(list ++ rest)
   defp unix_pathtype(relative), do:
     {:relative, relative}
 
   @slash [?/, ?\\]
 
-  defp win32_pathtype([list | rest]) when is_list(list), do:
+  defp win32_pathtype([list|rest]) when is_list(list), do:
     win32_pathtype(list++rest)
-  defp win32_pathtype([char, list | rest]) when is_list(list), do:
-    win32_pathtype([char | list++rest])
-  defp win32_pathtype(<<c1, c2, relative::binary>>) when c1 in @slash and c2 in @slash, do:
+  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:
+  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:
+  defp win32_pathtype(<<_letter, ?:, c, relative :: binary>>) when c in @slash, do:
     {:absolute, relative}
-  defp win32_pathtype(<<_letter, ?:, relative::binary>>), do:
+  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([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:
@@ -267,7 +267,7 @@ defmodule Path do
   In other words, it tries to strip the `from` prefix from `path`.
 
   This function does not query the file system, so it assumes
-  no symlinks between the paths.
+  no symlinks in between the paths.
 
   In case a direct relative path cannot be found, it returns
   the original path.
@@ -290,11 +290,11 @@ defmodule Path do
     relative_to(split(path), split(from), path)
   end
 
-  defp relative_to([h | t1], [h | t2], original) do
+  defp relative_to([h|t1], [h|t2], original) do
     relative_to(t1, t2, original)
   end
 
-  defp relative_to([_ | _] = l1, [], _original) do
+  defp relative_to([_|_] = l1, [], _original) do
     join(l1)
   end
 
@@ -363,11 +363,10 @@ defmodule Path do
 
   ## Examples
 
-      iex> Path.dirname("/foo/bar.ex")
-      "/foo"
-
-      iex> Path.dirname("/foo/bar/baz.ex")
-      "/foo/bar"
+      Path.dirname("/foo/bar.ex")
+      #=> "/foo"
+      Path.dirname("/foo/bar/baz.ex")
+      #=> "/foo/bar"
 
   """
   @spec dirname(t) :: binary
@@ -446,8 +445,8 @@ defmodule Path do
 
   """
   @spec join([t]) :: binary
-  def join([name1, name2 | rest]), do:
-    join([join(name1, name2) | rest])
+  def join([name1, name2|rest]), do:
+    join([join(name1, name2)|rest])
   def join([name]), do:
     name
 
@@ -471,11 +470,10 @@ defmodule Path do
   end
 
   defp do_join("", right, os_type),   do: relative(right, os_type)
-  defp do_join("/", right, os_type),  do: "/" <> relative(right, os_type)
+  defp do_join(left, "", _os_type),   do: left
   defp do_join(left, right, os_type), do: remove_dirsep(left, os_type) <> "/" <> relative(right, os_type)
 
   defp remove_dirsep("", _os_type), do: ""
-  defp remove_dirsep("/", _os_type), do: "/"
   defp remove_dirsep(bin, os_type) do
     last = :binary.last(bin)
     if last == ?/ or (last == ?\\ and os_type == :win32) do
@@ -496,14 +494,14 @@ defmodule Path do
 
   ## Examples
 
-      iex> Path.split("")
-      []
+       iex> Path.split("")
+       []
 
-      iex> Path.split("foo")
-      ["foo"]
+       iex> Path.split("foo")
+       ["foo"]
 
-      iex> Path.split("/foo/bar")
-      ["/", "foo", "bar"]
+       iex> Path.split("/foo/bar")
+       ["/", "foo", "bar"]
 
   """
   @spec split(t) :: [binary]
@@ -547,8 +545,7 @@ defmodule Path do
   end
 
   @doc """
-  Traverses paths according to the given `glob` expression, and returns a
-  list of matches.
+  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
@@ -563,20 +560,16 @@ defmodule Path do
       files and zero or more directories and subdirectories
 
     * `[char1,char2,...]` - matches any of the characters listed; two
-      characters separated by a hyphen will match a range of characters.
-      Do not add spaces before and after the comma as it would then match
-      paths containing the space character itself.
+      characters separated by a hyphen will match a range of characters
 
     * `{item1,item2,...}` - matches one of the alternatives
-      Do not add spaces before and after the comma as it would then match
-      paths containing the space character itself.
 
   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".
 
   By default, the patterns `*` and `?` do not match files starting
-  with a dot `.` unless `match_dot: true` is given in `opts`.
+  with a dot `.` unless `match_dot: true` is given.
 
   ## Examples
 
@@ -591,7 +584,7 @@ defmodule Path do
       Path.wildcard("projects/*/ebin/**/*.{beam,app}")
 
   """
-  @spec wildcard(t, Keyword.t) :: [binary]
+  @spec wildcard(t) :: [binary]
   def wildcard(glob, opts \\ []) do
     mod = if Keyword.get(opts, :match_dot), do: :file, else: Path.Wildcard
     glob
@@ -634,28 +627,32 @@ defmodule Path do
     end
   end
 
-  defp expand_dot(<<"/", rest::binary>>),
-    do: "/" <> do_expand_dot(rest)
-  defp expand_dot(<<letter, ":/", rest::binary>>) when letter in ?a..?z,
-    do: <<letter, ":/">> <> do_expand_dot(rest)
+  defp expand_dot(<<"/../", rest::binary>>),
+    do: expand_dot("/" <> rest)
+  defp expand_dot(<<letter, ":/../", rest::binary>>) when letter in ?a..?z,
+    do: expand_dot(<<letter, ":/", rest::binary>>)
+  defp expand_dot("/.."),
+    do: "/"
+  defp expand_dot(<<letter, ":/..">>) when letter in ?a..?z,
+    do: expand_dot(<<letter, ":/">>)
   defp expand_dot(path),
-    do: do_expand_dot(path)
+    do: expand_dot(:binary.split(path, "/", [:global]), [])
 
-  defp do_expand_dot(path),
-    do: do_expand_dot(:binary.split(path, "/", [:global]), [])
+  defp expand_dot([".."|t], [_, _|acc]) do
+    expand_dot t, acc
+  end
 
-  defp do_expand_dot([".." | t], [_, _ | acc]),
-    do: do_expand_dot(t, acc)
-  defp do_expand_dot([".." | t], []),
-    do: do_expand_dot(t, [])
-  defp do_expand_dot(["." | t], acc),
-    do: do_expand_dot(t, acc)
-  defp do_expand_dot([h | t], acc),
-    do: do_expand_dot(t, ["/", h | acc])
-  defp do_expand_dot([], []),
-    do: ""
-  defp do_expand_dot([], ["/" | acc]),
-    do: IO.iodata_to_binary(:lists.reverse(acc))
+  defp expand_dot(["."|t], acc) do
+    expand_dot t, acc
+  end
+
+  defp expand_dot([h|t], acc) do
+    expand_dot t, ["/", h|acc]
+  end
+
+  defp expand_dot([], ["/"|acc]) do
+    IO.iodata_to_binary(:lists.reverse(acc))
+  end
 
   defp major_os_type do
     :os.type |> elem(0)

lib/elixir/lib/port.ex

@@ -3,145 +3,84 @@ defmodule Port do
   Functions related to Erlang ports.
   """
 
-  @type name :: {:spawn, charlist | binary} |
-                {:spawn_driver, charlist | binary} |
-                {:spawn_executable, charlist | atom} |
-                {:fd, non_neg_integer, non_neg_integer}
-
   @doc """
-  Opens an Erlang port given a tuple `name` and a list of `settings`.
-
-  ## Name
-
-  The supported values for `name` are:
-
-    * `{:spawn, command}` - to run an external program. The first space separated
-      word of `command` will be considered as the name of the program to run, so
-      use `{:spawn_executable, command}` to run a program having spaces in its name.
-    * `{:spawn_driver, command}` - similar to `{:spawn, command}`, but to run a
-      loaded driver.
-    * `{:spawn_executable, filename}` - similar to `{:spawn, filename}`, but to run
-      an external executable. With this option, `filename` in its whole is considered
-      the name of the program to execute.
-    * `{:fd, fd_in, fd_out}` - to access file descriptors used by Erlang, `fd_in`
-      being used for standard input, `fd_out` for standard output.
-
-  For more information, see [`:erlang.open_port/2`](http://www.erlang.org/doc/man/erlang.html#open_port-2).
+  See http://www.erlang.org/doc/man/erlang.html#open_port-2.
 
   Inlined by the compiler.
   """
-  @spec open(name, list) :: port
   def open(name, settings) do
     :erlang.open_port(name, settings)
   end
 
   @doc """
-  Closes the `port`.
-
-  For more information, see [`:erlang.port_close/1`](http://www.erlang.org/doc/man/erlang.html#port_close-1).
+  See http://www.erlang.org/doc/man/erlang.html#port_close-1.
 
   Inlined by the compiler.
   """
-  @spec close(port) :: true
   def close(port) do
     :erlang.port_close(port)
   end
 
   @doc """
-  Sends `data` to the port driver `port`.
-
-  For more information, see [`:erlang.port_command/2`](http://www.erlang.org/doc/man/erlang.html#port_command-2).
+  See http://www.erlang.org/doc/man/erlang.html#port_command-2.
 
   Inlined by the compiler.
   """
-  @spec command(port, iodata, [:force | :nosuspend]) :: boolean
   def command(port, data, options \\ []) do
     :erlang.port_command(port, data, options)
   end
 
   @doc """
-  Associates the `port` identifier with a `pid`.
-
-  For more information, see [`:erlang.port_connect/2`](http://www.erlang.org/doc/man/erlang.html#port_connect-2).
+  See http://www.erlang.org/doc/man/erlang.html#port_connect-2.
 
   Inlined by the compiler.
   """
-  @spec connect(port, pid) :: true
   def connect(port, pid) do
     :erlang.port_connect(port, pid)
   end
 
   @doc """
-  Sends a synchronous control command to the `port` and returns its reply as a binary.
-
-  Not all port drivers support this feature.
-
-  For more information, see [`:erlang.port_control/3`](http://www.erlang.org/doc/man/erlang.html#port_control-3).
+  See http://www.erlang.org/doc/man/erlang.html#port_control-3.
 
   Inlined by the compiler.
   """
-  @spec control(port, integer, iodata) :: iodata | binary
   def control(port, operation, data) do
     :erlang.port_control(port, operation, data)
   end
 
   @doc """
-  Makes a synchronous call to the `port` and returns its reply as a term.
-
-  Not all port drivers support this control feature.
-
-  For more information, see [`:erlang.port_call/3`](http://www.erlang.org/doc/man/erlang.html#port_call-3).
+  See http://www.erlang.org/doc/man/erlang.html#port_call-3.
 
   Inlined by the compiler.
   """
-  @spec call(port, integer, term) :: term
   def call(port, operation, data) do
     :erlang.port_call(port, operation, data)
   end
 
   @doc """
-  Returns information about the `port`
-  or `nil` if the port is closed.
+  See http://www.erlang.org/doc/man/erlang.html#port_info-1.
 
-  For more information, see [`:erlang.port_info/1`](http://www.erlang.org/doc/man/erlang.html#port_info-1).
+  Inlined by the compiler.
   """
   def info(port) do
-    nillify :erlang.port_info(port)
+    :erlang.port_info(port)
   end
 
   @doc """
-  Returns information about the `port`
-  or `nil` if the port is closed.
+  See http://www.erlang.org/doc/man/erlang.html#port_info-2.
 
-  For more information, see [`:erlang.port_info/2`](http://www.erlang.org/doc/man/erlang.html#port_info-2).
+  Inlined by the compiler.
   """
-  @spec info(port, atom) :: {atom, term} | nil
-  def info(port, spec)
-
-  def info(port, :registered_name) do
-    case :erlang.port_info(port, :registered_name) do
-      [] -> {:registered_name, []}
-      other -> nillify(other)
-    end
-  end
-
   def info(port, item) do
-    nillify :erlang.port_info(port, item)
+    :erlang.port_info(port, item)
   end
 
   @doc """
-  Returns a list of the ports for the current node.
-
-  For more information, see [`:erlang.ports/0`](http://www.erlang.org/doc/man/erlang.html#ports-0).
+  See http://www.erlang.org/doc/man/erlang.html#ports-0.
 
   Inlined by the compiler.
   """
-  @spec list :: [port]
   def list do
     :erlang.ports
   end
-
-  @compile {:inline, nillify: 1}
-  defp nillify(:undefined), do: nil
-  defp nillify(other),      do: other
-end
+end

lib/elixir/lib/process.ex

@@ -15,12 +15,10 @@ defmodule Process do
   """
 
   @doc """
-  Returns `true` if the process exists and is alive (i.e. it is not exiting
-  and has not exited yet). Otherwise, returns `false`.
+  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.
-
-  Inlined by the compiler.
   """
   @spec alive?(pid) :: boolean
   def alive?(pid) do
@@ -28,9 +26,7 @@ defmodule Process do
   end
 
   @doc """
-  Returns all key-value pairs in the process dictionary.
-
-  Inlined by the compiler.
+  Returns all key-values in the dictionary.
   """
   @spec get :: [{term, term}]
   def get do
@@ -38,7 +34,7 @@ defmodule Process do
   end
 
   @doc """
-  Returns the value for the given `key` or `default` if `key` is not set.
+  Returns the value for the given `key`.
   """
   @spec get(term) :: term
   @spec get(term, default :: term) :: term
@@ -51,20 +47,8 @@ defmodule Process do
     end
   end
 
-  @doc """
-  Returns all keys in the process dictionary.
-
-  Inlined by the compiler.
-  """
-  @spec get_keys() :: [term]
-  def get_keys() do
-    :erlang.get_keys()
-  end
-
   @doc """
   Returns all keys that have the given `value`.
-
-  Inlined by the compiler.
   """
   @spec get_keys(term) :: [term]
   def get_keys(value) do
@@ -72,10 +56,7 @@ defmodule Process do
   end
 
   @doc """
-  Stores the given `key`-`value` pair in the process dictionary.
-
-  The return value is the value that was previously stored under the key `key`
-  (or `nil` in case no value was stored under `key`).
+  Stores the given key-value in the process dictionary.
   """
   @spec put(term, term) :: term | nil
   def put(key, value) do
@@ -83,7 +64,7 @@ defmodule Process do
   end
 
   @doc """
-  Deletes the given `key` from the process dictionary.
+  Deletes the given `key` from the dictionary.
   """
   @spec delete(term) :: term | nil
   def delete(key) do
@@ -91,27 +72,22 @@ defmodule Process do
   end
 
   @doc """
-  Sends an exit signal with the given `reason` to the `pid`.
+  Sends an exit signal with the given reason to the pid.
 
-  The following behaviour applies if `reason` is any term except `:normal`
-  or `:kill`:
+  The following behaviour applies if reason is any term except `:normal` or `:kill`:
 
-    1. If `pid` is not trapping exits, `pid` will exit with the given
-       `reason`.
+    1. If pid is not trapping exits, pid will exit with the given reason.
 
-    2. If `pid` is trapping exits, the exit signal is transformed into a
-       message `{:EXIT, from, reason}` and delivered to the message queue
-       of `pid`.
+    2. If pid is trapping exits, the exit signal is transformed into a message
+       `{:EXIT, from, reason}` and delivered to the message queue of pid.
 
-    3. If `reason` is the atom `:normal`, `pid` will not exit (unless it
-       is the calling process's pid, in which case it will exit with the
-       reason `:normal`). If it is trapping exits, the exit signal is
-       transformed into a message `{:EXIT, from, :normal}` and delivered
-       to its message queue.
+    3. If reason is the atom `:normal`, pid will not exit. If it is trapping
+       exits, the exit signal is transformed into a message `{:EXIT, from,
+       :normal}` and delivered to its message queue.
 
-    4. If `reason` is the atom `:kill`, that is if `exit(pid, :kill)` is
-       called, an untrappable exit signal is sent to `pid` which will
-       unconditionally exit with exit reason `:killed`.
+    4. If reason is the atom `:kill`, that is if `exit(pid, :kill)` is called,
+       an untrappable exit signal is sent to pid which will unconditionally
+       exit with exit reason `:killed`.
 
   Inlined by the compiler.
 
@@ -125,80 +101,6 @@ defmodule Process do
     :erlang.exit(pid, reason)
   end
 
-  @doc """
-  Sleeps the current process by `timeout`.
-
-  `timeout` is either the number of milliseconds to sleep as an
-  integer or the atom `:infinity`. When `:infinity` is given,
-  the current process will suspend forever.
-
-  **Use this function with extreme care**. For almost all situations
-  where you would use `sleep/1` in Elixir, there is likely a
-  more correct, faster and precise way of achieving it with
-  message passing.
-
-  For example, if you are waiting a process to perform some
-  action, it is better to communicate.
-
-  In other words, **do not**:
-
-      Task.start_link fn ->
-        do_something()
-        ...
-      end
-
-      # Wait until work is done
-      Process.sleep(2000)
-
-  But **do**:
-
-      parent = self()
-      Task.start_link fn ->
-        do_something()
-        send parent, :work_is_done
-        ...
-      end
-
-      receive do
-        :work_is_done -> :ok
-      after
-        30_000 -> :timeout # Optional timeout
-      end
-
-  Or even use `Task.async/1` and `Task.await/2` in the example
-  above.
-
-  Similarly, if you are waiting for a process to terminate,
-  use monitor instead of sleep. **Do not**:
-
-      Task.start_link fn ->
-        ...
-      end
-
-      # Wait until task terminates
-      Process.sleep(2000)
-
-  Instead **do**:
-
-      {:ok, pid} =
-        Task.start_link fn ->
-          ...
-        end
-
-      ref = Process.monitor(pid)
-      receive do
-        {:DOWN, ^ref, _, _, _} -> :task_is_down
-      after
-        30_000 -> :timeout # Optional timeout
-      end
-
-  """
-  def sleep(timeout)
-      when is_integer(timeout) and timeout >= 0
-      when timeout == :infinity do
-    receive after: (timeout -> :ok)
-  end
-
   @doc """
   Sends a message to the given process.
 
@@ -217,10 +119,11 @@ defmodule Process do
       :noconnect
 
   """
-  @spec send(dest, msg, [option]) :: :ok | :noconnect | :nosuspend when
+  @spec send(dest, msg, [option]) ::  result when
         dest: pid | port | atom | {atom, node},
         msg: any,
-        option: :noconnect | :nosuspend
+        option: :noconnect | :nosuspend,
+        result: :ok | :noconnect | :nosuspend
   def send(dest, msg, options) do
     :erlang.send(dest, msg, options)
   end
@@ -234,7 +137,8 @@ defmodule Process do
   not refer to a process.
 
   This function returns a timer reference, which can be read or canceled with
-  `read_timer/1` and `cancel_timer/1`.
+  `:erlang.read_timer/1`, `:erlang.start_timer/3` and `:erlang.cancel_timer/1`.
+  Note `time` cannot be greater than `4294967295`.
 
   Finally, the timer will be automatically canceled if the given `dest` is a pid
   which is not alive or when the given pid exits. Note that timers will not be
@@ -246,46 +150,6 @@ defmodule Process do
     :erlang.send_after(time, dest, msg)
   end
 
-  @doc """
-  Cancels a timer created by `send_after/3`.
-
-  When the result is an integer, it represents the time in milliseconds
-  left until the timer would have expired.
-
-  When the result is `false`, a timer corresponding to `timer_ref` could
-  not be found. This can be either because the timer expired, already has
-  been canceled, or because `timer_ref` never corresponded to a timer.
-
-  If the timer has expired, the timeout message has been sent, but it does
-  not tell you whether or not it has arrived at its destination yet.
-
-  Inlined by the compiler.
-  """
-  @spec cancel_timer(reference) :: non_neg_integer | false
-  def cancel_timer(timer_ref) do
-    :erlang.cancel_timer(timer_ref)
-  end
-
-  @doc """
-  Reads a timer created by `send_after/3`.
-
-  When the result is an integer, it represents the time in milliseconds
-  left until the timer will expire.
-
-  When the result is `false`, a timer corresponding to `timer_ref` could
-  not be found. This can be either because the timer expired, already has
-  been canceled, or because `timer_ref` never corresponded to a timer.
-
-  If the timer has expired, the timeout message has been sent, but it does
-  not tell you whether or not it has arrived at its destination yet.
-
-  Inlined by the compiler.
-  """
-  @spec read_timer(reference) :: non_neg_integer | false
-  def read_timer(timer_ref) do
-    :erlang.read_timer(timer_ref)
-  end
-
   @type spawn_opt  :: :link | :monitor | {:priority, :low | :normal | :high} |
                       {:fullsweep_after, non_neg_integer} |
                       {:min_heap_size, non_neg_integer} |
@@ -293,7 +157,8 @@ defmodule Process do
   @type spawn_opts :: [spawn_opt]
 
   @doc """
-  Spawns the given function according to the given options.
+  Spawns the given module and function passing the given args
+  according to the given options.
 
   The result depends on the given options. In particular,
   if `:monitor` is given as an option, it will return a tuple
@@ -301,7 +166,7 @@ defmodule Process do
   just the spawned process pid.
 
   It also accepts extra options, for the list of available options
-  check [`:erlang.spawn_opt/4`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-4).
+  check http://www.erlang.org/doc/man/erlang.html#spawn_opt-4
 
   Inlined by the compiler.
   """
@@ -311,7 +176,7 @@ defmodule Process do
   end
 
   @doc """
-  Spawns the given function from module `mod`, passing the given `args`
+  Spawns the given module and function passing the given args
   according to the given options.
 
   The result depends on the given options. In particular,
@@ -320,7 +185,7 @@ defmodule Process do
   just the spawned process pid.
 
   It also accepts extra options, for the list of available options
-  check [`:erlang.spawn_opt/4`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-4).
+  check http://www.erlang.org/doc/man/erlang.html#spawn_opt-4
 
   Inlined by the compiler.
   """
@@ -330,12 +195,10 @@ defmodule Process do
   end
 
   @doc """
-  The calling process starts monitoring the given `item`.
+  The calling process starts monitoring the item given.
   It returns the monitor reference.
 
-  See [the need for monitoring](http://elixir-lang.org/getting-started/mix-otp/genserver.html#the-need-for-monitoring)
-  for an example.
-  See [`:erlang.monitor/2`](http://www.erlang.org/doc/man/erlang.html#monitor-2) for more info.
+  See http://www.erlang.org/doc/man/erlang.html#monitor-2 for more info.
 
   Inlined by the compiler.
   """
@@ -349,7 +212,7 @@ defmodule Process do
   obtained by calling `monitor/1`, this monitoring is turned off.
   If the monitoring is already turned off, nothing happens.
 
-  See [`:erlang.demonitor/2`](http://www.erlang.org/doc/man/erlang.html#demonitor-2) for more info.
+  See http://www.erlang.org/doc/man/erlang.html#demonitor-2 for more info.
 
   Inlined by the compiler.
   """
@@ -367,7 +230,7 @@ defmodule Process do
   `alive?/1` will return `false` for a process that is exiting,
   but its process identifier will be part of the result returned.
 
-  See [`:erlang.processes/0`](http://www.erlang.org/doc/man/erlang.html#processes-0) for more info.
+  See http://www.erlang.org/doc/man/erlang.html#processes-0 for more info.
   """
   @spec list :: [pid]
   def list do
@@ -378,7 +241,7 @@ defmodule Process do
   Creates a link between the calling process and another process
   (or port) `pid`, if there is not such a link already.
 
-  See [`:erlang.link/1`](http://www.erlang.org/doc/man/erlang.html#link-1) for more info.
+  See http://www.erlang.org/doc/man/erlang.html#link-1 for more info.
 
   Inlined by the compiler.
   """
@@ -392,7 +255,7 @@ defmodule Process do
   the process or port referred to by `pid`. Returns `true` and does not
   fail, even if there is no link or `id` does not exist
 
-  See [`:erlang.unlink/1`](http://www.erlang.org/doc/man/erlang.html#unlink-1) for more info.
+  See http://www.erlang.org/doc/man/erlang.html#unlink-1 for more info.
 
   Inlined by the compiler.
   """
@@ -402,24 +265,23 @@ defmodule Process do
   end
 
   @doc """
-  Associates the atom `name` with a `pid` or a port identifier.
+  Associates the name with a pid or a port identifier. `name`, which must
+  be an atom, can be used instead of the pid / port identifier with the
+  `Kernel.send/2` function.
 
-  `name`, can then be used instead of the `pid` / port identifier with the `Kernel.send/2`
-  function. `Process.register/2` will fail with `ArgumentError` if the pid supplied
-  is no longer alive, (check with `alive?/1`) or if the name is already registered
-  (check with `whereis/1`) or if the `pid` is already registered to a different `name`.
+  `Process.register/2` will fail with `ArgumentError` if the pid supplied
+  is no longer alive, (check with `alive?/1`) or if the name is
+  already registered (check with `whereis/1`).
   """
   @spec register(pid | port, atom) :: true
-  def register(pid, name) when not name in [nil, false, true] and is_atom(name) do
+  def register(pid, name) when not name in [nil, false, true] do
     :erlang.register(name, pid)
   end
 
   @doc """
-  Removes the registered `name`, associated with a pid or a port identifier.
+  Removes the registered name, associated with a pid or a port identifier.
 
-  Fails with `ArgumentError` if the name is not registered to any pid or port.
-
-  See [`:erlang.unregister/1`](http://www.erlang.org/doc/man/erlang.html#unregister-1) for more info.
+  See http://www.erlang.org/doc/man/erlang.html#unregister-1 for more info.
   """
   @spec unregister(atom) :: true
   def unregister(name) do
@@ -427,10 +289,10 @@ defmodule Process do
   end
 
   @doc """
-  Returns the pid or port identifier with the registered `name`.
+  Returns the pid or port identifier with the registered name.
   Returns `nil` if the name is not registered.
 
-  See [`:erlang.whereis/1`](http://www.erlang.org/doc/man/erlang.html#whereis-1) for more info.
+  See http://www.erlang.org/doc/man/erlang.html#whereis-1 for more info.
   """
   @spec whereis(atom) :: pid | port | nil
   def whereis(name) do
@@ -467,9 +329,9 @@ defmodule Process do
                          :sensitive
   @doc """
   Sets certain flags for the process which calls this function.
-  Returns the old value of the `flag`.
+  Returns the old value of the flag.
 
-  See [`:erlang.process_flag/2`](http://www.erlang.org/doc/man/erlang.html#process_flag-2) for more info.
+  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
@@ -478,10 +340,10 @@ defmodule Process do
 
   @doc """
   Sets certain flags for the process `pid`, in the same manner as `flag/2`.
-  Returns the old value of the `flag`. The allowed values for `flag` are
-  only a subset of those allowed in `flag/2`, namely `:save_calls`.
+  Returns the old value of the flag. The allowed values for `flag` are
+  only a subset of those allowed in `flag/2`, namely: `save_calls`.
 
-  See [`:erlang.process_flag/3`](http://www.erlang.org/doc/man/erlang.html#process_flag-3) for more info.
+  See http://www.erlang.org/doc/man/erlang.html#process_flag-3 for more info.
   """
   @spec flag(pid, :save_calls, non_neg_integer) :: non_neg_integer
   def flag(pid, flag, value) do
@@ -489,11 +351,11 @@ defmodule Process do
   end
 
   @doc """
-  Returns information about the process identified by `pid`, or returns `nil` if the process
+  Returns information about the process identified by `pid` or `nil` if the process
   is not alive.
   Use this only for debugging information.
 
-  See [`:erlang.process_info/1`](http://www.erlang.org/doc/man/erlang.html#process_info-1) for more info.
+  See http://www.erlang.org/doc/man/erlang.html#process_info-1 for more info.
   """
   @spec info(pid) :: Keyword.t
   def info(pid) do
@@ -501,12 +363,12 @@ defmodule Process do
   end
 
   @doc """
-  Returns information about the process identified by `pid`,
-  or returns `nil` if the process is not alive.
+  Returns information about the process identified by `pid`
+  or `nil` if the process is not alive.
 
-  See [`:erlang.process_info/2`](http://www.erlang.org/doc/man/erlang.html#process_info-2) for more info.
+  See http://www.erlang.org/doc/man/erlang.html#process_info-2 for more info.
   """
-  @spec info(pid, atom | [atom]) :: {atom, term} | [{atom, term}]  | nil
+  @spec info(pid, atom) :: {atom, term} | nil
   def info(pid, spec)
 
   def info(pid, :registered_name) do
@@ -517,25 +379,10 @@ defmodule Process do
     end
   end
 
-  def info(pid, spec) when is_atom(spec) or is_list(spec) do
+  def info(pid, spec) when is_atom(spec) do
     nillify :erlang.process_info(pid, spec)
   end
 
-  @doc """
-  Puts the calling process into a wait state
-  where its memory allocation has been reduced as much as possible,
-  which is useful if the process does not expect to receive any messages
-  in the near future.
-
-  See [`:erlang.hibernate/3`](http://www.erlang.org/doc/man/erlang.html#hibernate-3) for more info.
-
-  Inlined by the compiler.
-  """
-  @spec hibernate(module, atom, list) :: no_return
-  def hibernate(mod, fun, args) do
-    :erlang.hibernate(mod, fun, args)
-  end
-
   @compile {:inline, nillify: 1}
   defp nillify(:undefined), do: nil
   defp nillify(other),      do: other

lib/elixir/lib/protocol.ex

@@ -19,19 +19,18 @@ defmodule Protocol do
   defmacro def({name, _, args}) when is_atom(name) and is_list(args) do
     arity = length(args)
 
-    type_args = :lists.map(fn _ -> quote(do: term) end,
-                           :lists.seq(2, arity))
+    type_args = for _ <- :lists.seq(2, arity), do: quote(do: term)
     type_args = [quote(do: t) | type_args]
 
-    call_args = :lists.map(fn i -> {String.to_atom(<<?x, i + 64>>), [], __MODULE__} end,
-                           :lists.seq(2, arity))
+    call_args = for i <- :lists.seq(2, arity),
+                  do: {String.to_atom(<<?x, i + 64>>), [], __MODULE__}
     call_args = [quote(do: t) | call_args]
 
     quote do
       name  = unquote(name)
       arity = unquote(arity)
 
-      @functions [{name, arity} | @functions]
+      @functions [{name, arity}|@functions]
 
       # Generate a fake definition with the user
       # signature that will be used by docs
@@ -56,7 +55,7 @@ defmodule Protocol do
   @doc """
   Checks if the given module is loaded and is protocol.
 
-  Returns `:ok` if so, otherwise raises `ArgumentError`.
+  Returns `:ok` if so, otherwise raises ArgumentError.
   """
   @spec assert_protocol!(module) :: :ok | no_return
   def assert_protocol!(module) do
@@ -70,7 +69,7 @@ defmodule Protocol do
     end
 
     try do
-      module.__protocol__(:module)
+      module.__protocol__(:name)
     rescue
       UndefinedFunctionError ->
         raise ArgumentError, "#{inspect module} is not a protocol" <> extra
@@ -83,7 +82,7 @@ defmodule Protocol do
   Checks if the given module is loaded and is an implementation
   of the given protocol.
 
-  Returns `:ok` if so, otherwise raises `ArgumentError`.
+  Returns `:ok` if so, otherwise raises ArgumentError.
   """
   @spec assert_impl!(module, module) :: :ok | no_return
   def assert_impl!(protocol, base) do
@@ -115,7 +114,7 @@ defmodule Protocol do
   end
 
   @doc """
-  Derives the `protocol` for `module` with the given options.
+  Derive the `protocol` for `module` with the given options.
   """
   defmacro derive(protocol, module, options \\ []) do
     quote do
@@ -127,10 +126,10 @@ defmodule Protocol do
   ## Consolidation
 
   @doc """
-  Extracts all protocols from the given paths.
+  Extract all protocols from the given paths.
 
-  The paths can be either a charlist or a string. Internally
-  they are worked on as charlists, so passing them as lists
+  The paths can be either a char list or a string. Internally
+  they are worked on as char lists, so passing them as lists
   avoid extra conversion.
 
   Does not load any of the protocols.
@@ -144,23 +143,23 @@ defmodule Protocol do
       true
 
   """
-  @spec extract_protocols([charlist | String.t]) :: [atom]
+  @spec extract_protocols([char_list | String.t]) :: [atom]
   def extract_protocols(paths) do
     extract_matching_by_attribute paths, 'Elixir.',
       fn module, attributes ->
         case attributes[:protocol] do
-          [fallback_to_any: _] -> module
+          [fallback_to_any: _, consolidated: _] -> module
           _ -> nil
         end
       end
   end
 
   @doc """
-  Extracts all types implemented for the given protocol from
+  Extract all types implemented for the given protocol from
   the given paths.
 
-  The paths can be either a charlist or a string. Internally
-  they are worked on as charlists, so passing them as lists
+  The paths can be either a char list or a string. Internally
+  they are worked on as char lists, so passing them as lists
   avoid extra conversion.
 
   Does not load any of the implementations.
@@ -174,9 +173,9 @@ defmodule Protocol do
       true
 
   """
-  @spec extract_impls(module, [charlist | String.t]) :: [atom]
+  @spec extract_impls(module, [char_list | String.t]) :: [atom]
   def extract_impls(protocol, paths) when is_atom(protocol) do
-    prefix = Atom.to_charlist(protocol) ++ '.'
+    prefix = Atom.to_char_list(protocol) ++ '.'
     extract_matching_by_attribute paths, prefix, fn
       _mod, attributes ->
         case attributes[:impl] do
@@ -200,7 +199,7 @@ defmodule Protocol do
     end
   end
 
-  defp list_dir(path), do: list_dir(to_charlist(path))
+  defp list_dir(path), do: list_dir(to_char_list(path))
 
   defp extract_from_file(path, file, prefix, callback) do
     if :lists.prefix(prefix, file) and :filename.extension(file) == '.beam' do
@@ -217,12 +216,21 @@ defmodule Protocol do
     end
   end
 
+  defmacrop if_ok(expr, call) do
+    quote do
+      case unquote(expr) do
+        {:ok, var} -> unquote(Macro.pipe(quote(do: var), call, 0))
+        other -> other
+      end
+    end
+  end
+
   @doc """
-  Returns `true` if the protocol was consolidated.
+  Returns true if the protocol was consolidated.
   """
   @spec consolidated?(module) :: boolean
   def consolidated?(protocol) do
-    protocol.__protocol__(:consolidated?)
+    protocol.__info__(:attributes)[:protocol][:consolidated]
   end
 
   @doc """
@@ -241,7 +249,7 @@ defmodule Protocol do
 
       Protocol.consolidated?(Enumerable)
 
-  If the first element of the tuple is `true`, it means
+  If the first element of the tuple is true, it means
   the protocol was consolidated.
 
   This function does not load the protocol at any point
@@ -254,9 +262,9 @@ defmodule Protocol do
     {:error, :not_a_protocol} |
     {:error, :no_beam_info}
   def consolidate(protocol, types) when is_atom(protocol) do
-    with {:ok, info} <- beam_protocol(protocol),
-         {:ok, code, docs} <- change_debug_info(info, types),
-         do: compile(code, docs)
+    beam_protocol(protocol)
+    |> if_ok(change_debug_info types)
+    |> if_ok(compile)
   end
 
   @docs_chunk 'ExDc'
@@ -269,7 +277,7 @@ defmodule Protocol do
                          {:attributes, attributes},
                          {@docs_chunk, docs}]}} ->
         case attributes[:protocol] do
-          [fallback_to_any: any] ->
+          [fallback_to_any: any, consolidated: _] ->
             {:ok, {protocol, any, abstract_code, docs}}
           _ ->
             {:error, :not_a_protocol}
@@ -290,51 +298,45 @@ defmodule Protocol do
   # impl_for/1 dispatch version.
   defp change_debug_info({protocol, any, code, docs}, types) do
     types   = if any, do: types, else: List.delete(types, Any)
-    all     = [Any] ++ for {_guard, mod} <- __builtin__(), do: mod
+    all     = [Any] ++ for {_guard, mod} <- builtin, do: mod
     structs = types -- all
     case change_impl_for(code, protocol, types, structs, false, []) do
-      {:ok, ret} -> {:ok, ret, docs}
+      {:ok, ret} -> {:ok, {ret, docs}}
       other      -> other
     end
   end
 
-  defp change_impl_for([{:function, line, :__protocol__, 1, clauses} | t], protocol, types, structs, _, acc) do
-    clauses = :lists.map(fn
-      {:clause, l, [{:atom, _, :consolidated?}], [], [{:atom, _, _}]} ->
-        {:clause, l, [{:atom, 0, :consolidated?}], [], [{:atom, 0, true}]}
-      {:clause, _, _, _, _} = c ->
-        c
-    end, clauses)
-
+  defp change_impl_for([{:attribute, line, :protocol, opts}|t], protocol, types, structs, _, acc) do
+    opts = [fallback_to_any: opts[:fallback_to_any], consolidated: true]
     change_impl_for(t, protocol, types, structs, true,
-                    [{:function, line, :__protocol__, 1, clauses} | acc])
+                    [{:attribute, line, :protocol, opts}|acc])
   end
 
-  defp change_impl_for([{:function, line, :impl_for, 1, _} | t], protocol, types, structs, is_protocol, acc) do
-    fallback = if Any in types, do: load_impl(protocol, Any)
+  defp change_impl_for([{:function, line, :impl_for, 1, _}|t], protocol, types, structs, is_protocol, acc) do
+    fallback = if Any in types, do: load_impl(protocol, Any), else: nil
 
-    clauses = for {guard, mod} <- __builtin__(),
+    clauses = for {guard, mod} <- builtin,
                   mod in types,
                   do: builtin_clause_for(mod, guard, protocol, line)
 
-    clauses = [struct_clause_for(line) | clauses] ++
+    clauses = [struct_clause_for(line)|clauses] ++
               [fallback_clause_for(fallback, protocol, line)]
 
     change_impl_for(t, protocol, types, structs, is_protocol,
-                    [{:function, line, :impl_for, 1, clauses} | acc])
+                    [{:function, line, :impl_for, 1, clauses}|acc])
   end
 
-  defp change_impl_for([{:function, line, :struct_impl_for, 1, _} | t], protocol, types, structs, is_protocol, acc) do
-    fallback = if Any in types, do: load_impl(protocol, Any)
+  defp change_impl_for([{:function, line, :struct_impl_for, 1, _}|t], protocol, types, structs, is_protocol, acc) do
+    fallback = if Any in types, do: load_impl(protocol, Any), else: nil
     clauses = for struct <- structs, do: each_struct_clause_for(struct, protocol, line)
     clauses = clauses ++ [fallback_clause_for(fallback, protocol, line)]
 
     change_impl_for(t, protocol, types, structs, is_protocol,
-                    [{:function, line, :struct_impl_for, 1, clauses} | acc])
+                    [{:function, line, :struct_impl_for, 1, clauses}|acc])
   end
 
-  defp change_impl_for([h | t], protocol, info, types, is_protocol, acc) do
-    change_impl_for(t, protocol, info, types, is_protocol, [h | acc])
+  defp change_impl_for([h|t], protocol, info, types, is_protocol, acc) do
+    change_impl_for(t, protocol, info, types, is_protocol, [h|acc])
   end
 
   defp change_impl_for([], protocol, _info, _types, is_protocol, acc) do
@@ -384,14 +386,13 @@ defmodule Protocol do
   end
 
   # Finally compile the module and emit its bytecode.
-  defp compile({protocol, code}, docs) do
+  defp compile({{protocol, code}, docs}) do
     opts = if Code.compiler_options[:debug_info], do: [:debug_info], else: []
-    {:ok, ^protocol, binary, _warnings} = :compile.forms(code, [:return | opts])
-    {:ok,
-      case docs do
-        :missing_chunk -> binary
-        _ -> :elixir_module.add_beam_chunk(binary, @docs_chunk, docs)
-      end}
+    {:ok, ^protocol, binary, _warnings} = :compile.forms(code, [:return|opts])
+    unless docs == :missing_chunk do
+      binary = :elixir_module.add_beam_chunk(binary, @docs_chunk, docs)
+    end
+    {:ok, binary}
   end
 
   ## Definition callbacks
@@ -417,7 +418,7 @@ defmodule Protocol do
         @fallback_to_any false
 
         # Invoke the user given block
-        _ = unquote(block)
+        unquote(block)
 
         # Finalize expansion
         unquote(after_defprotocol)
@@ -426,9 +427,8 @@ defmodule Protocol do
   end
 
   defp after_defprotocol do
-    quote bind_quoted: [builtin: __builtin__()] do
-      @doc false
-      @spec impl_for(term) :: atom | nil
+    quote bind_quoted: [builtin: builtin] do
+      @spec impl_for(term) :: atom() | nil
       Kernel.def impl_for(data)
 
       # Define the implementation for structs.
@@ -440,7 +440,7 @@ defmodule Protocol do
       end
 
       # Define the implementation for builtins.
-      :lists.foreach(fn {guard, mod} ->
+      for {guard, mod} <- builtin do
         target = Module.concat(__MODULE__, mod)
 
         Kernel.def impl_for(data) when :erlang.unquote(guard)(data) do
@@ -449,17 +449,21 @@ defmodule Protocol do
             false -> any_impl_for
           end
         end
-      end, builtin)
+      end
 
-      @doc false
-      @spec impl_for!(term) :: atom | no_return
+      @spec impl_for!(term) :: atom() | no_return()
       Kernel.def impl_for!(data) do
         impl_for(data) || raise(Protocol.UndefinedError, protocol: __MODULE__, value: data)
       end
 
       # Internal handler for Any
       if @fallback_to_any do
-        Kernel.defp any_impl_for, do: __MODULE__.Any.__impl__(:target)
+        Kernel.defp any_impl_for do
+          case impl_for?(__MODULE__.Any) do
+            true  -> __MODULE__.Any.__impl__(:target)
+            false -> nil
+          end
+        end
       else
         Kernel.defp any_impl_for, do: nil
       end
@@ -489,22 +493,20 @@ defmodule Protocol do
       # Store information as an attribute so it
       # can be read without loading the module.
       Module.register_attribute(__MODULE__, :protocol, persist: true)
-      @protocol [fallback_to_any: !!@fallback_to_any]
+      @protocol [fallback_to_any: !!@fallback_to_any, consolidated: false]
 
       @doc false
-      @spec __protocol__(:module) :: __MODULE__
+      @spec __protocol__(:name) :: __MODULE__
       @spec __protocol__(:functions) :: unquote(Protocol.__functions_spec__(@functions))
-      @spec __protocol__(:consolidated?) :: boolean
-      Kernel.def __protocol__(:module), do: __MODULE__
+      Kernel.def __protocol__(:name), do: __MODULE__
       Kernel.def __protocol__(:functions), do: unquote(:lists.sort(@functions))
-      Kernel.def __protocol__(:consolidated?), do: false
     end
   end
 
   @doc false
   def __functions_spec__([]),
     do: []
-  def __functions_spec__([h | t]),
+  def __functions_spec__([h|t]),
     do: [:lists.foldl(&{:|, [], [&1, &2]}, h, t), quote(do: ...)]
 
   @doc false
@@ -520,7 +522,7 @@ defmodule Protocol do
     # Unquote the implementation just later
     # when all variables will already be injected
     # into the module body.
-    impl =
+    __impl__ =
       quote unquote: false do
         @doc false
         @spec __impl__(:for) :: unquote(for)
@@ -537,7 +539,6 @@ defmodule Protocol do
       name     = Module.concat(protocol, for)
 
       Protocol.assert_protocol!(protocol)
-      Protocol.__ensure_defimpl__(protocol, for, __ENV__)
 
       defmodule name do
         @behaviour protocol
@@ -549,7 +550,7 @@ defmodule Protocol do
         Module.register_attribute(__MODULE__, :impl, persist: true)
         @impl [protocol: @protocol, for: @for]
 
-        unquote(impl)
+        unquote(__impl__)
       end
     end
   end
@@ -577,13 +578,12 @@ defmodule Protocol do
   defp derive(protocol, for, struct, opts, env) do
     extra = ", cannot derive #{inspect protocol} for #{inspect for}"
     assert_protocol!(protocol, extra)
-    __ensure_defimpl__(protocol, for, env)
-    assert_impl!(protocol, Any, extra)
+    assert_impl!(protocol, Map, extra)
 
     # Clean up variables from eval context
     env  = %{env | vars: [], export_vars: nil}
     args = [for, struct, opts]
-    impl = Module.concat(protocol, Any)
+    impl = Module.concat(protocol, Map)
 
     :elixir_module.expand_callback(env.line, impl, :__deriving__, args, env, fn
       mod, fun, args ->
@@ -606,37 +606,24 @@ defmodule Protocol do
     end)
   end
 
-  @doc false
-  def __ensure_defimpl__(protocol, for, env) do
-    if Protocol.consolidated?(protocol) do
-      message =
-        "the #{inspect protocol} protocol has already been consolidated" <>
-        ", an implementation for #{inspect for} has no effect"
-      :elixir_errors.warn(env.line, env.file, message)
-    end
-    :ok
-  end
-
   @doc false
   def __spec__?(module, name, arity) do
     signature = {name, arity}
+    specs     = Module.get_attribute(module, :spec)
 
-    specs = Module.get_attribute(module, :spec)
     found =
-      :lists.map(fn {:spec, expr, caller} ->
-        if Kernel.Typespec.spec_to_signature(expr) == signature do
-          Kernel.Typespec.define_spec(:callback, expr, caller)
-          true
-        end
-      end, specs)
+      for {:spec, expr, caller} <- specs,
+        Kernel.Typespec.spec_to_signature(expr) == signature do
+        Kernel.Typespec.define_spec(:callback, expr, caller)
+        true
+      end
 
-    :lists.any(& &1 == true, found)
+    found != []
   end
 
   ## Helpers
 
-  @doc false
-  def __builtin__ do
+  defp builtin do
     [is_tuple: Tuple,
      is_atom: Atom,
      is_list: List,

lib/elixir/lib/range.ex

@@ -1,13 +1,6 @@
 defmodule Range do
   @moduledoc """
-  Defines a range.
-
-  A range represents a discrete number of values where
-  the first and last values are integers.
-
-  Ranges can be either increasing (first <= last) or
-  decreasing (first > last). Ranges are also always
-  inclusive.
+  Defines a Range.
 
   A Range is represented internally as a struct. However,
   the most common form of creating and matching on ranges
@@ -15,50 +8,28 @@ defmodule Range do
 
       iex> range = 1..3
       1..3
-      iex> first..last = range
+      iex> first .. last = range
       iex> first
       1
       iex> last
       3
 
-  A Range implements the Enumerable protocol, which means
-  all of the functions in the Enum module is available:
-
-      iex> range = 1..10
-      1..10
-      iex> Enum.reduce(range, 0, fn i, acc -> i * i + acc end)
-      385
-      iex> Enum.count(range)
-      10
-      iex> Enum.member?(range, 11)
-      false
-      iex> Enum.member?(range, 8)
-      true
-
   """
 
   defstruct first: nil, last: nil
 
-  @type t :: %Range{first: integer, last: integer}
+  @type t :: %Range{}
   @type t(first, last) :: %Range{first: first, last: last}
 
-
   @doc """
   Creates a new range.
   """
-  @spec new(integer, integer) :: t
-  def new(first, last) when is_integer(first) and is_integer(last) do
+  def new(first, last) do
     %Range{first: first, last: last}
   end
 
-  def new(first, last) do
-    raise ArgumentError,
-      "ranges (first..last) expect both sides to be integers, " <>
-      "got: #{inspect first}..#{inspect last}"
-  end
-
   @doc """
-  Returns `true` if the given `term` is a valid range.
+  Returns true if the given argument is a range.
 
   ## Examples
 
@@ -69,38 +40,52 @@ defmodule Range do
       false
 
   """
-  @spec range?(term) :: boolean
-  def range?(term)
-  def range?(first..last) when is_integer(first) and is_integer(last), do: true
+  def range?(%Range{}), do: true
   def range?(_), do: false
 end
 
+defprotocol Range.Iterator do
+  @moduledoc """
+  A protocol used for iterating range elements.
+  """
+
+  @doc """
+  Returns the function that calculates the next item.
+  """
+  def next(first, range)
+
+  @doc """
+  Count how many items are in the range.
+  """
+  def count(first, range)
+end
+
 defimpl Enumerable, for: Range do
-  def reduce(first..last, acc, fun) do
-    reduce(first, last, acc, fun, last >= first)
+  def reduce(first .. last = range, acc, fun) do
+    reduce(first, last, acc, fun, Range.Iterator.next(first, range), last >= first)
   end
 
-  defp reduce(_x, _y, {:halt, acc}, _fun, _up) do
+  defp reduce(_x, _y, {:halt, acc}, _fun, _next, _up) do
     {:halted, acc}
   end
 
-  defp reduce(x, y, {:suspend, acc}, fun, up) do
-    {:suspended, acc, &reduce(x, y, &1, fun, up)}
+  defp reduce(x, y, {:suspend, acc}, fun, next, up) do
+    {:suspended, acc, &reduce(x, y, &1, fun, next, up)}
   end
 
-  defp reduce(x, y, {:cont, acc}, fun, true) when x <= y do
-    reduce(x + 1, y, fun.(x, acc), fun, true)
+  defp reduce(x, y, {:cont, acc}, fun, next, true) when x <= y do
+    reduce(next.(x), y, fun.(x, acc), fun, next, true)
   end
 
-  defp reduce(x, y, {:cont, acc}, fun, false) when x >= y do
-    reduce(x - 1, y, fun.(x, acc), fun, false)
+  defp reduce(x, y, {:cont, acc}, fun, next, false) when x >= y do
+    reduce(next.(x), y, fun.(x, acc), fun, next, false)
   end
 
-  defp reduce(_, _, {:cont, acc}, _fun, _up) do
+  defp reduce(_, _, {:cont, acc}, _fun, _next, _up) do
     {:done, acc}
   end
 
-  def member?(first..last, value) when is_integer(value) do
+  def member?(first .. last, value) do
     if first <= last do
       {:ok, first <= value and value <= last}
     else
@@ -108,15 +93,25 @@ defimpl Enumerable, for: Range do
     end
   end
 
-  def member?(_.._, _value) do
-    {:ok, false}
+  def count(first .. _ = range) do
+    {:ok, Range.Iterator.count(first, range)}
+  end
+end
+
+defimpl Range.Iterator, for: Integer do
+  def next(first, _ .. last) when is_integer(last) do
+    if last >= first do
+      &(&1 + 1)
+    else
+      &(&1 - 1)
+    end
   end
 
-  def count(first..last) do
-    if first <= last do
-      {:ok, last - first + 1}
+  def count(first, _ .. last) when is_integer(last) do
+    if last >= first do
+      last - first + 1
     else
-      {:ok, first - last + 1}
+      first - last + 1
     end
   end
 end
@@ -124,7 +119,7 @@ end
 defimpl Inspect, for: Range do
   import Inspect.Algebra
 
-  def inspect(first..last, opts) do
+  def inspect(first .. last, opts) do
     concat [to_doc(first, opts), "..", to_doc(last, opts)]
   end
 end

lib/elixir/lib/record.ex

@@ -1,6 +1,6 @@
 defmodule Record do
   @moduledoc """
-  Module to work with, define and import records.
+  Module to work, define and import records.
 
   Records are simply tuples where the first element is an atom:
 
@@ -10,7 +10,7 @@ defmodule Record do
   This module provides conveniences for working with records at
   compilation time, where compile-time field names are used to
   manipulate the tuples, providing fast operations on top of
-  the tuples' compact structure.
+  the tuples compact structure.
 
   In Elixir, records are used mostly in two situations:
 
@@ -29,10 +29,10 @@ defmodule Record do
 
       defmodule MyModule do
         require Record
-        Record.defrecord :user, name: "john", age: 25
+        Record.defrecord :user name: "john", age: 25
 
         @type user :: record(:user, name: String.t, age: integer)
-        # expands to: "@type user :: {:user, String.t, integer}"
+        # expands to: `@type user :: {:user, String.t, integer}`
       end
   """
 
@@ -52,21 +52,8 @@ defmodule Record do
        uid: :undefined, gid: :undefined]
 
   """
-  def extract(name, opts) when is_atom(name) and is_list(opts) do
-    Record.Extractor.extract(name, opts)
-  end
-
-  @doc """
-  Extracts all records information from an Erlang file.
-
-  Returns a keyword list containing extracted record names as keys, and
-  lists of tuples describing the fields as values. It expects a named
-  argument :from or :from_lib, which correspond to *include* or
-  *include_lib* attribute from Erlang modules, respectively.
-
-  """
-  def extract_all(opts) when is_list(opts) do
-    Record.Extractor.extract_all(opts)
+  defmacro extract(name, opts) when is_atom(name) and is_list(opts) do
+    Macro.escape Record.Extractor.extract(name, opts)
   end
 
   @doc """
@@ -85,14 +72,14 @@ defmodule Record do
     case Macro.Env.in_guard?(__CALLER__) do
       true ->
         quote do
-          is_atom(unquote(kind)) and is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0 and
-            elem(unquote(data), 0) == unquote(kind)
+          is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0
+            and :erlang.element(1, unquote(data)) == unquote(kind)
         end
       false ->
         quote do
           result = unquote(data)
-          kind = unquote(kind)
-          is_atom(kind) and is_tuple(result) and tuple_size(result) > 0 and elem(result, 0) == kind
+          is_tuple(result) and tuple_size(result) > 0
+            and :erlang.element(1, result) == unquote(kind)
         end
     end
   end
@@ -116,13 +103,14 @@ defmodule Record do
     case Macro.Env.in_guard?(__CALLER__) do
       true ->
         quote do
-          is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0 and
-            is_atom(elem(unquote(data), 0))
+          is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0
+            and is_atom(:erlang.element(1, unquote(data)))
         end
       false ->
         quote do
           result = unquote(data)
-          is_tuple(result) and tuple_size(result) > 0 and is_atom(elem(result, 0))
+          is_tuple(result) and tuple_size(result) > 0
+            and is_atom(:erlang.element(1, result))
         end
     end
   end
@@ -157,14 +145,6 @@ defmodule Record do
       # Convert a record to a keyword list
       user(record) #=> [name: "meg", age: 26]
 
-  The generated macros can also be used in order to pattern match on records and
-  to bind variables during the match:
-
-      record = user() #=> {:user, "meg", 25}
-
-      user(name: name) = record
-      name #=> "meg"
-
   By default, Elixir uses the record name as the first element of
   the tuple (the tag). But it can be changed to something else:
 
@@ -176,25 +156,6 @@ defmodule Record do
       require User
       User.user() #=> {User, nil}
 
-  ## Defining extracted records with anonymous functions
-
-  If a record defines an anonymous function, an `ArgumentError`
-  will occur if you attempt to create a record with it.
-  This can occur unintentionally when defining a record after extracting
-  it from an Erlang library that uses anonymous functions for defaults.
-
-      Record.defrecord :my_rec, Record.extract(...)
-      #=> ** (ArgumentError) invalid value for record field fun_field,
-      cannot escape #Function<12.90072148/2 in :erl_eval.expr/5>.
-
-  To work around this error, redefine the field with your own &M.f/a function,
-  like so:
-
-      defmodule MyRec do
-        require Record
-        Record.defrecord :my_rec, Record.extract(...) |> Keyword.merge(fun_field: &__MODULE__.foo/2)
-        def foo(bar, baz), do: IO.inspect({bar, baz})
-      end
   """
   defmacro defrecord(name, tag \\ nil, kv) do
     quote bind_quoted: [name: name, tag: tag, kv: kv] do
@@ -259,8 +220,8 @@ defmodule Record do
         create(atom, fields, args, caller)
       true ->
         case Macro.expand(args, caller) do
-          {:{}, _, [^atom | list]} when length(list) == length(fields) ->
-            record = List.to_tuple([atom | list])
+          {:{}, _, [^atom|list]} when length(list) == length(fields) ->
+            record = List.to_tuple([atom|list])
             Macro.escape(Record.__keyword__(atom, fields, record))
           {^atom, arg} when length(fields) == 1 ->
             Macro.escape(Record.__keyword__(atom, fields, {atom, arg}))
@@ -296,15 +257,17 @@ defmodule Record do
   # Creates a new record with the given default fields and keyword values.
   defp create(atom, fields, keyword, caller) do
     in_match = Macro.Env.in_match?(caller)
-    keyword = apply_underscore(fields, keyword)
 
     {match, remaining} =
       Enum.map_reduce(fields, keyword, fn({field, default}, each_keyword) ->
         new_fields =
-          case Keyword.fetch(each_keyword, field) do
-            {:ok, value} -> value
-            :error when in_match -> {:_, [], nil}
-            :error -> Macro.escape(default)
+          case Keyword.has_key?(each_keyword, field) do
+            true  -> Keyword.get(each_keyword, field)
+            false ->
+              case in_match do
+                true  -> {:_, [], nil}
+                false -> Macro.escape(default)
+              end
           end
 
         {new_fields, Keyword.delete(each_keyword, field)}
@@ -312,7 +275,7 @@ defmodule Record do
 
     case remaining do
       [] ->
-        {:{}, [], [atom | match]}
+        {:{}, [], [atom|match]}
       _  ->
         keys = for {key, _} <- remaining, do: key
         raise ArgumentError, "record #{inspect atom} does not have the key: #{inspect hd(keys)}"
@@ -325,8 +288,6 @@ defmodule Record do
       raise ArgumentError, "cannot invoke update style macro inside match"
     end
 
-    keyword = apply_underscore(fields, keyword)
-
     Enum.reduce keyword, var, fn({key, value}, acc) ->
       index = find_index(fields, key, 0)
       if index do
@@ -351,15 +312,15 @@ defmodule Record do
     end
   end
 
-  defp find_index([{k, _} | _], k, i), do: i + 2
-  defp find_index([{_, _} | t], k, i), do: find_index(t, k, i + 1)
+  defp find_index([{k, _}|_], k, i), do: i + 2
+  defp find_index([{_, _}|t], k, i), do: find_index(t, k, i + 1)
   defp find_index([], _k, _i), do: nil
 
   # Returns a keyword list of the record
   @doc false
   def __keyword__(atom, fields, record) do
     if is_record(record, atom) do
-      [_tag | values] = Tuple.to_list(record)
+      [_tag|values] = Tuple.to_list(record)
       join_keyword(fields, values, [])
     else
       msg = "expected argument to be a literal atom, literal keyword or a #{inspect atom} record, got runtime: #{inspect record}"
@@ -367,20 +328,8 @@ defmodule Record do
     end
   end
 
-  defp join_keyword([{field, _default} | fields], [value | values], acc),
-    do: join_keyword(fields, values, [{field, value} | acc])
+  defp join_keyword([{field, _default}|fields], [value|values], acc),
+    do: join_keyword(fields, values, [{field, value}| acc])
   defp join_keyword([], [], acc),
     do: :lists.reverse(acc)
-
-  defp apply_underscore(fields, keyword) do
-    case Keyword.fetch(keyword, :_) do
-      {:ok, default} ->
-        fields
-        |> Enum.map(fn {k, _} -> {k, default} end)
-        |> Keyword.merge(keyword)
-        |> Keyword.delete(:_)
-      :error ->
-        keyword
-    end
-  end
 end

lib/elixir/lib/record/extractor.ex

@@ -4,44 +4,27 @@ defmodule Record.Extractor do
   # Retrieve a record definition from an Erlang file using
   # the same lookup as the *include* attribute from Erlang modules.
   def extract(name, from: file) when is_binary(file) do
-    extract_record(name, from_file(file))
+    file = String.to_char_list(file)
+
+    realfile =
+      case :code.where_is_file(file) do
+        :non_existing -> file
+        realfile -> realfile
+      end
+
+    extract_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 extract(name, from_lib: file) when is_binary(file) do
-    extract_record(name, from_lib_file(file))
-  end
+    [app|path] = :filename.split(String.to_char_list(file))
 
-  # Retrieve all records definitions from an Erlang file using
-  # the same lookup as the *include* attribute from Erlang modules.
-  def extract_all(from: file) when is_binary(file) do
-    extract_all_records(from_file(file))
-  end
-
-  # Retrieve all records definitions from an Erlang file using
-  # the same lookup as the *include_lib* attribute from Erlang modules.
-  def extract_all(from_lib: file) when is_binary(file) do
-    extract_all_records(from_lib_file(file))
-  end
-
-  # Find file using the same lookup as the *include* attribute from Erlang modules.
-  defp from_file(file) do
-    file = String.to_charlist(file)
-    case :code.where_is_file(file) do
-      :non_existing -> file
-      realfile -> realfile
-    end
-  end
-
-  # Find file using the same lookup as the *include_lib* attribute from Erlang modules.
-  defp from_lib_file(file) do
-    [app | path] = :filename.split(String.to_charlist(file))
     case :code.lib_dir(List.to_atom(app)) do
       {:error, _} ->
         raise ArgumentError, "lib file #{file} could not be found"
       libpath ->
-        :filename.join([libpath | path])
+        extract_record name, :filename.join([libpath|path])
     end
   end
 
@@ -56,24 +39,16 @@ defmodule Record.Extractor do
     end
   end
 
-  # Retrieve all records from the given file
-  defp extract_all_records(file) do
-    form = read_file(file)
-    records = extract_records(form)
-    for rec = {name, _fields} <- records, do: {name, parse_record(rec, form)}
-  end
-
   # Parse the given file and extract all existent records.
   defp extract_records(form) do
     for {:attribute, _, :record, record} <- form, do: record
   end
 
   # Read a file and return its abstract syntax form that also
-  # includes record but with macros and other attributes expanded,
-  # such as "-include(...)" and "-include_lib(...)". This is done
-  # by using Erlang's epp.
+  # includes record and other preprocessor modules. This is done
+  # by using Erlang's epp_dodger.
   defp read_file(file) do
-    case :epp.parse_file(file, []) do
+    case :epp_dodger.quick_parse_file(file) do
       {:ok, form} ->
         form
       other ->
@@ -105,11 +80,11 @@ defmodule Record.Extractor do
 
   defp eval_record(cons, form) do
     form = form ++
-      [{:function, 0, :hello, 0, [
-         {:clause, 0, [], [], [cons]}]}]
+      [ {:function, 0, :hello, 0, [
+          {:clause, 0, [], [], [ cons ]} ]} ]
 
     {:function, 0, :hello, 0, [
-      {:clause, 0, [], [], [record_ast]}]} = :erl_expand_records.module(form, []) |> List.last
+      {:clause, 0, [], [], [ record_ast ]} ]} = :erl_expand_records.module(form, []) |> List.last
 
     {:value, record, _} = :erl_eval.expr(record_ast, [])
     record

lib/elixir/lib/regex.ex

@@ -1,19 +1,18 @@
 defmodule Regex do
   @moduledoc ~S"""
-  Provides regular expressions for Elixir. Built on top of Erlang's `:re`
-  module.
+  Regular expressions for Elixir built on top of Erlang's `re` module.
 
-  As the `:re` module, Regex is based on PCRE
+  As the `re` module, Regex is based on PCRE
   (Perl Compatible Regular Expressions). More information can be
-  found in the [`:re` module documentation](http://www.erlang.org/doc/man/re.html).
+  found in the [`re` documentation](http://www.erlang.org/doc/man/re.html).
 
   Regular expressions in Elixir can be created using `Regex.compile!/2`
-  or using the special form with [`~r`](Kernel.html#sigil_r/2) or [`~R`](Kernel.html#sigil_R/2):
+  or using the special form with [`~r`](Kernel.html#sigil_r/2):
 
       # A simple regular expressions that matches foo anywhere in the string
       ~r/foo/
 
-      # A regular expression with case insensitive and Unicode options
+      # A regular expression with case insensitive and unicode options
       ~r/foo/iu
 
   A Regex is represented internally as the `Regex` struct. Therefore,
@@ -23,9 +22,9 @@ defmodule Regex do
 
   The modifiers available when creating a Regex are:
 
-    * `unicode` (u) - enables Unicode specific patterns like `\p` and change
-      modifiers like `\w`, `\W`, `\s` and friends to also match on Unicode.
-      It expects valid Unicode strings to be given on match
+    * `unicode` (u) - enables unicode specific patterns like `\p` and changes
+      modifiers like `\w`, `\W`, `\s` and friends to also match on unicode.
+      It expects valid unicode strings to be given on match
 
     * `caseless` (i) - add case insensitivity
 
@@ -42,8 +41,7 @@ defmodule Regex do
     * `firstline` (f) - forces the unanchored pattern to match before or at the
       first newline, though the matched text may continue over the newline
 
-    * `ungreedy` (U) - inverts the "greediness" of the regexp
-      (the previous `r` option is deprecated in favor of `U`)
+    * `ungreedy` (r) - inverts the "greediness" of the regexp
 
   The options not available are:
 
@@ -56,7 +54,7 @@ defmodule Regex do
 
   ## Captures
 
-  Many functions in this module handle what to capture in a regex
+  Many functions in this module allows what to capture in a regex
   match via the `:capture` option. The supported values are:
 
     * `:all` - all captured subpatterns including the complete matching string
@@ -91,7 +89,7 @@ defmodule Regex do
 
   The given options can either be a binary with the characters
   representing the same regex options given to the `~r` sigil,
-  or a list of options, as expected by the Erlang's [`:re` module](http://www.erlang.org/doc/man/re.html).
+  or a list of options, as expected by the [Erlang `re` docs](http://www.erlang.org/doc/man/re.html).
 
   It returns `{:ok, regex}` in case of success,
   `{:error, reason}` otherwise.
@@ -135,7 +133,7 @@ defmodule Regex do
   Compiles the regular expression according to the given options.
   Fails with `Regex.CompileError` if the regex cannot be compiled.
   """
-  @spec compile!(binary, binary | [term]) :: t
+  @spec compile(binary, binary | [term]) :: t
   def compile!(source, options \\ "") do
     case compile(source, options) do
       {:ok, regex} -> regex
@@ -161,8 +159,7 @@ defmodule Regex do
   end
 
   @doc """
-  Returns `true` if the given `term` is a regex.
-  Otherwise returns `false`.
+  Returns true if the given argument is a regex.
 
   ## Examples
 
@@ -173,8 +170,8 @@ defmodule Regex do
       false
 
   """
-  @spec regex?(any) :: boolean
-  def regex?(term)
+  @spec regex?(t) :: true
+  @spec regex?(any) :: false
   def regex?(%Regex{}), do: true
   def regex?(_), do: false
 
@@ -186,7 +183,7 @@ defmodule Regex do
 
     * `:return`  - set to `:index` to return indexes. Defaults to `:binary`.
     * `:capture` - what to capture in the result. Check the moduledoc for `Regex`
-      to see the possible capture values.
+                   to see the possible capture values.
 
   ## Examples
 
@@ -197,7 +194,7 @@ defmodule Regex do
       nil
 
       iex> Regex.run(~r/c(d)/, "abcd", return: :index)
-      [{2, 2}, {3, 1}]
+      [{2,2},{3,1}]
 
   """
   @spec run(t, binary, [term]) :: nil | [binary] | [{integer, integer}]
@@ -292,16 +289,15 @@ defmodule Regex do
 
   @doc """
   Same as `run/3`, but scans the target several times collecting all
-  matches of the regular expression.
-
-  A list of lists is returned, where each entry in the primary list represents a
-  match and each entry in the secondary list represents the captured contents.
+  matches of the regular expression. A list of lists is returned,
+  where each entry in the primary list represents a match and each
+  entry in the secondary list represents the captured contents.
 
   ## Options
 
     * `:return`  - set to `:index` to return indexes. Defaults to `:binary`.
     * `:capture` - what to capture in the result. Check the moduledoc for `Regex`
-      to see the possible capture values.
+                   to see the possible capture values.
 
   ## Examples
 
@@ -331,8 +327,7 @@ defmodule Regex do
   end
 
   @doc """
-  Splits the given target based on the given pattern and in the given number of
-  parts.
+  Splits the given target into the number of parts specified.
 
   ## Options
 
@@ -341,22 +336,20 @@ defmodule Regex do
       split the string into the maximum number of parts possible based on the
       given pattern.
 
-    * `:trim` - when `true`, removes empty strings (`""`) from the result.
+    * `:trim` - when true, remove blank strings from the result.
 
-    * `:on` - specifies which captures to split the string on, and in what
-      order. Defaults to `:first` which means captures inside the regex do not
-      affect the splitting process.
-
-    * `:include_captures` - when `true`, includes in the result the matches of
-      the regular expression. Defaults to `false`.
+    * `:on` - specifies which captures and order to split the string
+      on. Check the moduledoc for `Regex` to see the possible capture
+      values. Defaults to `:first` which means captures inside the
+      Regex does not affect the split result.
 
   ## Examples
 
       iex> Regex.split(~r/-/, "a-b-c")
-      ["a", "b", "c"]
+      ["a","b","c"]
 
       iex> Regex.split(~r/-/, "a-b-c", [parts: 2])
-      ["a", "b-c"]
+      ["a","b-c"]
 
       iex> Regex.split(~r/-/, "abc")
       ["abc"]
@@ -370,32 +363,19 @@ defmodule Regex do
       iex> Regex.split(~r/a(?<second>b)c/, "abc", on: [:second])
       ["a", "c"]
 
-      iex> Regex.split(~r/(x)/, "Elixir", include_captures: true)
-      ["Eli", "x", "ir"]
-
-      iex> Regex.split(~r/a(?<second>b)c/, "abc", on: [:second], include_captures: true)
-      ["a", "b", "c"]
-
   """
   @spec split(t, String.t, [term]) :: [String.t]
   def split(regex, string, options \\ [])
 
-  def split(%Regex{}, "", opts) do
-    if Keyword.get(opts, :trim, false) do
-      []
-    else
-      [""]
-    end
-  end
+  def split(%Regex{}, "", _opts), do: [""]
 
-  def split(%Regex{re_pattern: compiled}, string, opts) when is_binary(string) and is_list(opts) do
+  def split(%Regex{re_pattern: compiled}, string, opts) when is_binary(string) do
     on = Keyword.get(opts, :on, :first)
     case :re.run(string, compiled, [:global, capture: on]) do
       {:match, matches} ->
         do_split(matches, string, 0,
                  parts_to_index(Keyword.get(opts, :parts, :infinity)),
-                 Keyword.get(opts, :trim, false),
-                 Keyword.get(opts, :include_captures, false))
+                 Keyword.get(opts, :trim, false))
       :match ->
         [string]
       :nomatch ->
@@ -406,58 +386,41 @@ defmodule Regex do
   defp parts_to_index(:infinity),                      do: 0
   defp parts_to_index(n) when is_integer(n) and n > 0, do: n
 
-  defp do_split(_, string, offset, _counter, true, _with_captures) when byte_size(string) <= offset,
+  defp do_split(_, string, offset, _counter, true) when byte_size(string) <= offset,
     do: []
 
-  defp do_split(_, string, offset, 1, _trim, _with_captures),
+  defp do_split(_, string, offset, 1, _trim),
     do: [binary_part(string, offset, byte_size(string) - offset)]
 
-  defp do_split([], string, offset, _counter, _trim, _with_captures),
+  defp do_split([], string, offset, _counter, _trim),
     do: [binary_part(string, offset, byte_size(string) - offset)]
 
-  defp do_split([[{pos, _} | h] | t], string, offset, counter, trim, with_captures) when pos - offset < 0,
-    do: do_split([h | t], string, offset, counter, trim, with_captures)
+  defp do_split([[{pos, _}|h]|t], string, offset, counter, trim) when pos - offset < 0,
+    do: do_split([h|t], string, offset, counter, trim)
 
-  defp do_split([[] | t], string, offset, counter, trim, with_captures),
-    do: do_split(t, string, offset, counter, trim, with_captures)
+  defp do_split([[]|t], string, offset, counter, trim),
+    do: do_split(t, string, offset, counter, trim)
 
-  defp do_split([[{pos, length} | h] | t], string, offset, counter, trim, true) do
-    new_offset = pos + length
-    keep = pos - offset
-
-    if keep == 0 and length == 0 do
-      do_split([h | t], string, new_offset, counter, trim, true)
-    else
-      <<_::binary-size(offset), part::binary-size(keep), match::binary-size(length), _::binary>> = string
-
-      if keep == 0 and (length == 0 or trim) do
-        [match | do_split([h | t], string, new_offset, counter - 1, trim, true)]
-      else
-        [part, match | do_split([h | t], string, new_offset, counter - 1, trim, true)]
-      end
-    end
-  end
-
-  defp do_split([[{pos, length} | h] | t], string, offset, counter, trim, false) do
+  defp do_split([[{pos, length}|h]|t], string, offset, counter, trim) do
     new_offset = pos + length
     keep = pos - offset
 
     if keep == 0 and (length == 0 or trim) do
-      do_split([h | t], string, new_offset, counter, trim, false)
+      do_split([h|t], string, new_offset, counter, trim)
     else
       <<_::binary-size(offset), part::binary-size(keep), _::binary>> = string
-      [part | do_split([h | t], string, new_offset, counter - 1, trim, false)]
+      [part|do_split([h|t], string, new_offset, counter - 1, trim)]
     end
   end
 
   @doc ~S"""
   Receives a regex, a binary and a replacement, returns a new
-  binary where all matches are replaced by the replacement.
+  binary where the all matches are replaced by replacement.
 
   The replacement can be either a string or a function. The string
   is used as a replacement for every match and it allows specific
-  captures to be accessed via `\\N` or `\g{N}`, where `N` is the
-  capture. In case `\\0` is used, the whole match is inserted.
+  captures to be accessed via `\N`, where `N` is the capture. In
+  case `\0` is used, the whole match is inserted.
 
   When the replacement is a function, the function may have arity
   N where each argument maps to a capture, with the first argument
@@ -467,7 +430,7 @@ defmodule Regex do
   ## Options
 
     * `:global` - when `false`, replaces only the first occurrence
-      (defaults to `true`)
+      (defaults to true)
 
   ## Examples
 
@@ -483,39 +446,31 @@ defmodule Regex do
       iex> Regex.replace(~r/a(b|d)c/, "abcadc", "[\\1]")
       "[b][d]"
 
-      iex> Regex.replace(~r/\.(\d)$/, "500.5", ".\\g{1}0")
-      "500.50"
-
       iex> Regex.replace(~r/a(b|d)c/, "abcadc", fn _, x -> "[#{x}]" end)
       "[b][d]"
 
-      iex> Regex.replace(~r/a/, "abcadc", "A", global: false)
-      "Abcadc"
-
   """
   @spec replace(t, String.t, String.t | (... -> String.t), [term]) :: String.t
   def replace(regex, string, replacement, options \\ [])
 
-  def replace(regex, string, replacement, options)
-      when is_binary(string) and is_binary(replacement) and is_list(options) do
+  def replace(regex, string, replacement, options) when is_binary(replacement) do
     do_replace(regex, string, precompile_replacement(replacement), options)
   end
 
-  def replace(regex, string, replacement, options)
-      when is_binary(string) and is_function(replacement) and is_list(options)  do
+  def replace(regex, string, replacement, options) when is_function(replacement) do
     {:arity, arity} = :erlang.fun_info(replacement, :arity)
     do_replace(regex, string, {replacement, arity}, options)
   end
 
   defp do_replace(%Regex{re_pattern: compiled}, string, replacement, options) do
     opts = if Keyword.get(options, :global) != false, do: [:global], else: []
-    opts = [{:capture, :all, :index} | opts]
+    opts = [{:capture, :all, :index}|opts]
 
     case :re.run(string, compiled, opts) do
       :nomatch ->
         string
-      {:match, [mlist | t]} when is_list(mlist) ->
-        apply_list(string, replacement, [mlist | t]) |> IO.iodata_to_binary
+      {:match, [mlist|t]} when is_list(mlist) ->
+        apply_list(string, replacement, [mlist|t]) |> IO.iodata_to_binary
       {:match, slist} ->
         apply_list(string, replacement, [slist]) |> IO.iodata_to_binary
     end
@@ -524,32 +479,32 @@ defmodule Regex do
   defp precompile_replacement(""),
     do: []
 
-  defp precompile_replacement(<<?\\, ?g, ?{, rest::binary>>) when byte_size(rest) > 0 do
-    {ns, <<?}, rest::binary>>} = pick_int(rest)
-    [List.to_integer(ns) | precompile_replacement(rest)]
-  end
-
-  defp precompile_replacement(<<?\\, ?\\, rest::binary>>) do
-    [<<?\\>> | precompile_replacement(rest)]
-  end
-
-  defp precompile_replacement(<<?\\, x, rest::binary>>) when x in ?0..?9 do
-    {ns, rest} = pick_int(rest)
-    [List.to_integer([x | ns]) | precompile_replacement(rest)]
-  end
-
-  defp precompile_replacement(<<x, rest::binary>>) do
+  defp precompile_replacement(<<?\\, x, rest :: binary>>) when x < ?0 or x > ?9 do
     case precompile_replacement(rest) do
       [head | t] when is_binary(head) ->
-        [<<x, head::binary>> | t]
+        [<<x, head :: binary>> | t]
       other ->
         [<<x>> | other]
     end
   end
 
-  defp pick_int(<<x, rest::binary>>) when x in ?0..?9 do
+  defp precompile_replacement(<<?\\, rest :: binary>>) when byte_size(rest) > 0 do
+    {ns, rest} = pick_int(rest)
+    [List.to_integer(ns) | precompile_replacement(rest)]
+  end
+
+  defp precompile_replacement(<<x, rest :: binary>>) do
+    case precompile_replacement(rest) do
+      [head | t] when is_binary(head) ->
+        [<<x, head :: binary>> | t]
+      other ->
+        [<<x>> | other]
+    end
+  end
+
+  defp pick_int(<<x, rest :: binary>>) when x in ?0..?9 do
     {found, rest} = pick_int(rest)
-    {[x | found], rest}
+    {[x|found], rest}
   end
 
   defp pick_int(bin) do
@@ -570,12 +525,12 @@ defmodule Regex do
 
   defp apply_list(whole, string, pos, replacement, [[{mpos, _} | _] | _] = list) when mpos > pos do
     length = mpos - pos
-    <<untouched::binary-size(length), rest::binary>> = string
+    <<untouched :: binary-size(length), rest :: binary>> = string
     [untouched | apply_list(whole, rest, mpos, replacement, list)]
   end
 
-  defp apply_list(whole, string, pos, replacement, [[{pos, length} | _] = head | tail]) do
-    <<_::size(length)-binary, rest::binary>> = string
+  defp apply_list(whole, string, pos, replacement, [[{mpos, length} | _] = head | tail]) when mpos == pos do
+    <<_ :: size(length)-binary, rest :: binary>> = string
     new_data = apply_replace(whole, replacement, head)
     [new_data | apply_list(whole, rest, pos + length, replacement, tail)]
   end
@@ -595,7 +550,7 @@ defmodule Regex do
       cond do
         is_binary(part) ->
           part
-        part >= tuple_size(indexes) ->
+        part > tuple_size(indexes) ->
           ""
         true ->
           get_index(string, elem(indexes, part))
@@ -608,7 +563,7 @@ defmodule Regex do
   end
 
   defp get_index(string, {pos, len}) do
-    <<_::size(pos)-binary, res::size(len)-binary, _::binary>> = string
+    <<_ :: size(pos)-binary, res :: size(len)-binary, _ :: binary>> = string
     res
   end
 
@@ -617,14 +572,14 @@ defmodule Regex do
   end
 
   defp get_indexes(string, [], arity) do
-    ["" | get_indexes(string, [], arity - 1)]
+    [""|get_indexes(string, [], arity - 1)]
   end
 
-  defp get_indexes(string, [h | t], arity) do
-    [get_index(string, h) | get_indexes(string, t, arity - 1)]
+  defp get_indexes(string, [h|t], arity) do
+    [get_index(string, h)|get_indexes(string, t, arity - 1)]
   end
 
-  {:ok, pattern} = :re.compile(~S"[.^$*+?()\[\]{}\\\|\s#]", [:unicode])
+  {:ok, pattern} = :re.compile(~S"[.^$*+?()[{\\\|\s#]", [:unicode])
   @escape_pattern pattern
 
   @doc ~S"""
@@ -658,20 +613,13 @@ defmodule Regex do
 
   # Private Helpers
 
-  defp translate_options(<<?u, t::binary>>, acc), do: translate_options(t, [:unicode, :ucp | acc])
-  defp translate_options(<<?i, t::binary>>, acc), do: translate_options(t, [:caseless | acc])
-  defp translate_options(<<?x, t::binary>>, acc), do: translate_options(t, [:extended | acc])
-  defp translate_options(<<?f, t::binary>>, acc), do: translate_options(t, [:firstline | acc])
-  defp translate_options(<<?U, t::binary>>, acc), do: translate_options(t, [:ungreedy | acc])
-  defp translate_options(<<?s, t::binary>>, acc), do: translate_options(t, [:dotall, {:newline, :anycrlf} | acc])
-  defp translate_options(<<?m, t::binary>>, acc), do: translate_options(t, [:multiline | acc])
-
-  # TODO: Remove on 2.0
-  defp translate_options(<<?r, t::binary>>, acc) do
-    IO.warn "the /r modifier in regular expressions is deprecated, please use /U instead"
-    translate_options(t, [:ungreedy | acc])
-  end
-
+  defp translate_options(<<?u, t :: binary>>, acc), do: translate_options(t, [:unicode, :ucp|acc])
+  defp translate_options(<<?i, t :: binary>>, acc), do: translate_options(t, [:caseless|acc])
+  defp translate_options(<<?x, t :: binary>>, acc), do: translate_options(t, [:extended|acc])
+  defp translate_options(<<?f, t :: binary>>, acc), do: translate_options(t, [:firstline|acc])
+  defp translate_options(<<?r, t :: binary>>, acc), do: translate_options(t, [:ungreedy|acc])
+  defp translate_options(<<?s, t :: binary>>, acc), do: translate_options(t, [:dotall, {:newline, :anycrlf}|acc])
+  defp translate_options(<<?m, t :: binary>>, acc), do: translate_options(t, [:multiline|acc])
   defp translate_options(<<>>, acc), do: acc
   defp translate_options(rest, _acc), do: {:error, rest}
 end

lib/elixir/lib/set.ex

@@ -1,15 +1,50 @@
 defmodule Set do
   @moduledoc ~S"""
-  WARNING: this module is deprecated.
+  This module specifies the Set API expected to be
+  implemented by different representations.
 
-  Use the `MapSet` module instead.
+  It also provides functions that redirect to the
+  underlying Set, allowing a developer to work with
+  different Set implementations using one API.
+
+  To create a new set, use the `new` functions defined
+  by each set type:
+
+      HashSet.new  #=> creates an empty HashSet
+
+  In the examples below, `set_impl` means a specific
+  `Set` implementation, for example `HashSet`.
+
+  ## Protocols
+
+  Sets are required to implement both `Enumerable` and `Collectable`
+  protocols.
+
+  ## Match
+
+  Sets are required to implement all operations using the match (`===`)
+  operator.
   """
 
+  use Behaviour
+
   @type value :: any
   @type values :: [ value ]
   @type t :: map
 
-  # TODO: Deprecate every function by 1.4
+  defcallback new :: t
+  defcallback delete(t, value) :: t
+  defcallback difference(t, t) :: t
+  defcallback disjoint?(t, t) :: boolean
+  defcallback equal?(t, t) :: boolean
+  defcallback intersection(t, t) :: t
+  defcallback member?(t, value) :: boolean
+  defcallback put(t, value) :: t
+  defcallback size(t) :: non_neg_integer
+  defcallback subset?(t, t) :: boolean
+  defcallback to_list(t) :: list()
+  defcallback union(t, t) :: t
+
   defmacrop target(set) do
     quote do
       case unquote(set) do
@@ -21,10 +56,39 @@ defmodule Set do
     end
   end
 
+  @doc """
+  Deletes `value` from `set`.
+
+  ## Examples
+
+      iex> s = Enum.into([1, 2, 3], set_impl.new)
+      iex> Set.delete(s, 4) |> Enum.sort
+      [1, 2, 3]
+
+      iex> s = Enum.into([1, 2, 3], set_impl.new)
+      iex> Set.delete(s, 2) |> Enum.sort
+      [1, 3]
+
+  """
+  @spec delete(t, value) :: t
   def delete(set, value) do
     target(set).delete(set, value)
   end
 
+  @doc """
+  Returns a set that is `set1` without the members of `set2`.
+
+  Notice this function is polymorphic as it calculates the difference
+  for of any type. Each set implementation also provides a `difference`
+  function, but they can only work with sets of the same type.
+
+  ## Examples
+
+      iex> Set.difference(Enum.into([1,2], set_impl.new), Enum.into([2,3,4], set_impl.new)) |> Enum.sort
+      [1]
+
+  """
+  @spec difference(t, t) :: t
   def difference(set1, set2) do
     target1 = target(set1)
     target2 = target(set2)
@@ -32,12 +96,29 @@ defmodule Set do
     if target1 == target2 do
       target1.difference(set1, set2)
     else
-      Enumerable.reduce(set2, {:cont, set1}, fn v, acc ->
+      target2.reduce(set2, {:cont, set1}, fn v, acc ->
         {:cont, target1.delete(acc, v)}
       end) |> elem(1)
     end
   end
 
+  @doc """
+  Checks if `set1` and `set2` have no members in common.
+
+  Notice this function is polymorphic as it checks for disjoint sets of
+  any type. Each set implementation also provides a `disjoint?` function,
+  but they can only work with sets of the same type.
+
+  ## Examples
+
+      iex> Set.disjoint?(Enum.into([1, 2], set_impl.new), Enum.into([3, 4], set_impl.new))
+      true
+
+      iex> Set.disjoint?(Enum.into([1, 2], set_impl.new), Enum.into([2, 3], set_impl.new))
+      false
+
+  """
+  @spec disjoint?(t, t) :: boolean
   def disjoint?(set1, set2) do
     target1 = target(set1)
     target2 = target(set2)
@@ -45,7 +126,7 @@ defmodule Set do
     if target1 == target2 do
       target1.disjoint?(set1, set2)
     else
-      Enumerable.reduce(set2, {:cont, true}, fn member, acc ->
+      target2.reduce(set2, {:cont, true}, fn member, acc ->
         case target1.member?(set1, member) do
           false -> {:cont, acc}
           _     -> {:halt, false}
@@ -55,10 +136,28 @@ defmodule Set do
   end
 
   @doc false
+  @spec empty(t) :: t
   def empty(set) do
     target(set).empty(set)
   end
 
+  @doc """
+  Check if two sets are equal using `===`.
+
+  Notice this function is polymorphic as it compares sets of
+  any type. Each set implementation also provides an `equal?`
+  function, but they can only work with sets of the same type.
+
+  ## Examples
+
+      iex> Set.equal?(Enum.into([1, 2], set_impl.new), Enum.into([2, 1, 1], set_impl.new))
+      true
+
+      iex> Set.equal?(Enum.into([1, 2], set_impl.new), Enum.into([3, 4], set_impl.new))
+      false
+
+  """
+  @spec equal?(t, t) :: boolean
   def equal?(set1, set2) do
     target1 = target(set1)
     target2 = target(set2)
@@ -75,7 +174,23 @@ defmodule Set do
     end
   end
 
+  @doc """
+  Returns a set containing only members in common between `set1` and `set2`.
 
+  Notice this function is polymorphic as it calculates the intersection of
+  any type. Each set implementation also provides a `intersection` function,
+  but they can only work with sets of the same type.
+
+  ## Examples
+
+      iex> Set.intersection(Enum.into([1,2], set_impl.new), Enum.into([2,3,4], set_impl.new)) |> Enum.sort
+      [2]
+
+      iex> Set.intersection(Enum.into([1,2], set_impl.new), Enum.into([3,4], set_impl.new)) |> Enum.sort
+      []
+
+  """
+  @spec intersection(t, t) :: t
   def intersection(set1, set2) do
     target1 = target(set1)
     target2 = target(set2)
@@ -83,26 +198,77 @@ defmodule Set do
     if target1 == target2 do
       target1.intersection(set1, set2)
     else
-      Enumerable.reduce(set1, {:cont, target1.new}, fn v, acc ->
+      target1.reduce(set1, {:cont, target1.new}, fn v, acc ->
         {:cont, if(target2.member?(set2, v), do: target1.put(acc, v), else: acc)}
       end) |> elem(1)
     end
   end
 
+  @doc """
+  Checks if `set` contains `value`.
 
+  ## Examples
+
+      iex> Set.member?(Enum.into([1, 2, 3], set_impl.new), 2)
+      true
+
+      iex> Set.member?(Enum.into([1, 2, 3], set_impl.new), 4)
+      false
+
+  """
+  @spec member?(t, value) :: boolean
   def member?(set, value) do
     target(set).member?(set, value)
   end
 
+  @doc """
+  Inserts `value` into `set` if it does not already contain it.
 
+  ## Examples
+
+      iex> Set.put(Enum.into([1, 2, 3], set_impl.new), 3) |> Enum.sort
+      [1, 2, 3]
+
+      iex> Set.put(Enum.into([1, 2, 3], set_impl.new), 4) |> Enum.sort
+      [1, 2, 3, 4]
+
+  """
+  @spec put(t, value) :: t
   def put(set, value) do
     target(set).put(set, value)
   end
 
+  @doc """
+  Returns the number of elements in `set`.
+
+  ## Examples
+
+      iex> Set.size(Enum.into([1, 2, 3], set_impl.new))
+      3
+
+  """
+  @spec size(t) :: non_neg_integer
   def size(set) do
     target(set).size(set)
   end
 
+  @doc """
+  Checks if `set1`'s members are all contained in `set2`.
+
+  Notice this function is polymorphic as it checks the subset for
+  any type. Each set implementation also provides a `subset?` function,
+  but they can only work with sets of the same type.
+
+  ## Examples
+
+      iex> Set.subset?(Enum.into([1, 2], set_impl.new), Enum.into([1, 2, 3], set_impl.new))
+      true
+
+      iex> Set.subset?(Enum.into([1, 2, 3], set_impl.new), Enum.into([1, 2], set_impl.new))
+      false
+
+  """
+  @spec subset?(t, t) :: boolean
   def subset?(set1, set2) do
     target1 = target(set1)
     target2 = target(set2)
@@ -114,10 +280,34 @@ defmodule Set do
     end
   end
 
+  @doc """
+  Converts `set` to a list.
+
+  ## Examples
+
+      iex> set_impl.to_list(Enum.into([1, 2, 3], set_impl.new)) |> Enum.sort
+      [1,2,3]
+
+  """
+  @spec to_list(t) :: list
   def to_list(set) do
     target(set).to_list(set)
   end
 
+  @doc """
+  Returns a set containing all members of `set1` and `set2`.
+
+  Notice this function is polymorphic as it calculates the union of
+  any type. Each set implementation also provides a `union` function,
+  but they can only work with sets of the same type.
+
+  ## Examples
+
+      iex> Set.union(Enum.into([1,2], set_impl.new), Enum.into([2,3,4], set_impl.new)) |> Enum.sort
+      [1,2,3,4]
+
+  """
+  @spec union(t, t) :: t
   def union(set1, set2) do
     target1 = target(set1)
     target2 = target(set2)
@@ -125,14 +315,14 @@ defmodule Set do
     if target1 == target2 do
       target1.union(set1, set2)
     else
-      Enumerable.reduce(set2, {:cont, set1}, fn v, acc ->
+      target2.reduce(set2, {:cont, set1}, fn v, acc ->
         {:cont, target1.put(acc, v)}
       end) |> elem(1)
     end
   end
 
-  defp do_subset?(_target1, target2, set1, set2) do
-    Enumerable.reduce(set1, {:cont, true}, fn member, acc ->
+  defp do_subset?(target1, target2, set1, set2) do
+    target1.reduce(set1, {:cont, true}, fn member, acc ->
       case target2.member?(set2, member) do
         true -> {:cont, acc}
         _    -> {:halt, false}

lib/elixir/lib/stream.ex

@@ -9,7 +9,7 @@ defmodule Stream do
       iex> range = 1..5
       1..5
       iex> Enum.map range, &(&1 * 2)
-      [2, 4, 6, 8, 10]
+      [2,4,6,8,10]
 
   In the example above, as we mapped over the range, the elements being
   enumerated were created one by one, during enumeration. The `Stream`
@@ -18,11 +18,11 @@ defmodule Stream do
       iex> range = 1..3
       iex> stream = Stream.map(range, &(&1 * 2))
       iex> Enum.map(stream, &(&1 + 1))
-      [3, 5, 7]
+      [3,5,7]
 
   Notice we started with a range and then we created a stream that is
   meant to multiply each item in the range by 2. At this point, no
-  computation was done. Only when `Enum.map/2` is called we actually
+  computation was done yet. Just when `Enum.map/2` is called we
   enumerate over each item in the range, multiplying it by 2 and adding 1.
   We say the functions in `Stream` are *lazy* and the functions in `Enum`
   are *eager*.
@@ -33,26 +33,26 @@ defmodule Stream do
   computations that are executed at a later moment. Let's see another
   example:
 
-      1..3
-      |> Enum.map(&IO.inspect(&1))
-      |> Enum.map(&(&1 * 2))
-      |> Enum.map(&IO.inspect(&1))
+      1..3 |>
+        Enum.map(&IO.inspect(&1)) |>
+        Enum.map(&(&1 * 2)) |>
+        Enum.map(&IO.inspect(&1))
       1
       2
       3
       2
       4
       6
-      #=> [2, 4, 6]
+      #=> [2,4,6]
 
   Notice that we first printed each item in the list, then multiplied each
   element by 2 and finally printed each new value. In this example, the list
   was enumerated three times. Let's see an example with streams:
 
-      stream = 1..3
-      |> Stream.map(&IO.inspect(&1))
-      |> Stream.map(&(&1 * 2))
-      |> Stream.map(&IO.inspect(&1))
+      stream = 1..3 |>
+        Stream.map(&IO.inspect(&1)) |>
+        Stream.map(&(&1 * 2)) |>
+        Stream.map(&IO.inspect(&1))
       Enum.to_list(stream)
       1
       2
@@ -60,16 +60,16 @@ defmodule Stream do
       4
       3
       6
-      #=> [2, 4, 6]
+      #=> [2,4,6]
 
   Although the end result is the same, the order in which the items were
   printed changed! With streams, we print the first item and then print
   its double. In this example, the list was enumerated just once!
 
-  That's what we meant when we said earlier that streams are composable,
+  That's what we meant when we first said that streams are composable,
   lazy enumerables. Notice we could call `Stream.map/2` multiple times,
-  effectively composing the streams and keeping them lazy. The computations
-  are only performed when you call a function from the `Enum` module.
+  effectively composing the streams and they are lazy. The computations
+  are performed only when you call a function from the `Enum` module.
 
   ## Creating Streams
 
@@ -85,7 +85,7 @@ defmodule Stream do
   Note the functions in this module are guaranteed to return enumerables.
   Since enumerables can have different shapes (structs, anonymous functions,
   and so on), the functions in this module may return any of those shapes
-  and that this may change at any time. For example, a function that today
+  and that it may change at any time. For example, a function that today
   returns an anonymous function may return a struct in future releases.
   """
 
@@ -96,26 +96,23 @@ defmodule Stream do
   @type element :: any
   @type index   :: non_neg_integer
   @type default :: any
+  @type       t :: %__MODULE__{}
 
   # Require Stream.Reducers and its callbacks
   require Stream.Reducers, as: R
 
-  defmacrop skip(acc) do
-    {:cont, acc}
-  end
-
-  defmacrop next(f, entry, acc) do
+  defmacrop cont(f, entry, acc) do
     quote do: unquote(f).(unquote(entry), unquote(acc))
   end
 
   defmacrop acc(h, n, t) do
-    quote do: [unquote(h), unquote(n) | unquote(t)]
+    quote do: [unquote(h),unquote(n)|unquote(t)]
   end
 
-  defmacrop next_with_acc(f, entry, h, n, t) do
+  defmacrop cont_with_acc(f, entry, h, n, t) do
     quote do
-      {reason, [h | t]} = unquote(f).(unquote(entry), [unquote(h) | unquote(t)])
-      {reason, [h, unquote(n) | t]}
+      {reason, [h|t]} = unquote(f).(unquote(entry), [unquote(h)|unquote(t)])
+      {reason, [h,unquote(n)|t]}
     end
   end
 
@@ -134,9 +131,9 @@ defmodule Stream do
   `step` is optional and, if not passed, defaults to `n`, i.e.
   chunks do not overlap. If the final chunk does not have `n`
   elements to fill the chunk, elements are taken as necessary
-  from `leftover` if it was passed. If `leftover` is passed and
-  does not have enough elements to fill the chunk, then the chunk is
-  returned anyway with less than `n` elements. If `leftover` is not
+  from `pad` if it was passed. If `pad` is passed and does not
+  have enough elements to fill the chunk, then the chunk is
+  returned anyway with less than `n` elements. If `pad` is not
   passed at all or is `nil`, then the partial chunk is discarded
   from the result.
 
@@ -155,17 +152,16 @@ defmodule Stream do
       [[1, 2, 3], [4, 5, 6]]
 
   """
-  @spec chunk(Enumerable.t, pos_integer, pos_integer) :: Enumerable.t
-  @spec chunk(Enumerable.t, pos_integer, pos_integer, Enumerable.t | nil) :: Enumerable.t
-  def chunk(enum, n, step, leftover \\ nil)
-      when is_integer(n) and n > 0 and is_integer(step) and step > 0 do
+  @spec chunk(Enumerable.t, non_neg_integer, non_neg_integer) :: Enumerable.t
+  @spec chunk(Enumerable.t, non_neg_integer, non_neg_integer, Enumerable.t | nil) :: Enumerable.t
+  def chunk(enum, n, step, pad \\ nil) when n > 0 and step > 0 do
     limit = :erlang.max(n, step)
-    if is_nil(leftover) do
+    if is_nil(pad) do
       lazy enum, {[], 0}, fn(f1) -> R.chunk(n, step, limit, f1) end
     else
       lazy enum, {[], 0},
            fn(f1) -> R.chunk(n, step, limit, f1) end,
-           &do_chunk(&1, n, leftover, &2)
+           &do_chunk(&1, n, pad, &2)
      end
   end
 
@@ -173,9 +169,9 @@ defmodule Stream do
     {:cont, acc}
   end
 
-  defp do_chunk(acc(h, {buffer, count} = old, t), n, leftover, f1) do
-    buffer = :lists.reverse(buffer, Enum.take(leftover, n - count))
-    next_with_acc(f1, buffer, h, old, t)
+  defp do_chunk(acc(h, {buffer, count} = old, t), n, pad, f1) do
+    buffer = :lists.reverse(buffer) ++ Enum.take(pad, n - count)
+    cont_with_acc(f1, buffer, h, old, t)
   end
 
   @doc """
@@ -202,41 +198,7 @@ defmodule Stream do
   end
 
   defp do_chunk_by(acc(h, {buffer, _}, t), f1) do
-    next_with_acc(f1, :lists.reverse(buffer), h, nil, t)
-  end
-
-
-  @doc """
-  Creates a stream that only emits elements if they are different from the last emitted element.
-
-  This function only ever needs to store the last emitted element.
-
-  Elements are compared using `===`.
-
-  ## Examples
-
-      iex> Stream.dedup([1, 2, 3, 3, 2, 1]) |> Enum.to_list
-      [1, 2, 3, 2, 1]
-
-  """
-  @spec dedup(Enumerable.t) :: Enumerable.t
-  def dedup(enum) do
-    dedup_by(enum, fn x -> x end)
-  end
-
-  @doc """
-  Creates a stream that only emits elements if the result of calling `fun` on the element is
-  different from the (stored) result of calling `fun` on the last emitted element.
-
-  ## Examples
-
-      iex> Stream.dedup_by([{1, :x}, {2, :y}, {2, :z}, {1, :x}], fn {x, _} -> x end) |> Enum.to_list
-      [{1, :x}, {2, :y}, {1, :x}]
-
-  """
-  @spec dedup_by(Enumerable.t, (element -> term)) :: Enumerable.t
-  def dedup_by(enum, fun) when is_function(fun, 1) do
-    lazy enum, nil, fn f1 -> R.dedup(fun, f1) end
+    cont_with_acc(f1, :lists.reverse(buffer), h, nil, t)
   end
 
   @doc """
@@ -251,11 +213,11 @@ defmodule Stream do
 
       iex> stream = Stream.drop(1..10, 5)
       iex> Enum.to_list(stream)
-      [6, 7, 8, 9, 10]
+      [6,7,8,9,10]
 
       iex> stream = Stream.drop(1..10, -5)
       iex> Enum.to_list(stream)
-      [1, 2, 3, 4, 5]
+      [1,2,3,4,5]
 
   """
   @spec drop(Enumerable.t, non_neg_integer) :: Enumerable.t
@@ -270,53 +232,23 @@ defmodule Stream do
       fn
         entry, [h, {count, buf1, []} | t] ->
           do_drop(:cont, n, entry, h, count, buf1, [], t)
-        entry, [h, {count, buf1, [next | buf2]} | t] ->
-          {reason, [h | t]} = f1.(next, [h | t])
+        entry, [h, {count, buf1, [next|buf2]} | t] ->
+          {reason, [h|t]} = f1.(next, [h|t])
           do_drop(reason, n, entry, h, count, buf1, buf2, t)
       end
     end
   end
 
   defp do_drop(reason, n, entry, h, count, buf1, buf2, t) do
-    buf1  = [entry | buf1]
+    buf1  = [entry|buf1]
     count = count + 1
     if count == n do
-      {reason, [h, {0, [], :lists.reverse(buf1)} | t]}
+      {reason, [h, {0, [], :lists.reverse(buf1)}|t]}
     else
-      {reason, [h, {count, buf1, buf2} | t]}
+      {reason, [h, {count, buf1, buf2}|t]}
     end
   end
 
-  @doc """
-  Creates a stream that drops every `nth` item from the enumerable.
-
-  The first item is always dropped, unless `nth` is 0.
-
-  `nth` must be a non-negative integer, or `FunctionClauseError` will be thrown.
-
-  ## Examples
-
-      iex> stream = Stream.drop_every(1..10, 2)
-      iex> Enum.to_list(stream)
-      [2, 4, 6, 8, 10]
-
-      iex> stream = Stream.drop_every(1..1000, 1)
-      iex> Enum.to_list(stream)
-      []
-
-      iex> stream = Stream.drop_every([1, 2, 3, 4, 5], 0)
-      iex> Enum.to_list(stream)
-      [1, 2, 3, 4, 5]
-
-  """
-  @spec drop_every(Enumerable.t, non_neg_integer) :: Enumerable.t
-  def drop_every(enum, 0), do: %Stream{enum: enum}
-  def drop_every([], _nth), do: %Stream{enum: []}
-
-  def drop_every(enum, nth) when is_integer(nth) and nth > 0 do
-    lazy enum, nth, fn(f1) -> R.drop_every(nth, f1) end
-  end
-
   @doc """
   Lazily drops elements of the enumerable while the given
   function returns `true`.
@@ -325,7 +257,7 @@ defmodule Stream do
 
       iex> stream = Stream.drop_while(1..10, &(&1 <= 5))
       iex> Enum.to_list(stream)
-      [6, 7, 8, 9, 10]
+      [6,7,8,9,10]
 
   """
   @spec drop_while(Enumerable.t, (element -> as_boolean(term))) :: Enumerable.t
@@ -334,7 +266,7 @@ defmodule Stream do
   end
 
   @doc """
-  Executes the given function for each item.
+  Execute the given function for each item.
 
   Useful for adding side effects (like printing) to a stream.
 
@@ -362,7 +294,7 @@ defmodule Stream do
 
   @doc """
   Creates a stream that will apply the given function on enumeration and
-  flatten the result, but only one level deep.
+  flatten the result.
 
   ## Examples
 
@@ -370,10 +302,6 @@ defmodule Stream do
       iex> Enum.to_list(stream)
       [1, 2, 2, 4, 3, 6]
 
-      iex> stream = Stream.flat_map([1, 2, 3], fn(x) -> [[x]] end)
-      iex> Enum.to_list(stream)
-      [[1], [2], [3]]
-
   """
   @spec flat_map(Enumerable.t, (element -> Enumerable.t)) :: Enumerable.t
   def flat_map(enum, mapper) do
@@ -406,7 +334,7 @@ defmodule Stream do
 
       iex> stream = Stream.filter_map(1..6, fn(x) -> rem(x, 2) == 0 end, &(&1 * 2))
       iex> Enum.to_list(stream)
-      [4, 8, 12]
+      [4,8,12]
 
   """
   @spec filter_map(Enumerable.t, (element -> as_boolean(term)), (element -> any)) :: Enumerable.t
@@ -415,22 +343,19 @@ defmodule Stream do
   end
 
   @doc """
-  Creates a stream that emits a value after the given period `n`
-  in milliseconds.
+  Creates a stream that emits a value every `n` milliseconds.
 
   The values emitted are an increasing counter starting at `0`.
-  This operation will block the caller by the given interval
-  every time a new item is streamed.
 
   ## Examples
 
       iex> Stream.interval(10) |> Enum.take(10)
-      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+      [0,1,2,3,4,5,6,7,8,9]
 
   """
   @spec interval(non_neg_integer) :: Enumerable.t
   def interval(n) do
-    unfold 0, fn(count) ->
+    unfold 0, fn (count) ->
       :timer.sleep(n)
       {count, count + 1}
     end
@@ -449,26 +374,26 @@ defmodule Stream do
 
   defp do_into(enum, collectable, transform, acc, fun) do
     {initial, into} = Collectable.into(collectable)
-    composed = fn x, [acc | collectable] ->
+    composed = fn x, [acc|collectable] ->
       collectable = into.(collectable, {:cont, transform.(x)})
       {reason, acc} = fun.(x, acc)
-      {reason, [acc | collectable]}
+      {reason, [acc|collectable]}
     end
     do_into(&Enumerable.reduce(enum, &1, composed), initial, into, acc)
   end
 
   defp do_into(reduce, collectable, into, {command, acc}) do
     try do
-      reduce.({command, [acc | collectable]})
+      reduce.({command, [acc|collectable]})
     catch
       kind, reason ->
         stacktrace = System.stacktrace
         into.(collectable, :halt)
         :erlang.raise(kind, reason, stacktrace)
     else
-      {:suspended, [acc | collectable], continuation} ->
+      {:suspended, [acc|collectable], continuation} ->
         {:suspended, acc, &do_into(continuation, collectable, into, &1)}
-      {reason, [acc | collectable]} ->
+      {reason, [acc|collectable]} ->
         into.(collectable, :done)
         {reason, acc}
     end
@@ -482,7 +407,7 @@ defmodule Stream do
 
       iex> stream = Stream.map([1, 2, 3], fn(x) -> x * 2 end)
       iex> Enum.to_list(stream)
-      [2, 4, 6]
+      [2,4,6]
 
   """
   @spec map(Enumerable.t, (element -> any)) :: Enumerable.t
@@ -498,7 +423,7 @@ defmodule Stream do
 
       iex> stream = Stream.reject([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
       iex> Enum.to_list(stream)
-      [1, 3]
+      [1,3]
 
   """
   @spec reject(Enumerable.t, (element -> as_boolean(term))) :: Enumerable.t
@@ -540,7 +465,7 @@ defmodule Stream do
 
       iex> stream = Stream.scan(1..5, &(&1 + &2))
       iex> Enum.to_list(stream)
-      [1, 3, 6, 10, 15]
+      [1,3,6,10,15]
 
   """
   @spec scan(Enumerable.t, (element, acc -> any)) :: Enumerable.t
@@ -557,7 +482,7 @@ defmodule Stream do
 
       iex> stream = Stream.scan(1..5, 0, &(&1 + &2))
       iex> Enum.to_list(stream)
-      [1, 3, 6, 10, 15]
+      [1,3,6,10,15]
 
   """
   @spec scan(Enumerable.t, acc, (element, acc -> any)) :: Enumerable.t
@@ -566,72 +491,85 @@ defmodule Stream do
   end
 
   @doc """
-  Lazily takes the next `count` items from the enumerable and stops
+  Lazily takes the next `n` items from the enumerable and stops
   enumeration.
 
-  If a negative `count` is given, the last `count` values will be taken.
-  For such, the collection is fully enumerated keeping up to `2 * count`
+  If a negative `n` is given, the last `n` values will be taken.
+  For such, the collection is fully enumerated keeping up to `2 * n`
   elements in memory. Once the end of the collection is reached,
   the last `count` elements will be executed. Therefore, using
-  a negative `count` on an infinite collection will never return.
+  a negative `n` on an infinite collection will never return.
 
   ## Examples
 
       iex> stream = Stream.take(1..100, 5)
       iex> Enum.to_list(stream)
-      [1, 2, 3, 4, 5]
+      [1,2,3,4,5]
 
       iex> stream = Stream.take(1..100, -5)
       iex> Enum.to_list(stream)
-      [96, 97, 98, 99, 100]
+      [96,97,98,99,100]
 
       iex> stream = Stream.cycle([1, 2, 3]) |> Stream.take(5)
       iex> Enum.to_list(stream)
-      [1, 2, 3, 1, 2]
+      [1,2,3,1,2]
 
   """
-  @spec take(Enumerable.t, integer) :: Enumerable.t
+  @spec take(Enumerable.t, non_neg_integer) :: Enumerable.t
   def take(_enum, 0), do: %Stream{enum: []}
-  def take([], _count), do: %Stream{enum: []}
 
-  def take(enum, count) when is_integer(count) and count > 0 do
-    lazy enum, count, fn(f1) -> R.take(f1) end
+  def take(enum, n) when n > 0 do
+    lazy enum, n, fn(f1) -> R.take(f1) end
   end
 
-  def take(enum, count) when is_integer(count) and count < 0 do
-    &Enumerable.reduce(Enum.take(enum, count), &1, &2)
+  def take(enum, n) when n < 0 do
+    &do_take(enum, abs(n), &1, &2)
   end
 
+  defp do_take(enum, n, acc, f) do
+    {_, {_count, buf1, buf2}} =
+      Enumerable.reduce(enum, {:cont, {0, [], []}}, fn
+        entry, {count, buf1, buf2} ->
+          buf1  = [entry|buf1]
+          count = count + 1
+          if count == n do
+            {:cont, {0, [], buf1}}
+          else
+            {:cont, {count, buf1, buf2}}
+          end
+      end)
+
+    Enumerable.reduce(do_take_last(buf1, buf2, n, []), acc, f)
+  end
+
+  defp do_take_last(_buf1, _buf2, 0, acc),
+    do: acc
+  defp do_take_last([], [], _, acc),
+    do: acc
+  defp do_take_last([], [h|t], n, acc),
+    do: do_take_last([], t, n-1, [h|acc])
+  defp do_take_last([h|t], buf2, n, acc),
+    do: do_take_last(t, buf2, n-1, [h|acc])
+
   @doc """
-  Creates a stream that takes every `nth` item from the enumerable.
+  Creates a stream that takes every `n` item from the enumerable.
 
-  The first item is always included, unless `nth` is 0.
-
-  `nth` must be a non-negative integer, or `FunctionClauseError` will be thrown.
+  The first item is always included, unless `n` is 0.
 
   ## Examples
 
       iex> stream = Stream.take_every(1..10, 2)
       iex> Enum.to_list(stream)
-      [1, 3, 5, 7, 9]
-
-      iex> stream = Stream.take_every([1, 2, 3, 4, 5], 1)
-      iex> Enum.to_list(stream)
-      [1, 2, 3, 4, 5]
-
-      iex> stream = Stream.take_every(1..1000, 0)
-      iex> Enum.to_list(stream)
-      []
+      [1,3,5,7,9]
 
   """
   @spec take_every(Enumerable.t, non_neg_integer) :: Enumerable.t
-  def take_every(_enum, 0), do: %Stream{enum: []}
-  def take_every([], _nth), do: %Stream{enum: []}
-
-  def take_every(enum, nth) when is_integer(nth) and nth > 0 do
-    lazy enum, nth, fn(f1) -> R.take_every(nth, f1) end
+  def take_every(enum, n) when n > 0 do
+    lazy enum, n, fn(f1) -> R.take_every(n, f1) end
   end
 
+  def take_every(_enum, 0), do: %Stream{enum: []}
+
   @doc """
   Lazily takes elements of the enumerable while the given
   function returns `true`.
@@ -640,7 +578,7 @@ defmodule Stream do
 
       iex> stream = Stream.take_while(1..100, &(&1 <= 5))
       iex> Enum.to_list(stream)
-      [1, 2, 3, 4, 5]
+      [1,2,3,4,5]
 
   """
   @spec take_while(Enumerable.t, (element -> as_boolean(term))) :: Enumerable.t
@@ -651,8 +589,7 @@ defmodule Stream do
   @doc """
   Creates a stream that emits a single value after `n` milliseconds.
 
-  The value emitted is `0`. This operation will block the caller by
-  the given time until the item is streamed.
+  The value emitted is `0`.
 
   ## Examples
 
@@ -689,139 +626,100 @@ defmodule Stream do
       ...>   if acc < n, do: {[i], acc + 1}, else: {:halt, acc}
       ...> end)
       iex> Enum.to_list(stream)
-      [1, 2, 3]
+      [1,2,3]
 
   """
   @spec transform(Enumerable.t, acc, fun) :: Enumerable.t when
         fun: (element, acc -> {Enumerable.t, acc} | {:halt, acc}),
         acc: any
-  def transform(enum, acc, reducer) when is_function(reducer, 2) do
-    &do_transform(enum, fn -> acc end, reducer, &1, &2, nil)
+  def transform(enum, acc, reducer) do
+    &do_transform(enum, acc, reducer, &1, &2)
   end
 
-  @doc """
-  Transforms an existing stream with function-based start and finish.
-
-  The accumulator is only calculated when transformation starts. It also
-  allows an after function to be given which is invoked when the stream
-  halts or completes.
-
-  This function can be seen as a combination of `Stream.resource/3` with
-  `Stream.transform/3`.
-  """
-  @spec transform(Enumerable.t, (() -> acc), fun, (acc -> term)) :: Enumerable.t when
-        fun: (element, acc -> {Enumerable.t, acc} | {:halt, acc}),
-        acc: any
-  def transform(enum, start_fun, reducer, after_fun)
-      when is_function(start_fun, 0) and is_function(reducer, 2) and is_function(after_fun, 1) do
-    &do_transform(enum, start_fun, reducer, &1, &2, after_fun)
-  end
-
-  defp do_transform(enumerables, user_acc, user, inner_acc, fun, after_fun) do
+  defp do_transform(enumerables, user_acc, user, inner_acc, fun) do
     inner = &do_transform_each(&1, &2, fun)
     step  = &do_transform_step(&1, &2)
     next  = &Enumerable.reduce(enumerables, &1, step)
-    do_transform(user_acc.(), user, fun, [], next, inner_acc, inner, after_fun)
+    do_transform(user_acc, user, fun, [], next, inner_acc, inner)
   end
 
-  defp do_transform(user_acc, _user, _fun, _next_acc, _next, {:halt, inner_acc}, _inner, after_fun) do
-    do_after(after_fun, user_acc)
-    {:halted, inner_acc}
-  end
-
-  defp do_transform(user_acc, user, fun, next_acc, next, {:suspend, inner_acc}, inner, after_fun) do
-    {:suspended, inner_acc, &do_transform(user_acc, user, fun, next_acc, next, &1, inner, after_fun)}
-  end
-
-  defp do_transform(user_acc, user, fun, next_acc, next, inner_acc, inner, after_fun) do
+  defp do_transform(user_acc, user, fun, next_acc, next, inner_acc, inner) do
     case next.({:cont, next_acc}) do
-      {:suspended, [val | next_acc], next} ->
+      {:suspended, [val|next_acc], next} ->
         try do
           user.(val, user_acc)
         catch
           kind, reason ->
             stacktrace = System.stacktrace
             next.({:halt, next_acc})
-            do_after(after_fun, user_acc)
             :erlang.raise(kind, reason, stacktrace)
         else
           {[], user_acc} ->
-            do_transform(user_acc, user, fun, next_acc, next, inner_acc, inner, after_fun)
+            do_transform(user_acc, user, fun, next_acc, next, inner_acc, inner)
           {list, user_acc} when is_list(list) ->
             do_list_transform(user_acc, user, fun, next_acc, next, inner_acc, inner,
-                              &Enumerable.List.reduce(list, &1, fun), after_fun)
-          {:halt, user_acc} ->
+                              &Enumerable.List.reduce(list, &1, fun))
+          {:halt, _user_acc} ->
             next.({:halt, next_acc})
-            do_after(after_fun, user_acc)
             {:halted, elem(inner_acc, 1)}
           {other, user_acc} ->
             do_enum_transform(user_acc, user, fun, next_acc, next, inner_acc, inner,
-                              &Enumerable.reduce(other, &1, inner), after_fun)
+                              &Enumerable.reduce(other, &1, inner))
         end
       {reason, _} ->
-        do_after(after_fun, user_acc)
         {reason, elem(inner_acc, 1)}
     end
   end
 
-  defp do_list_transform(user_acc, user, fun, next_acc, next, inner_acc, inner, reduce, after_fun) do
+  defp do_list_transform(user_acc, user, fun, next_acc, next, inner_acc, inner, reduce) do
     try do
       reduce.(inner_acc)
     catch
       kind, reason ->
         stacktrace = System.stacktrace
         next.({:halt, next_acc})
-        do_after(after_fun, user_acc)
         :erlang.raise(kind, reason, stacktrace)
     else
       {:done, acc} ->
-        do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner, after_fun)
+        do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner)
       {:halted, acc} ->
         next.({:halt, next_acc})
-        do_after(after_fun, user_acc)
         {:halted, acc}
       {:suspended, acc, c} ->
-        {:suspended, acc, &do_list_transform(user_acc, user, fun, next_acc, next, &1, inner, c, after_fun)}
+        {:suspended, acc, &do_list_transform(user_acc, user, fun, next_acc, next, &1, inner, c)}
     end
   end
 
-  defp do_enum_transform(user_acc, user, fun, next_acc, next, {op, inner_acc}, inner, reduce, after_fun) do
+  defp do_enum_transform(user_acc, user, fun, next_acc, next, {op, inner_acc}, inner, reduce) do
     try do
-      reduce.({op, [:outer | inner_acc]})
+      reduce.({op, [:outer|inner_acc]})
     catch
       kind, reason ->
         stacktrace = System.stacktrace
         next.({:halt, next_acc})
-        do_after(after_fun, user_acc)
         :erlang.raise(kind, reason, stacktrace)
     else
-      # Only take into account outer halts when the op is not halt itself.
-      # Otherwise, we were the ones wishing to halt, so we should just stop.
-      {:halted, [:outer | acc]} when op != :halt ->
-        do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner, after_fun)
-      {:halted, [_ | acc]} ->
+      {:halted, [:outer|acc]} ->
+        do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner)
+      {:halted, [:inner|acc]} ->
         next.({:halt, next_acc})
-        do_after(after_fun, user_acc)
         {:halted, acc}
-      {:done, [_ | acc]} ->
-        do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner, after_fun)
-      {:suspended, [_ | acc], c} ->
-        {:suspended, acc, &do_enum_transform(user_acc, user, fun, next_acc, next, &1, inner, c, after_fun)}
+      {:done, [_|acc]} ->
+        do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner)
+      {:suspended, [_|acc], c} ->
+        {:suspended, acc, &do_enum_transform(user_acc, user, fun, next_acc, next, &1, inner, c)}
     end
   end
 
-  defp do_after(nil, _user_acc), do: :ok
-  defp do_after(fun, user_acc),  do: fun.(user_acc)
-
-  defp do_transform_each(x, [:outer | acc], f) do
+  defp do_transform_each(x, [:outer|acc], f) do
     case f.(x, acc) do
-      {:halt, res} -> {:halt, [:inner | res]}
-      {op, res}    -> {op, [:outer | res]}
+      {:halt, res} -> {:halt, [:inner|res]}
+      {op, res}    -> {op, [:outer|res]}
     end
   end
 
   defp do_transform_step(x, acc) do
-    {:suspend, [x | acc]}
+    {:suspend, [x|acc]}
   end
 
   @doc """
@@ -834,17 +732,17 @@ defmodule Stream do
 
   ## Examples
 
-      iex> Stream.uniq([1, 2, 3, 3, 2, 1]) |> Enum.to_list
+      iex> Stream.uniq([1, 2, 3, 2, 1]) |> Enum.to_list
       [1, 2, 3]
 
-      iex> Stream.uniq([{1, :x}, {2, :y}, {2, :z}, {1, :x}], fn {x, _} -> x end) |> Enum.to_list
-      [{1, :x}, {2, :y}]
+      iex> Stream.uniq([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end) |> Enum.to_list
+      [{1,:x}, {2,:y}]
 
   """
   @spec uniq(Enumerable.t) :: Enumerable.t
   @spec uniq(Enumerable.t, (element -> term)) :: Enumerable.t
   def uniq(enum, fun \\ fn x -> x end) do
-    lazy enum, %{}, fn f1 -> R.uniq(fun, f1) end
+    lazy enum, [], fn f1 -> R.uniq(fun, f1) end
   end
 
   @doc """
@@ -855,17 +753,12 @@ defmodule Stream do
 
       iex> stream = Stream.with_index([1, 2, 3])
       iex> Enum.to_list(stream)
-      [{1, 0}, {2, 1}, {3, 2}]
-
-      iex> stream = Stream.with_index([1, 2, 3], 3)
-      iex> Enum.to_list(stream)
-      [{1, 3}, {2, 4}, {3, 5}]
+      [{1,0},{2,1},{3,2}]
 
   """
   @spec with_index(Enumerable.t) :: Enumerable.t
-  @spec with_index(Enumerable.t, integer) :: Enumerable.t
-  def with_index(enum, offset \\ 0) do
-    lazy enum, offset, fn(f1) -> R.with_index(f1) end
+  def with_index(enum) do
+    lazy enum, 0, fn(f1) -> R.with_index(f1) end
   end
 
   ## Combiners
@@ -877,7 +770,7 @@ defmodule Stream do
 
       iex> stream = Stream.concat([1..3, 4..6, 7..9])
       iex> Enum.to_list(stream)
-      [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      [1,2,3,4,5,6,7,8,9]
 
   """
   @spec concat(Enumerable.t) :: Enumerable.t
@@ -892,13 +785,13 @@ defmodule Stream do
 
       iex> stream = Stream.concat(1..3, 4..6)
       iex> Enum.to_list(stream)
-      [1, 2, 3, 4, 5, 6]
+      [1,2,3,4,5,6]
 
       iex> stream1 = Stream.cycle([1, 2, 3])
       iex> stream2 = Stream.cycle([4, 5, 6])
       iex> stream = Stream.concat(stream1, stream2)
       iex> Enum.take(stream, 6)
-      [1, 2, 3, 1, 2, 3]
+      [1,2,3,1,2,3]
 
   """
   @spec concat(Enumerable.t, Enumerable.t) :: Enumerable.t
@@ -916,7 +809,7 @@ defmodule Stream do
       iex> concat = Stream.concat(1..3, 4..6)
       iex> cycle  = Stream.cycle([:a, :b, :c])
       iex> Stream.zip(concat, cycle) |> Enum.to_list
-      [{1, :a}, {2, :b}, {3, :c}, {4, :a}, {5, :b}, {6, :c}]
+      [{1,:a},{2,:b},{3,:c},{4,:a},{5,:b},{6,:c}]
 
   """
   @spec zip(Enumerable.t, Enumerable.t) :: Enumerable.t
@@ -954,12 +847,12 @@ defmodule Stream do
     end
   end
 
-  defp do_zip([{fun, fun_acc} | t], acc, callback, list, buffer) do
+  defp do_zip([{fun, fun_acc}|t], acc, callback, list, buffer) do
     case fun.({:cont, fun_acc}) do
-      {:suspended, [i | fun_acc], fun} ->
-        do_zip(t, acc, callback, [i | list], [{fun, fun_acc} | buffer])
+      {:suspended, [i|fun_acc], fun} ->
+        do_zip(t, acc, callback, [i|list], [{fun, fun_acc}|buffer])
       {_, _} ->
-        do_zip_close(:lists.reverse(buffer, t))
+        do_zip_close(:lists.reverse(buffer) ++ t)
         {:done, acc}
     end
   end
@@ -970,13 +863,13 @@ defmodule Stream do
   end
 
   defp do_zip_close([]), do: :ok
-  defp do_zip_close([{fun, acc} | t]) do
+  defp do_zip_close([{fun, acc}|t]) do
     fun.({:halt, acc})
     do_zip_close(t)
   end
 
   defp do_zip_step(x, acc) do
-    {:suspend, [x | acc]}
+    {:suspend, [x|acc]}
   end
 
   ## Sources
@@ -987,9 +880,9 @@ defmodule Stream do
 
   ## Examples
 
-      iex> stream = Stream.cycle([1, 2, 3])
+      iex> stream = Stream.cycle([1,2,3])
       iex> Enum.take(stream, 5)
-      [1, 2, 3, 1, 2]
+      [1,2,3,1,2]
 
   """
   @spec cycle(Enumerable.t) :: Enumerable.t
@@ -1040,13 +933,13 @@ defmodule Stream do
   end
 
   @doc """
-  Emits a sequence of values, starting with `start_value`. Successive
+  Emit a sequence of values, starting with `start_value`. Successive
   values are generated by calling `next_fun` on the previous value.
 
   ## Examples
 
       iex> Stream.iterate(0, &(&1+1)) |> Enum.take(5)
-      [0, 1, 2, 3, 4]
+      [0,1,2,3,4]
 
   """
   @spec iterate(element, (element -> element)) :: Enumerable.t
@@ -1065,10 +958,8 @@ defmodule Stream do
 
   ## Examples
 
-      # Although not necessary, let's seed the random algorithm
-      iex> :rand.seed(:exsplus, {1, 2, 3})
-      iex> Stream.repeatedly(&:rand.uniform/0) |> Enum.take(3)
-      [0.40502929729990744, 0.45336720247823126, 0.04094511692041057]
+      iex> Stream.repeatedly(&:random.uniform/0) |> Enum.take(3)
+      [0.4435846174457203, 0.7230402056221108, 0.94581636451987]
 
   """
   @spec repeatedly((() -> element)) :: Enumerable.t
@@ -1091,7 +982,7 @@ defmodule Stream do
   @doc """
   Emits a sequence of values for the given resource.
 
-  Similar to `transform/3` but the initial accumulated value is
+  Similar to `transform/2` but the initial accumulated value is
   computed lazily via `start_fun` and executes an `after_fun` at
   the end of enumeration (both in cases of success and failure).
 
@@ -1116,7 +1007,7 @@ defmodule Stream do
                       fn file -> File.close(file) end)
 
   """
-  @spec resource((() -> acc), (acc -> {[element], acc} | {:halt, acc}), (acc -> term)) :: Enumerable.t
+  @spec resource((() -> acc), (acc -> {element, acc} | nil), (acc -> term)) :: Enumerable.t
   def resource(start_fun, next_fun, after_fun) do
     &do_resource(start_fun.(), next_fun, &1, &2, after_fun)
   end
@@ -1178,28 +1069,28 @@ defmodule Stream do
 
   defp do_enum_resource(next_acc, next_fun, {op, acc}, fun, after_fun, reduce) do
     try do
-      reduce.({op, [:outer | acc]})
+      reduce.({op, [:outer|acc]})
     catch
       kind, reason ->
         stacktrace = System.stacktrace
         after_fun.(next_acc)
         :erlang.raise(kind, reason, stacktrace)
     else
-      {:halted, [:outer | acc]} ->
+      {:halted, [:outer|acc]} ->
         do_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun)
-      {:halted, [:inner | acc]} ->
+      {:halted, [:inner|acc]} ->
         do_resource(next_acc, next_fun, {:halt, acc}, fun, after_fun)
-      {:done, [_ | acc]} ->
+      {:done, [_|acc]} ->
         do_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun)
-      {:suspended, [_ | acc], c} ->
+      {:suspended, [_|acc], c} ->
         {:suspended, acc, &do_enum_resource(next_acc, next_fun, &1, fun, after_fun, c)}
     end
   end
 
-  defp do_resource_each(x, [:outer | acc], f) do
+  defp do_resource_each(x, [:outer|acc], f) do
     case f.(x, acc) do
-      {:halt, res} -> {:halt, [:inner | res]}
-      {op, res}    -> {op, [:outer | res]}
+      {:halt, res} -> {:halt, [:inner|res]}
+      {op, res}    -> {op, [:outer|res]}
     end
   end
 
@@ -1241,17 +1132,17 @@ defmodule Stream do
   @compile {:inline, lazy: 2, lazy: 3, lazy: 4}
 
   defp lazy(%Stream{done: nil, funs: funs} = lazy, fun),
-    do: %{lazy | funs: [fun | funs] }
+    do: %{lazy | funs: [fun|funs] }
   defp lazy(enum, fun),
     do: %Stream{enum: enum, funs: [fun]}
 
   defp lazy(%Stream{done: nil, funs: funs, accs: accs} = lazy, acc, fun),
-    do: %{lazy | funs: [fun | funs], accs: [acc | accs] }
+    do: %{lazy | funs: [fun|funs], accs: [acc|accs] }
   defp lazy(enum, acc, fun),
     do: %Stream{enum: enum, funs: [fun], accs: [acc]}
 
   defp lazy(%Stream{done: nil, funs: funs, accs: accs} = lazy, acc, fun, done),
-    do: %{lazy | funs: [fun | funs], accs: [acc | accs], done: done}
+    do: %{lazy | funs: [fun|funs], accs: [acc|accs], done: done}
   defp lazy(enum, acc, fun, done),
     do: %Stream{enum: enum, funs: [fun], accs: [acc], done: done}
 end
@@ -1281,8 +1172,8 @@ defimpl Enumerable, for: Stream do
   end
 
   defp do_each(reduce, done, accs, {command, acc}) do
-    case reduce.({command, [acc | accs]}) do
-      {:suspended, [acc | accs], continuation} ->
+    case reduce.({command, [acc|accs]}) do
+      {:suspended, [acc|accs], continuation} ->
         {:suspended, acc, &do_each(continuation, done, accs, &1)}
       {:halted, accs} ->
         do_done {:halted, accs}, done
@@ -1291,13 +1182,13 @@ defimpl Enumerable, for: Stream do
     end
   end
 
-  defp do_done({reason, [acc | _]}, nil), do: {reason, acc}
-  defp do_done({reason, [acc | t]}, {done, fun}) do
-    [h | _] = Enum.reverse(t)
+  defp do_done({reason, [acc|_]}, nil), do: {reason, acc}
+  defp do_done({reason, [acc|t]}, {done, fun}) do
+    [h|_] = Enum.reverse(t)
     case done.([acc, h], fun) do
-      {:cont, [acc | _]}    -> {reason, acc}
-      {:halt, [acc | _]}    -> {:halted, acc}
-      {:suspend, [acc | _]} -> {:suspended, acc, &({:done, elem(&1, 1)})}
+      {:cont, [acc|_]}    -> {reason, acc}
+      {:halt, [acc|_]}    -> {:halted, acc}
+      {:suspend, [acc|_]} -> {:suspended, acc, &({:done, elem(&1, 1)})}
     end
   end
 end

lib/elixir/lib/stream/reducers.ex

@@ -5,7 +5,7 @@ defmodule Stream.Reducers do
   defmacro chunk(n, step, limit, f \\ nil) do
     quote do
       fn entry, acc(h, {buffer, count}, t) ->
-        buffer = [entry | buffer]
+        buffer = [entry|buffer]
         count  = count + 1
 
         new =
@@ -17,9 +17,9 @@ defmodule Stream.Reducers do
           end
 
         if count == unquote(n) do
-          next_with_acc(unquote(f), :lists.reverse(buffer), h, new, t)
+          cont_with_acc(unquote(f), :lists.reverse(buffer), h, new, t)
         else
-          skip(acc(h, new, t))
+          {:cont, acc(h, new, t)}
         end
       end
     end
@@ -31,24 +31,12 @@ defmodule Stream.Reducers do
         entry, acc(h, {buffer, value}, t) ->
           new_value = unquote(callback).(entry)
           if new_value == value do
-            skip(acc(h, {[entry | buffer], value}, t))
+            {:cont, acc(h, {[entry|buffer], value}, t)}
           else
-            next_with_acc(unquote(f), :lists.reverse(buffer), h, {[entry], new_value}, t)
+            cont_with_acc(unquote(f), :lists.reverse(buffer), h, {[entry], new_value}, t)
           end
         entry, acc(h, nil, t) ->
-          skip(acc(h, {[entry], unquote(callback).(entry)}, t))
-      end
-    end
-  end
-
-  defmacro dedup(callback, f \\ nil) do
-    quote do
-      fn(entry, acc(h, prev, t) = acc) ->
-        value = unquote(callback).(entry)
-        case prev do
-          {:value, ^value}  -> skip(acc)
-          _ -> next_with_acc(unquote(f), entry, h, {:value, value}, t)
-        end
+          {:cont, acc(h, {[entry], unquote(callback).(entry)}, t)}
       end
     end
   end
@@ -57,21 +45,9 @@ defmodule Stream.Reducers do
     quote do
       fn
         _entry, acc(h, n, t) when n > 0 ->
-          skip(acc(h, n-1, t))
+          {:cont, acc(h, n-1, t)}
         entry, acc(h, n, t) ->
-          next_with_acc(unquote(f), entry, h, n, t)
-      end
-    end
-  end
-
-  defmacro drop_every(nth, f \\ nil) do
-    quote do
-      fn
-        entry, acc(h, n, t) when n === :first
-                            when n === unquote(nth) ->
-          skip(acc(h, 1, t))
-        entry, acc(h, n, t) ->
-          next_with_acc(unquote(f), entry, h, n+1, t)
+          cont_with_acc(unquote(f), entry, h, n, t)
       end
     end
   end
@@ -80,9 +56,9 @@ defmodule Stream.Reducers do
     quote do
       fn entry, acc(h, bool, t) = orig ->
         if bool and unquote(callback).(entry) do
-          skip(orig)
+          {:cont, orig}
         else
-          next_with_acc(unquote(f), entry, h, false, t)
+          cont_with_acc(unquote(f), entry, h, false, t)
         end
       end
     end
@@ -92,9 +68,9 @@ defmodule Stream.Reducers do
     quote do
       fn(entry, acc) ->
         if unquote(callback).(entry) do
-          next(unquote(f), entry, acc)
+          cont(unquote(f), entry, acc)
         else
-          skip(acc)
+          {:cont, acc}
         end
       end
     end
@@ -104,9 +80,9 @@ defmodule Stream.Reducers do
     quote do
       fn(entry, acc) ->
         if unquote(filter).(entry) do
-          next(unquote(f), unquote(mapper).(entry), acc)
+          cont(unquote(f), unquote(mapper).(entry), acc)
         else
-          skip(acc)
+          {:cont, acc}
         end
       end
     end
@@ -115,7 +91,7 @@ defmodule Stream.Reducers do
   defmacro map(callback, f \\ nil) do
     quote do
       fn(entry, acc) ->
-        next(unquote(f), unquote(callback).(entry), acc)
+        cont(unquote(f), unquote(callback).(entry), acc)
       end
     end
   end
@@ -124,9 +100,9 @@ defmodule Stream.Reducers do
     quote do
       fn(entry, acc) ->
         unless unquote(callback).(entry) do
-          next(unquote(f), entry, acc)
+          cont(unquote(f), entry, acc)
         else
-          skip(acc)
+          {:cont, acc}
         end
       end
     end
@@ -136,10 +112,10 @@ defmodule Stream.Reducers do
     quote do
       fn
         entry, acc(h, :first, t) ->
-          next_with_acc(unquote(f), entry, h, {:ok, entry}, t)
+          cont_with_acc(unquote(f), entry, h, {:ok, entry}, t)
         entry, acc(h, {:ok, acc}, t) ->
           value = unquote(callback).(entry, acc)
-          next_with_acc(unquote(f), value, h, {:ok, value}, t)
+          cont_with_acc(unquote(f), value, h, {:ok, value}, t)
       end
     end
   end
@@ -148,7 +124,7 @@ defmodule Stream.Reducers do
     quote do
       fn(entry, acc(h, acc, t)) ->
         value = unquote(callback).(entry, acc)
-        next_with_acc(unquote(f), value, h, value, t)
+        cont_with_acc(unquote(f), value, h, value, t)
       end
     end
   end
@@ -156,16 +132,10 @@ defmodule Stream.Reducers do
   defmacro take(f \\ nil) do
     quote do
       fn(entry, acc(h, n, t) = orig) ->
-        case n do
-          0 ->
-            {:halt, orig}
-          1 ->
-            case next_with_acc(unquote(f), entry, h, n-1, t) do
-              {:cont, acc} -> {:halt, acc}
-              reason -> reason
-            end
-          _ ->
-            next_with_acc(unquote(f), entry, h, n-1, t)
+        if n >= 1 do
+          cont_with_acc(unquote(f), entry, h, n-1, t)
+        else
+          {:halt, orig}
         end
       end
     end
@@ -176,9 +146,9 @@ defmodule Stream.Reducers do
       fn
         entry, acc(h, n, t) when n === :first
                             when n === unquote(nth) ->
-          next_with_acc(unquote(f), entry, h, 1, t)
+          cont_with_acc(unquote(f), entry, h, 1, t)
         entry, acc(h, n, t) ->
-          skip(acc(h, n+1, t))
+          {:cont, acc(h, n+1, t)}
       end
     end
   end
@@ -187,7 +157,7 @@ defmodule Stream.Reducers do
     quote do
       fn(entry, acc) ->
         if unquote(callback).(entry) do
-          next(unquote(f), entry, acc)
+          cont(unquote(f), entry, acc)
         else
           {:halt, acc}
         end
@@ -199,10 +169,10 @@ defmodule Stream.Reducers do
     quote do
       fn(entry, acc(h, prev, t) = acc) ->
         value = unquote(callback).(entry)
-        if Map.has_key?(prev, value) do
-          skip(acc)
+        if :lists.member(value, prev) do
+          {:cont, acc}
         else
-          next_with_acc(unquote(f), entry, h, Map.put(prev, value, true), t)
+          cont_with_acc(unquote(f), entry, h, [value|prev], t)
         end
       end
     end
@@ -211,7 +181,7 @@ defmodule Stream.Reducers do
   defmacro with_index(f \\ nil) do
     quote do
       fn(entry, acc(h, counter, t)) ->
-        next_with_acc(unquote(f), {entry, counter}, h, counter + 1, t)
+        cont_with_acc(unquote(f), {entry, counter}, h, counter + 1, t)
       end
     end
   end

lib/elixir/lib/string/chars.ex

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

lib/elixir/lib/string_io.ex

@@ -1,9 +1,6 @@
 defmodule StringIO do
   @moduledoc """
-  Controls an IO device process that wraps a string.
-
-  A `StringIO` IO device can be passed as a "device" to
-  most of the functions in the `IO` module.
+  This module provides an IO device that wraps a string.
 
   ## Examples
 
@@ -18,9 +15,6 @@ defmodule StringIO do
   @doc """
   Creates an IO device.
 
-  `string` will be the initial input of the newly created
-  device.
-
   If the `:capture_prompt` option is set to `true`,
   prompts (specified as arguments to `IO.get*` functions)
   are captured.
@@ -46,8 +40,7 @@ defmodule StringIO do
   end
 
   @doc """
-  Returns the current input/output buffers for the given IO
-  device.
+  Returns current buffers.
 
   ## Examples
 
@@ -63,26 +56,7 @@ defmodule StringIO do
   end
 
   @doc """
-  Flushes the output buffer and returns its current contents.
-
-  ## Examples
-
-      iex> {:ok, pid} = StringIO.open("in")
-      iex> IO.write(pid, "out")
-      iex> StringIO.flush(pid)
-      "out"
-      iex> StringIO.contents(pid)
-      {"in", ""}
-
-  """
-  @spec flush(pid) :: binary
-  def flush(pid) when is_pid(pid) do
-    GenServer.call(pid, :flush)
-  end
-
-  @doc """
-  Stops the IO device and returns the remaining input/output
-  buffers.
+  Stops the IO device and returns remaining buffers.
 
   ## Examples
 
@@ -117,10 +91,6 @@ defmodule StringIO do
     {:reply, {input, output}, s}
   end
 
-  def handle_call(:flush, _from, %{output: output} = s) do
-    {:reply, output, %{s | output: ""}}
-  end
-
   def handle_call(:close, _from, %{input: input, output: output} = s) do
     {:stop, :normal, {:ok, {input, output}}, s}
   end
@@ -135,20 +105,21 @@ defmodule StringIO do
     s
   end
 
-  defp io_request({:put_chars, chars} = req, s) do
-    put_chars(:latin1, chars, req, s)
+  defp io_request({:put_chars, chars}, %{output: output} = s) do
+    {:ok, %{s | output: << output :: binary, IO.chardata_to_string(chars) :: binary >>}}
   end
 
-  defp io_request({:put_chars, m, f, as} = req, s) do
-    put_chars(:latin1, apply(m, f, as), req, s)
+  defp io_request({:put_chars, m, f, as}, %{output: output} = s) do
+    chars = apply(m, f, as)
+    {:ok, %{s | output: << output :: binary, IO.chardata_to_string(chars) :: binary >>}}
   end
 
-  defp io_request({:put_chars, encoding, chars} = req, s) do
-    put_chars(encoding, chars, req, s)
+  defp io_request({:put_chars, _encoding, chars}, s) do
+    io_request({:put_chars, chars}, s)
   end
 
-  defp io_request({:put_chars, encoding, mod, func, args} = req, s) do
-    put_chars(encoding, apply(mod, func, args), req, s)
+  defp io_request({:put_chars, _encoding, mod, func, args}, s) do
+    io_request({:put_chars, mod, func, args}, s)
   end
 
   defp io_request({:get_chars, prompt, n}, s) when n >= 0 do
@@ -203,17 +174,6 @@ defmodule StringIO do
     {{:error, :request}, s}
   end
 
-  ## put_chars
-
-  defp put_chars(encoding, chars, req, %{output: output} = s) do
-    case :unicode.characters_to_binary(chars, encoding, :unicode) do
-      string when is_binary(string) ->
-        {:ok, %{s | output: output <> string}}
-      {_, _, _} ->
-        {{:error, req}, s}
-    end
-  end
-
   ## get_chars
 
   defp get_chars(encoding, prompt, n,
@@ -222,14 +182,11 @@ defmodule StringIO do
       {:error, _} = error ->
         {error, s}
       {result, input} ->
-        s =
-          if capture_prompt do
-            %{s | output: <<output::binary, IO.chardata_to_string(prompt)::binary>>}
-          else
-            s
-          end
+        if capture_prompt do
+          output = << output :: binary, IO.chardata_to_string(prompt) :: binary >>
+        end
 
-        {result, %{s | input: input}}
+        {result, %{s | input: input, output: output}}
     end
   end
 
@@ -242,7 +199,7 @@ defmodule StringIO do
   end
 
   defp do_get_chars(input, :latin1, n) do
-    <<chars::binary-size(n), rest::binary>> = input
+    <<chars :: binary-size(n), rest :: binary>> = input
     {chars, rest}
   end
 
@@ -252,7 +209,7 @@ defmodule StringIO do
         {buf_count, split_pos} when buf_count < n or split_pos == :none ->
           {input, ""}
         {_buf_count, split_pos} ->
-          <<chars::binary-size(split_pos), rest::binary>> = input
+          <<chars :: binary-size(split_pos), rest :: binary>> = input
           {chars, rest}
       end
     catch
@@ -273,14 +230,11 @@ defmodule StringIO do
       chars ->
         {result, input} = do_get_line(chars, encoding)
 
-        s =
-          if capture_prompt do
-            %{s | output: <<output::binary, IO.chardata_to_string(prompt)::binary>>}
-          else
-            s
-          end
+        if capture_prompt do
+          output = << output :: binary, IO.chardata_to_string(prompt) :: binary >>
+        end
 
-        {result, %{s | input: input}}
+        {result, %{s | input: input, output: output}}
     end
   end
 
@@ -306,20 +260,17 @@ defmodule StringIO do
       chars ->
         {result, input, count} = do_get_until(chars, encoding, mod, fun, args)
 
+        if capture_prompt do
+          output = << output :: binary, :binary.copy(IO.chardata_to_string(prompt), count) :: binary >>
+        end
+
         input =
           case input do
             :eof -> ""
             _ -> :unicode.characters_to_binary(input, encoding)
           end
 
-        s =
-          if capture_prompt do
-            %{s | output: <<output::binary, :binary.copy(IO.chardata_to_string(prompt), count)::binary>>}
-          else
-            s
-          end
-
-        {result, %{s | input: input}}
+        {result, %{s | input: input, output: output}}
     end
   end
 
@@ -338,10 +289,11 @@ defmodule StringIO do
     {line, rest} = collect_line(chars)
 
     case apply(mod, fun, [continuation, line | args]) do
-      {:done, result, :eof} ->
+      {:done, result, rest1} ->
+        unless rest1 == :eof do
+          rest = rest1 ++ rest
+        end
         {result, rest, count + 1}
-      {:done, result, extra} ->
-        {result, extra ++ rest, count + 1}
       {:more, next_continuation} ->
         do_get_until(rest, encoding, mod, fun, args, next_continuation, count + 1)
     end
@@ -349,7 +301,7 @@ defmodule StringIO do
 
   ## io_requests
 
-  defp io_requests([r | rs], {:ok, s}) do
+  defp io_requests([r|rs], {:ok, s}) do
     io_requests(rs, io_request(r, s))
   end
 
@@ -368,15 +320,15 @@ defmodule StringIO do
   end
 
   defp collect_line([?\r, ?\n | rest], stack) do
-    {:lists.reverse([?\n | stack]), rest}
+    {:lists.reverse([?\n|stack]), rest}
   end
 
   defp collect_line([?\n | rest], stack) do
-    {:lists.reverse([?\n | stack]), rest}
+    {:lists.reverse([?\n|stack]), rest}
   end
 
-  defp collect_line([h | t], stack) do
-    collect_line(t, [h | stack])
+  defp collect_line([h|t], stack) do
+    collect_line(t, [h|stack])
   end
 
   defp io_reply(from, reply_as, reply) do

lib/elixir/lib/supervisor.ex

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

lib/elixir/lib/supervisor/default.ex

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

lib/elixir/lib/supervisor/spec.ex

@@ -1,11 +1,11 @@
 defmodule Supervisor.Spec do
   @moduledoc """
-  Convenience functions for defining supervisor specifications.
+  Convenience functions for defining a supervision specification.
 
   ## Example
 
-  By using the functions in this module one can specify the children
-  to be used under a supervisor, started with `Supervisor.start_link/2`:
+  By using the functions in this module one can define a supervisor
+  and start it with `Supervisor.start_link/2`:
 
       import Supervisor.Spec
 
@@ -16,7 +16,7 @@ defmodule Supervisor.Spec do
 
       Supervisor.start_link(children, strategy: :one_for_one)
 
-  Sometimes, it may be handy to define supervisors backed
+  In many situations, it may be handy to define supervisors backed
   by a module:
 
       defmodule MySupervisor do
@@ -37,35 +37,42 @@ defmodule Supervisor.Spec do
 
   Notice in this case we don't have to explicitly import
   `Supervisor.Spec` as `use Supervisor` automatically does so.
-  Defining a module-based supervisor can be useful, for example,
-  to perform initialization tasks in the `init/1` callback.
+
+  Explicit supervisors as above are required when there is a need to:
+
+    1. Partialy change the supervision tree during hot-code swaps.
+
+    2. Define supervisors inside other supervisors.
+
+    3. Perform actions inside the supervision `init/1` callback.
+
+       For example, you may want to start an ETS table that is linked to
+       the supervisor (i.e. if the supervision tree needs to be restarted,
+       the ETS table must be restarted too).
 
   ## Supervisor and worker options
 
-  In the example above, we defined specs for workers and supervisors.
-  These specs (both for workers as well as supervisors) accept the
-  following options:
+  In the example above, we have defined workers and supervisors
+  and each accepts the following options:
 
     * `:id` - a name used to identify the child specification
       internally by the supervisor; defaults to the given module
-      name for the child worker/supervisor
+      name
 
     * `:function` - the function to invoke on the child to start it
 
-    * `:restart` - an atom that defines when a terminated child process should
-      be restarted (see the "Restart values" section below)
+    * `:restart` - defines when the child process should restart
 
-    * `:shutdown` - an atom that defines how a child process should be
-      terminated (see the "Shutdown values" section below)
+    * `:shutdown` - defines how a child process should be terminated
 
     * `:modules` - it should be a list with one element `[module]`,
       where module is the name of the callback module only if the
       child process is a `Supervisor` or `GenServer`; if the child
-      process is a `GenEvent`, `:modules` should be `:dynamic`
+      process is a `GenEvent`, modules should be `:dynamic`
 
-  ### Restart values (:restart)
+  ### Restart values
 
-  The following restart values are supported in the `:restart` option:
+  The following restart values are supported:
 
     * `:permanent` - the child process is always restarted
 
@@ -73,31 +80,27 @@ defmodule Supervisor.Spec do
       when the supervisor's strategy is `:rest_for_one` or `:one_for_all`)
 
     * `:transient` - the child process is restarted only if it
-      terminates abnormally, i.e., with an exit reason other than
+      terminates abnormally, i.e. with another exit reason than
       `:normal`, `:shutdown` or `{:shutdown, term}`
 
-  ### Shutdown values (:shutdown)
+  ### Shutdown values
 
-  The following shutdown values are supported in the `:shutdown` option:
+  The following shutdown values are supported:
 
     * `:brutal_kill` - the child process is unconditionally terminated
-      using `exit(child, :kill)`
+      using `exit(child, :kill)`.
 
-    * `:infinity` - if the child process is a supervisor, this is a mechanism
-      to give the subtree enough time to shutdown; it can also be used with
-      workers with care
-
-    * any integer - the value of `:shutdown` can also be any integer meaning
-      that the supervisor tells the child process to terminate by calling
-      `Process.exit(child, :shutdown)` and then waits for an exit signal back.
-      If no exit signal is received within the specified time (the value of this
-      option, in milliseconds), the child process is unconditionally terminated
-      using `Process.exit(child, :kill)`
+    * `: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 `Process.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 `Process.exit(child, :kill)`.
   """
 
-  # TODO: Update and provide a digest of strategies once we include DynamicSupervisor.
-
   @typedoc "Supported strategies"
   @type strategy :: :simple_one_for_one | :one_for_one | :one_for_all | :rest_for_one
 
@@ -128,13 +131,11 @@ defmodule Supervisor.Spec do
   Receives a list of children (workers or supervisors) to
   supervise and a set of options.
 
-  Returns a tuple containing the supervisor specification. This tuple can be
-  used as the return value of the `init/1` callback when implementing a
-  module-based supervisor.
+  Returns a tuple containing the supervisor specification.
 
   ## Examples
 
-      supervise(children, strategy: :one_for_one)
+      supervise children, strategy: :one_for_one
 
   ## Options
 
@@ -144,20 +145,18 @@ defmodule Supervisor.Spec do
       in the `Supervisor` module docs.
 
     * `:max_restarts` - the maximum amount of restarts allowed in
-      a time frame. Defaults to `3`.
+      a time frame. Defaults to 3.
 
     * `:max_seconds` - the time frame in which `:max_restarts` applies.
-      Defaults to `5`.
+      Defaults to 5.
 
-  The `:strategy` option is required and by default a maximum of 3 restarts is
-  allowed within 5 seconds. Check the `Supervisor` module for a detailed
-  description of the available strategies.
+  The `:strategy` option is required and by default maximum 3 restarts
+  are allowed within 5 seconds. Please check the `Supervisor` module for
+  a complete description of the available strategies.
   """
   @spec supervise([spec], strategy: strategy,
                           max_restarts: non_neg_integer,
                           max_seconds: non_neg_integer) :: {:ok, tuple}
-  # TODO: Make it return a tuple of format {:ok, children, opts}
-  # TODO: Deprecate once the new tuple format has been established
   def supervise(children, options) do
     unless strategy = options[:strategy] do
       raise ArgumentError, "expected :strategy option to be given"
@@ -170,7 +169,7 @@ defmodule Supervisor.Spec do
     {:ok, {{strategy, maxR, maxS}, children}}
   end
 
-  defp assert_unique_ids([id | rest]) do
+  defp assert_unique_ids([id|rest]) do
     if id in rest do
       raise ArgumentError,
         "duplicated id #{inspect id} found in the supervisor specification, " <>
@@ -188,7 +187,7 @@ defmodule Supervisor.Spec do
   Defines the given `module` as a worker which will be started
   with the given arguments.
 
-      worker(ExUnit.Runner, [], restart: :permanent)
+      worker ExUnit.Runner, [], restart: :permanent
 
   By default, the function `start_link` is invoked on the given
   module. Overall, the default values for the options are:
@@ -199,8 +198,8 @@ defmodule Supervisor.Spec do
        shutdown: 5000,
        modules: [module]]
 
-  Check the documentation for the `Supervisor.Spec` module for more
-  information on the options.
+  Check `Supervisor.Spec` module docs for more information on
+  the options.
   """
   @spec worker(module, [term], [restart: restart, shutdown: shutdown,
                                 id: term, function: atom, modules: modules]) :: spec
@@ -212,7 +211,7 @@ defmodule Supervisor.Spec do
   Defines the given `module` as a supervisor which will be started
   with the given arguments.
 
-      supervisor(ExUnit.Runner, [], restart: :permanent)
+      supervisor ExUnit.Runner, [], restart: :permanent
 
   By default, the function `start_link` is invoked on the given
   module. Overall, the default values for the options are:
@@ -223,8 +222,8 @@ defmodule Supervisor.Spec do
        shutdown: :infinity,
        modules: [module]]
 
-  Check the documentation for the `Supervisor.Spec` module for more
-  information on the options.
+  Check `Supervisor.Spec` module docs for more information on
+  the options.
   """
   @spec supervisor(module, [term], [restart: restart, shutdown: shutdown,
                                     id: term, function: atom, modules: modules]) :: spec
@@ -233,7 +232,6 @@ defmodule Supervisor.Spec do
     child(:supervisor, module, args, options)
   end
 
-  # TODO: Do and expose proper child validation
   defp child(type, module, args, options) do
     id       = Keyword.get(options, :id, module)
     modules  = Keyword.get(options, :modules, modules(module))
@@ -245,7 +243,6 @@ defmodule Supervisor.Spec do
       restart, shutdown, type, modules}
   end
 
-  # TODO: Remove GenEvent when there is no more GenEvent v2.0
   defp modules(GenEvent), do: :dynamic
   defp modules(module),   do: [module]
 end

lib/elixir/lib/system.ex

@@ -1,143 +1,52 @@
 defmodule System do
   @moduledoc """
-  The `System` module provides functions that interact directly
+  The System module provides access to variables used or
+  maintained by the VM and to functions that interact directly
   with the VM or the host system.
-
-  ## Time
-
-  The `System` module also provides functions that work with time,
-  returning different times kept by the system with support for
-  different time units.
-
-  One of the complexities in relying on system times is that they
-  may be adjusted. For example, when you enter and leave daylight
-  saving time, the system clock will be adjusted, often adding
-  or removing one hour. We call such changes "time warps". In
-  order to understand how such changes may be harmful, imagine
-  the following code:
-
-      ## DO NOT DO THIS
-      prev = System.os_time()
-      # ... execute some code ...
-      next = System.os_time()
-      diff = next - prev
-
-  If, while the code is executing, the system clock changes,
-  some code that executed in 1 second may be reported as taking
-  over 1 hour! To address such concerns, the VM provides a
-  monotonic time via `System.monotonic_time/0` which never
-  decreases and does not leap:
-
-      ## DO THIS
-      prev = System.monotonic_time()
-      # ... execute some code ...
-      next = System.monotonic_time()
-      diff = next - prev
-
-  Generally speaking, the VM provides three time measurements:
-
-    * `os_time/0` - the time reported by the OS. This time may be
-      adjusted forwards or backwards in time with no limitation;
-
-    * `system_time/0` - the VM view of the `os_time/0`. The system time and OS
-      time may not match in case of time warps although the VM works towards
-      aligning them. This time is not monotonic (i.e., it may decrease)
-      as its behaviour is configured [by the VM time warp
-      mode](http://www.erlang.org/doc/apps/erts/time_correction.html#Time_Warp_Modes);
-
-    * `monotonic_time/0` - a monotonically increasing time provided
-      by the Erlang VM.
-
-  The time functions in this module work in the `:native` unit
-  (unless specified otherwise), which is OS dependent. Most of
-  the time, all calculations are done in the `:native` unit, to
-  avoid loss of precision, with `convert_time_unit/3` being
-  invoked at the end to convert to a specific time unit like
-  milliseconds or microseconds. See the `t:time_unit/0` type for
-  more information.
-
-  For a more complete rundown on the VM support for different
-  times, see the [chapter on time and time
-  correction](http://www.erlang.org/doc/apps/erts/time_correction.html)
-  in the Erlang docs.
   """
 
-  @typedoc """
-  The time unit to be passed to functions like `monotonic_time/1` and others.
-
-  The `:seconds`, `:milliseconds`, `:microseconds` and `:nanoseconds` time
-  units controls the return value of the functions that accept a time unit.
-
-  A time unit can also be a strictly positive integer. In this case, it
-  represents the "parts per second": the time will be returned in `1 /
-  parts_per_second` seconds. For example, using the `:milliseconds` time unit
-  is equivalent to using `1000` as the time unit (as the time will be returned
-  in 1/1000 seconds - milliseconds).
-
-  Keep in mind the Erlang API will use `:milli_seconds`, `:micro_seconds`
-  and `:nano_seconds` as time units although Elixir normalizes their spelling
-  to match the SI convention.
-  """
-  @type time_unit ::
-    :seconds
-    | :milliseconds
-    | :microseconds
-    | :nanoseconds
-    | pos_integer
-
-  @base_dir     :filename.join(__DIR__, "../../..")
-  @version_file :filename.join(@base_dir, "VERSION")
-
-  defp strip(iodata) do
-    :re.replace(iodata, "^[\s\r\n\t]+|[\s\r\n\t]+$", "", [:global, return: :binary])
+  defp strip_re(iodata, pattern) do
+    :re.replace(iodata, pattern, "", [return: :binary])
   end
 
   defp read_stripped(path) do
     case :file.read_file(path) do
       {:ok, binary} ->
-        strip(binary)
-      _ ->
-        ""
+        strip_re(binary, "^\s+|\s+$")
+      _ -> ""
     end
   end
 
-  # Read and strip the version from the VERSION file.
+  # Read and strip the version from the `VERSION` file.
   defmacrop get_version do
-    case read_stripped(@version_file) do
+    case read_stripped(:filename.join(__DIR__, "../../../VERSION")) do
       ""   -> raise RuntimeError, message: "could not read the version number from VERSION"
       data -> data
     end
   end
 
-  # Tries to run "git rev-parse --short HEAD". In the case of success returns
-  # the short revision hash. If that fails, returns an empty string.
-  defmacrop get_revision do
-    :os.cmd('git rev-parse --short HEAD 2> /dev/null')
-    |> strip
+  # 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 = :filename.join(__DIR__, "../../../.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
 
-  defp revision, do: get_revision
-
   # Get the date at compilation time.
   defmacrop get_date do
     IO.iodata_to_binary :httpd_util.rfc1123_date
   end
 
-  @doc """
-  Returns the endianness.
-  """
-  def endianness do
-    :erlang.system_info(:endian)
-  end
-
-  @doc """
-  Returns the endianness the system was compiled with.
-  """
-  @endianness :erlang.system_info(:endian)
-  def compiled_endianness do
-    @endianness
-  end
-
   @doc """
   Elixir version information.
 
@@ -149,47 +58,32 @@ defmodule System do
   @doc """
   Elixir build information.
 
-  Returns a keyword list with Elixir version, Git short revision hash and compilation date.
+  Returns a keyword list with Elixir version, git tag info and compilation date.
   """
   @spec build_info() :: map
   def build_info do
-    %{build:    build,
-      date:     get_date,
-      revision: revision,
-      version:  version}
-  end
-
-  # Returns a string of the build info
-  defp build do
-    {:ok, v} = Version.parse(version)
-
-    cond do
-      ([] == v.pre) or ("" == revision) ->
-        version
-      true ->
-        "#{version} (#{revision})"
-    end
+    %{version: version, tag: get_describe, date: get_date}
   end
 
   @doc """
-  Lists command line arguments.
+  List command line arguments.
 
   Returns the list of command line arguments passed to the program.
   """
   @spec argv() :: [String.t]
   def argv do
-    :elixir_config.get(:argv)
+    :elixir_code_server.call :argv
   end
 
   @doc """
-  Modifies command line arguments.
+  Modify command line arguments.
 
   Changes the list of command line arguments. Use it with caution,
   as it destroys any previous argv information.
   """
   @spec argv([String.t]) :: :ok
   def argv(args) do
-    :elixir_config.put(:argv, args)
+    :elixir_code_server.cast({:argv, args})
   end
 
   @doc """
@@ -228,9 +122,13 @@ defmodule System do
   User home directory.
 
   Returns the user home directory (platform independent).
+  Returns `nil` if no user home is set.
   """
   def user_home do
-    :elixir_config.get(:home)
+    case :os.type() do
+      {:win32, _} -> get_windows_home
+      _             -> get_unix_home
+    end
   end
 
   @doc """
@@ -244,6 +142,20 @@ defmodule System do
       raise RuntimeError, message: "could not find the user home, please set the HOME environment variable"
   end
 
+  defp get_unix_home do
+    get_env("HOME")
+  end
+
+  defp get_windows_home do
+    :filename.absname(
+      get_env("USERPROFILE") || (
+        hd = get_env("HOMEDRIVE")
+        hp = get_env("HOMEPATH")
+        hd && hp && hd <> hp
+      )
+    )
+  end
+
   @doc ~S"""
   Writable temporary directory.
 
@@ -312,7 +224,7 @@ defmodule System do
   The function must receive the exit status code as an argument.
   """
   def at_exit(fun) when is_function(fun, 1) do
-    :elixir_config.update :at_exit, &[fun | &1]
+    :elixir_code_server.cast {:at_exit, fun}
   end
 
   @doc """
@@ -326,7 +238,7 @@ defmodule System do
   """
   @spec find_executable(binary) :: binary | nil
   def find_executable(program) when is_binary(program) do
-    case :os.find_executable(String.to_charlist(program)) do
+    case :os.find_executable(String.to_char_list(program)) do
       false -> nil
       other -> List.to_string(other)
     end
@@ -338,7 +250,7 @@ defmodule System do
   Returns a list of all environment variables. Each variable is given as a
   `{name, value}` tuple where both `name` and `value` are strings.
   """
-  @spec get_env() :: %{optional(String.t) => String.t}
+  @spec get_env() :: %{String.t => String.t}
   def get_env do
     Enum.into(:os.getenv, %{}, fn var ->
       var = IO.chardata_to_string var
@@ -356,7 +268,7 @@ defmodule System do
   """
   @spec get_env(binary) :: binary | nil
   def get_env(varname) when is_binary(varname) do
-    case :os.getenv(String.to_charlist(varname)) do
+    case :os.getenv(String.to_char_list(varname)) do
       false -> nil
       other -> List.to_string(other)
     end
@@ -368,31 +280,31 @@ defmodule System do
   Returns the process identifier of the current Erlang emulator
   in the format most commonly used by the operating system environment.
 
-  For more information, see [`:os.getpid/0`](http://www.erlang.org/doc/man/os.html#getpid-0).
+  See http://www.erlang.org/doc/man/os.html#getpid-0 for more info.
   """
   @spec get_pid() :: binary
   def get_pid, do: IO.iodata_to_binary(:os.getpid)
 
   @doc """
-  Sets an environment variable value.
+  Set an environment variable value.
 
   Sets a new `value` for the environment variable `varname`.
   """
   @spec put_env(binary, binary) :: :ok
   def put_env(varname, value) when is_binary(varname) and is_binary(value) do
-   :os.putenv String.to_charlist(varname), String.to_charlist(value)
+   :os.putenv String.to_char_list(varname), String.to_char_list(value)
    :ok
   end
 
   @doc """
-  Sets multiple environment variables.
+  Set multiple environment variables.
 
   Sets a new value for each environment variable corresponding
   to each key in `dict`.
   """
-  @spec put_env(Enumerable.t) :: :ok
-  def put_env(enum) do
-    Enum.each enum, fn {key, val} -> put_env key, val end
+  @spec put_env(Dict.t) :: :ok
+  def put_env(dict) do
+    Enum.each dict, fn {key, val} -> put_env key, val end
   end
 
   @doc """
@@ -402,7 +314,7 @@ defmodule System do
   """
   @spec delete_env(String.t) :: :ok
   def delete_env(varname) do
-    :os.unsetenv(String.to_charlist(varname))
+    :os.unsetenv(String.to_char_list(varname))
     :ok
   end
 
@@ -420,7 +332,7 @@ defmodule System do
   end
 
   @doc """
-  Halts the Erlang runtime system.
+  Halt the Erlang runtime system.
 
   Halts the Erlang runtime system where the argument `status` must be a
   non-negative integer, the atom `:abort` or a binary.
@@ -431,13 +343,13 @@ defmodule System do
     * If `:abort`, the runtime system aborts producing a core dump, if that is
       enabled in the operating system.
 
-    * If a string, an Erlang crash dump is produced with status as slogan,
+    * If a string, 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 more information, see [`:erlang.halt/1`](http://www.erlang.org/doc/man/erlang.html#halt-1).
+  For more information, check: http://www.erlang.org/doc/man/erlang.html#halt-1
 
   ## Examples
 
@@ -455,37 +367,21 @@ defmodule System do
   end
 
   def halt(status) when is_binary(status) do
-    :erlang.halt(String.to_charlist(status))
+    :erlang.halt(String.to_char_list(status))
   end
 
-  @doc ~S"""
+  @doc """
   Executes the given `command` with `args`.
 
   `command` is expected to be an executable available in PATH
   unless an absolute path is given.
 
-  `args` must be a list of binaries which the executable will receive
-  as its arguments as is. This means that:
+  `args` must be a list of strings which are not expanded
+  in any way. For example, this means wildcard expansion will
+  not happen unless `Path.wildcard/2` is used. On Windows though,
+  wildcard expansion is up to the program.
 
-    * environment variables will not be interpolated
-    * wildcard expansion will not happen (unless `Path.wildcard/2` is used
-      explicitly)
-    * arguments do not need to be escaped or quoted for shell safety
-
-  This function returns a tuple containing the collected result
-  and the command exit status.
-
-  ## Examples
-
-      iex> System.cmd "echo", ["hello"]
-      {"hello\n", 0}
-
-      iex> System.cmd "echo", ["hello"], env: [{"MIX_ENV", "test"}]
-      {"hello\n", 0}
-
-      iex> System.cmd "echo", ["hello"], into: IO.stream(:stdio, :line)
-      hello
-      {%IO.Stream{}, 0}
+  A set of options are also supported and described below.
 
   ## Options
 
@@ -493,9 +389,9 @@ defmodule System do
     * `:cd` - the directory to run the command in
     * `:env` - an enumerable of tuples containing environment key-value as binary
     * `:arg0` - set the command arg0
-    * `:stderr_to_stdout` - redirects stderr to stdout when `true`
-    * `:parallelism` - when `true`, the VM will schedule port tasks to improve
-      parallelism in the system. If set to `false`, the VM will try to perform
+    * `:stderr_to_stdout` - redirects stderr to stdout when true
+    * `:parallelism` - when true, the VM will schedule port tasks to improve
+      parallelism in the system. If set to false, the VM will try to perform
       commands immediately, improving latency at the expense of parallelism.
       The default can be set on system startup by passing the "+spp" argument
       to `--erl`.
@@ -530,12 +426,12 @@ defmodule System do
 
   If you desire to execute a trusted command inside a shell, with pipes,
   redirecting and so on, please check
-  [`:os.cmd/1`](http://www.erlang.org/doc/man/os.html#cmd-1).
+  [Erlang's :os.cmd/1 function](http://www.erlang.org/doc/man/os.html#cmd-1).
   """
   @spec cmd(binary, [binary], Keyword.t) ::
         {Collectable.t, exit_status :: non_neg_integer}
   def cmd(command, args, opts \\ []) when is_binary(command) and is_list(args) do
-    cmd = String.to_charlist(command)
+    cmd = String.to_char_list(command)
 
     cmd =
       if Path.type(cmd) == :absolute do
@@ -546,16 +442,7 @@ defmodule System do
 
     {into, opts} = cmd_opts(opts, [:use_stdio, :exit_status, :binary, :hide, args: args], "")
     {initial, fun} = Collectable.into(into)
-    try do
-      do_cmd Port.open({:spawn_executable, cmd}, opts), initial, fun
-    catch
-      kind, reason ->
-        stacktrace = System.stacktrace
-        fun.(initial, :halt)
-        :erlang.raise(kind, reason, stacktrace)
-    else
-      {acc, status} -> {fun.(acc, :done), status}
-    end
+    do_cmd Port.open({:spawn_executable, cmd}, opts), initial, fun
   end
 
   defp do_cmd(port, acc, fun) do
@@ -563,32 +450,32 @@ defmodule System do
       {^port, {:data, data}} ->
         do_cmd(port, fun.(acc, {:cont, data}), fun)
       {^port, {:exit_status, status}} ->
-        {acc, status}
+        {fun.(acc, :done), status}
     end
   end
 
-  defp cmd_opts([{:into, any} | t], opts, _into),
+  defp cmd_opts([{:into, any}|t], opts, _into),
     do: cmd_opts(t, opts, any)
 
-  defp cmd_opts([{:cd, bin} | t], opts, into) when is_binary(bin),
-    do: cmd_opts(t, [{:cd, bin} | opts], into)
+  defp cmd_opts([{:cd, bin}|t], opts, into) when is_binary(bin),
+    do: cmd_opts(t, [{:cd, bin}|opts], into)
 
-  defp cmd_opts([{:arg0, bin} | t], opts, into) when is_binary(bin),
-    do: cmd_opts(t, [{:arg0, bin} | opts], into)
+  defp cmd_opts([{:arg0, bin}|t], opts, into) when is_binary(bin),
+    do: cmd_opts(t, [{:arg0, bin}|opts], into)
 
-  defp cmd_opts([{:stderr_to_stdout, true} | t], opts, into),
-    do: cmd_opts(t, [:stderr_to_stdout | opts], into)
+  defp cmd_opts([{:stderr_to_stdout, true}|t], opts, into),
+    do: cmd_opts(t, [:stderr_to_stdout|opts], into)
 
-  defp cmd_opts([{:stderr_to_stdout, false} | t], opts, into),
+  defp cmd_opts([{:stderr_to_stdout, false}|t], opts, into),
     do: cmd_opts(t, opts, into)
 
-  defp cmd_opts([{:parallelism, bool} | t], opts, into) when is_boolean(bool),
-    do: cmd_opts(t, [{:parallelism, bool} | opts], into)
+  defp cmd_opts([{:parallelism, bool}|t], opts, into) when is_boolean(bool),
+    do: cmd_opts(t, [{:parallelism, bool}|opts], into)
 
-  defp cmd_opts([{:env, enum} | t], opts, into),
-    do: cmd_opts(t, [{:env, validate_env(enum)} | opts], into)
+  defp cmd_opts([{:env, enum}|t], opts, into),
+    do: cmd_opts(t, [{:env, validate_env(enum)}|opts], into)
 
-  defp cmd_opts([{key, val} | _], _opts, _into),
+  defp cmd_opts([{key, val}|_], _opts, _into),
     do: raise(ArgumentError, "invalid option #{inspect key} with value #{inspect val}")
 
   defp cmd_opts([], opts, into),
@@ -596,213 +483,10 @@ defmodule System do
 
   defp validate_env(enum) do
     Enum.map enum, fn
-      {k, nil} ->
-        {String.to_charlist(k), false}
       {k, v} ->
-        {String.to_charlist(k), String.to_charlist(v)}
+        {String.to_char_list(k), String.to_char_list(v)}
       other ->
         raise ArgumentError, "invalid environment key-value #{inspect other}"
     end
   end
-
-  @doc """
-  Returns the current monotonic time in the `:native` time unit.
-
-  This time is monotonically increasing and starts in an unspecified
-  point in time.
-
-  Inlined by the compiler into `:erlang.monotonic_time/0`.
-  """
-  @spec monotonic_time() :: integer
-  def monotonic_time do
-    :erlang.monotonic_time()
-  end
-
-  @doc """
-  Returns the current monotonic time in the given time unit.
-
-  This time is monotonically increasing and starts in an unspecified
-  point in time.
-  """
-  @spec monotonic_time(time_unit) :: integer
-  def monotonic_time(unit) do
-    :erlang.monotonic_time(normalize_time_unit(unit))
-  end
-
-  @doc """
-  Returns the current system time in the `:native` time unit.
-
-  It is the VM view of the `os_time/0`. They may not match in
-  case of time warps although the VM works towards aligning
-  them. This time is not monotonic.
-
-  Inlined by the compiler into `:erlang.system_time/0`.
-  """
-  @spec system_time() :: integer
-  def system_time do
-    :erlang.system_time()
-  end
-
-  @doc """
-  Returns the current system time in the given time unit.
-
-  It is the VM view of the `os_time/0`. They may not match in
-  case of time warps although the VM works towards aligning
-  them. This time is not monotonic.
-  """
-  @spec system_time(time_unit) :: integer
-  def system_time(unit) do
-    :erlang.system_time(normalize_time_unit(unit))
-  end
-
-  @doc """
-  Converts `time` from time unit `from_unit` to time unit `to_unit`.
-
-  The result is rounded via the floor function.
-
-  `convert_time_unit/3` accepts an additional time unit (other than the
-  ones in the `time_unit` type) called `:native`. `:native` is the time
-  unit used by the Erlang runtime system. It's determined when the runtime
-  starts and stays the same until the runtime is stopped. To determine what
-  the `:native` unit amounts to in a system, you can call this function to
-  convert 1 second to the `:native` time unit (i.e.,
-  `System.convert_time_unit(1, :seconds, :native)`).
-  """
-  @spec convert_time_unit(integer, time_unit | :native, time_unit | :native) :: integer
-  def convert_time_unit(time, from_unit, to_unit) do
-    :erlang.convert_time_unit(time, normalize_time_unit(from_unit), normalize_time_unit(to_unit))
-  end
-
-  @doc """
-  Returns the current time offset between the Erlang VM monotonic
-  time and the Erlang VM system time.
-
-  The result is returned in the `:native` time unit.
-
-  See `time_offset/1` for more information.
-
-  Inlined by the compiler into `:erlang.time_offset/0`.
-  """
-  @spec time_offset() :: integer
-  def time_offset do
-    :erlang.time_offset()
-  end
-
-  @doc """
-  Returns the current time offset between the Erlang VM monotonic
-  time and the Erlang VM system time.
-
-  The result is returned in the given time unit `unit`. The returned
-  offset, added to an Erlang monotonic time (e.g., obtained with
-  `monotonic_time/1`), gives the Erlang system time that corresponds
-  to that monotonic time.
-  """
-  @spec time_offset(time_unit) :: integer
-  def time_offset(unit) do
-    :erlang.time_offset(normalize_time_unit(unit))
-  end
-
-  @doc """
-  Returns the current OS time.
-
-  The result is returned in the `:native` time unit.
-
-  This time may be adjusted forwards or backwards in time
-  with no limitation and is not monotonic.
-
-  Inlined by the compiler into `:os.system_time/0`.
-  """
-  @spec os_time() :: integer
-  def os_time do
-    :os.system_time()
-  end
-
-  @doc """
-  Returns the current OS time in the given time `unit`.
-
-  This time may be adjusted forwards or backwards in time
-  with no limitation and is not monotonic.
-  """
-  @spec os_time(time_unit) :: integer
-  def os_time(unit) do
-    :os.system_time(normalize_time_unit(unit))
-  end
-
-  @doc """
-  Returns the OTP release number.
-  """
-  @spec otp_release :: String.t
-  def otp_release do
-    :erlang.list_to_binary :erlang.system_info(:otp_release)
-  end
-
-  @doc """
-  Returns the number of schedulers in the VM.
-  """
-  @spec schedulers :: pos_integer
-  def schedulers do
-    :erlang.system_info(:schedulers)
-  end
-
-  @doc """
-  Returns the number of schedulers online in the VM.
-  """
-  @spec schedulers_online :: pos_integer
-  def schedulers_online do
-    :erlang.system_info(:schedulers_online)
-  end
-
-  @doc """
-  Generates and returns an integer that is unique in the current runtime
-  instance.
-
-  "Unique" means that this function, called with the same list of `modifiers`,
-  will never return the same integer more than once on the current runtime
-  instance.
-
-  If `modifiers` is `[]`, then a unique integer (that can be positive or negative) is returned.
-  Other modifiers can be passed to change the properties of the returned integer:
-
-    * `:positive` - the returned integer is guaranteed to be positive.
-    * `:monotonic` - the returned integer is monotonically increasing. This
-      means that, on the same runtime instance (but even on different
-      processes), integers returned using the `:monotonic` modifier will always
-      be strictly less than integers returned by successive calls with the
-      `:monotonic` modifier.
-
-  All modifiers listed above can be combined; repeated modifiers in `modifiers`
-  will be ignored.
-
-  Inlined by the compiler into `:erlang.unique_integer/1`.
-  """
-  @spec unique_integer([:positive | :monotonic]) :: integer
-  def unique_integer(modifiers \\ []) do
-    :erlang.unique_integer(modifiers)
-  end
-
-  defp normalize_time_unit(:native),
-    do: :native
-  defp normalize_time_unit(:seconds),
-    do: :seconds
-  defp normalize_time_unit(:milliseconds),
-    do: :milli_seconds
-  defp normalize_time_unit(:microseconds),
-    do: :micro_seconds
-  defp normalize_time_unit(:nanoseconds),
-    do: :nano_seconds
-  defp normalize_time_unit(unit) when is_integer(unit) and unit > 0,
-    do: unit
-
-  # TODO: Warn on Elixir 1.5
-  defp normalize_time_unit(erlang_unit)
-      when erlang_unit in [:milli_seconds, :micro_seconds, :nano_seconds] do
-    erlang_unit
-  end
-
-  defp normalize_time_unit(other) do
-    raise ArgumentError,
-      "unsupported time unit. Expected :seconds, :milliseconds, " <>
-      ":microseconds, :nanoseconds, or a positive integer, " <>
-      "got #{inspect other}"
-  end
 end

lib/elixir/lib/task.ex

@@ -1,62 +1,40 @@
 defmodule Task do
   @moduledoc """
-  Conveniences for spawning and awaiting tasks.
+  Conveniences for spawning and awaiting for tasks.
 
   Tasks are processes meant to execute one particular
-  action throughout their lifetime, often with little or no
+  action throughout their life-cycle, often with little or no
   communication with other processes. The most common use case
-  for tasks is to convert sequential code into concurrent code
-  by computing a value asynchronously:
+  for tasks is to compute a value asynchronously:
 
       task = Task.async(fn -> do_some_work() end)
       res  = do_some_other_work()
       res + Task.await(task)
 
-  Tasks spawned with `async` can be awaited on by their caller
-  process (and only their caller) as shown in the example above.
+  Tasks spawned with `async` can be awaited on by its caller
+  process (and only its caller) as shown in the example above.
   They are implemented by spawning a process that sends a message
   to the caller once the given computation is performed.
 
   Besides `async/1` and `await/2`, tasks can also be
-  started as part of a supervision tree and dynamically spawned
-  on remote nodes. We will explore all three scenarios next.
+  started as part of supervision trees and dynamically spawned
+  in remote nodes. We will explore all three scenarios next.
 
   ## async and await
 
-  One of the common uses of tasks is to convert sequential code
-  into concurrent code with `Task.async/1` while keeping its semantics.
-  When invoked, a new process will be created, linked and monitored
-  by the caller. Once the task action finishes, a message will be sent
-  to the caller with the result.
+  The most common way to spawn a task is with `Task.async/1`. A new
+  process will be created, linked and monitored by the caller. Once
+  the task action finishes, a message will be sent to the caller
+  with the result.
 
-  `Task.await/2` is used to read the message sent by the task.
-
-  There are two important things to consider when using `async`:
-
-    1. If you are using async tasks, you must await a reply
-       as they are *always* sent. If you are not expecting a reply,
-       consider using `Task.start_link/1` detailed below.
-
-    2. async tasks link the caller and the spawned process. This
-       means that, if the caller crashes, the task will crash
-       too and vice-versa. This is on purpose: if the process
-       meant to receive the result no longer exists, there is
-       no purpose in completing the computation.
-
-       If this is not desired, use `Task.start/1` or consider starting
-       the task under a `Task.Supervisor` using `async_nolink` or
-       `start_child`.
-
-  `Task.yield/2` is an alternative to `await/2` where the caller will
-  temporarily block, waiting until the task replies or crashes. If the
-  result does not arrive within the timeout, it can be called again at a
-  later moment. This allows checking for the result of a task multiple
-  times. If a reply does not arrive within the desired time,
-  `Task.shutdown/2` can be used to stop the task.
+  `Task.await/2` is used to read the message sent by the task. On
+  `await`, Elixir will also setup a monitor to verify if the process
+  exited for any abnormal reason (or in case exits are being
+  trapped by the caller).
 
   ## Supervised tasks
 
-  It is also possible to spawn a task under a supervisor
+  It is also possible to spawn a task inside a supervision tree
   with `start_link/1` and `start_link/3`:
 
       Task.start_link(fn -> IO.puts "ok" end)
@@ -74,81 +52,54 @@ defmodule Task do
   unlike `async/1`, returns `{:ok, pid}` (which is
   the result expected by supervision trees).
 
-  By default, most supervision strategies will try to restart
-  a worker after it exits regardless of the reason. If you design the
-  task to terminate normally (as in the example with `IO.puts/2` above),
-  consider passing `restart: :transient` in the options to `worker/3`.
+  ## Supervision trees
 
-  ## Dynamically supervised tasks
-
-  The `Task.Supervisor` module allows developers to dynamically
-  create multiple supervised tasks.
-
-  A short example is:
+  The `Task.Supervisor` module allows developers to start supervisors
+  that dynamically supervise tasks:
 
       {:ok, pid} = Task.Supervisor.start_link()
-      task = Task.Supervisor.async(pid, fn ->
-        # Do something
-      end)
-      Task.await(task)
+      Task.Supervisor.async(pid, MyMod, :my_fun, [arg1, arg2, arg3])
 
-  However, in the majority of cases, you want to add the task supervisor
-  to your supervision tree:
+  `Task.Supervisor` also makes it possible to spawn tasks in remote nodes as
+  long as the supervisor is registered locally or globally:
+
+      # In the remote node
+      Task.Supervisor.start_link(name: :tasks_sup)
+
+      # In the client
+      Task.Supervisor.async({:tasks_sup, :remote@local}, MyMod, :my_fun, [arg1, arg2, arg3])
+
+  `Task.Supervisor` is more often started in your supervision tree as:
 
       import Supervisor.Spec
 
       children = [
-        supervisor(Task.Supervisor, [[name: MyApp.TaskSupervisor]])
+        supervisor(Task.Supervisor, [[name: :tasks_sup]])
       ]
 
-  Now you can dynamically start supervised tasks:
-
-      Task.Supervisor.start_child(MyApp.TaskSupervisor, fn ->
-        # Do something
-      end)
-
-  Or even use the async/await pattern:
-
-      Task.Supervisor.async(MyApp.TaskSupervisor, fn ->
-        # Do something
-      end) |> Task.await()
-
-  Finally, check `Task.Supervisor` for other supported operations.
-
-  ## Distributed tasks
-
-  Since Elixir provides a Task supervisor, it is easy to use one
-  to dynamically spawn tasks across nodes:
-
-      # On the remote node
-      Task.Supervisor.start_link(name: MyApp.DistSupervisor)
-
-      # On the client
-      Task.Supervisor.async({MyApp.DistSupervisor, :remote@local},
-                            MyMod, :my_fun, [arg1, arg2, arg3])
-
-  Note that, when working with distributed tasks, one should use the `async/4` function
-  that expects explicit module, function and arguments, instead of `async/2` that
-  works with anonymous functions. That's because anonymous functions expect
+  Note that, when working with distributed tasks, one should use the `async/3` API,
+  that expects explicit module, function and arguments, instead of `async/1` that
+  works with anonymous functions. That's because the anonymous function API expects
   the same module version to exist on all involved nodes. Check the `Agent` module
-  documentation for more information on distributed processes as the limitations
-  described there apply to the whole ecosystem.
+  documentation for more information on distributed processes, as the limitations
+  described in the agents documentation apply to the whole ecosystem.
+
+  Finally, check `Task.Supervisor` for other operations supported by the Task
+  supervisor.
   """
 
   @doc """
   The Task struct.
 
-  It contains these fields:
+  It contains two fields:
 
-    * `:pid` - the PID of the task process; `nil` if the task does
-      not use a task process
+    * `:pid` - the process reference of the task process; it may be a pid
+      or a tuple containing the process and node names
 
     * `:ref` - the task monitor reference
 
-    * `:owner` - the PID of the process that started the task
-
   """
-  defstruct pid: nil, ref: nil, owner: nil
+  defstruct pid: nil, ref: nil
 
   @type t :: %__MODULE__{}
 
@@ -172,7 +123,7 @@ defmodule Task do
   Starts a task.
 
   This is only used when the task is used for side-effects
-  (i.e. no interest in the returned result) and it should not
+  (i.e. no interest in its return result) and it should not
   be linked to the current process.
   """
   @spec start(fun) :: {:ok, pid}
@@ -184,7 +135,7 @@ defmodule Task do
   Starts a task.
 
   This is only used when the task is used for side-effects
-  (i.e. no interest in the returned result) and it should not
+  (i.e. no interest in its return result) and it should not
   be linked to the current process.
   """
   @spec start(module, atom, [term]) :: {:ok, pid}
@@ -193,16 +144,16 @@ defmodule Task do
   end
 
   @doc """
-  Starts a task that must be awaited on.
+  Starts a task that can be awaited on.
 
   This function spawns a process that is linked to and monitored
   by the caller process. A `Task` struct is returned containing
   the relevant information.
 
-  Read the `Task` module documentation for more info on general
-  usage of `async/1` and `async/3`.
+  ## Task's message format
 
-  See also `async/3`.
+  The reply sent by the task will be in the format `{ref, msg}`,
+  where `ref` is the monitoring reference held by the task.
   """
   @spec async(fun) :: t
   def async(fun) do
@@ -210,76 +161,18 @@ defmodule Task do
   end
 
   @doc """
-  Starts a task that must be awaited on.
+  Starts a task that can be awaited on.
 
-  A `Task` struct is returned containing the relevant information.
-  Developers must eventually call `Task.await/2` or `Task.yield/2`
-  followed by `Task.shutdown/2` on the returned task.
-
-  Read the `Task` module documentation for more info on general
-  usage of `async/1` and `async/3`.
-
-  ## Linking
-
-  This function spawns a process that is linked to and monitored
-  by the caller process. The linking part is important because it
-  aborts the task if the parent process dies. It also guarantees
-  the code before async/await has the same properties after you
-  add the async call. For example, imagine you have this:
-
-      x = heavy_fun()
-      y = some_fun()
-      x + y
-
-  Now you want to make the `heavy_fun()` async:
-
-      x = Task.async(&heavy_fun/0)
-      y = some_fun()
-      Task.await(x) + y
-
-  As before, if `heavy_fun/0` fails, the whole computation will
-  fail, including the parent process. If you don't want the task
-  to fail then you must change the `heavy_fun/0` code in the
-  same way you would achieve it if you didn't have the async call.
-  For example, to either return `{:ok, val} | :error` results or,
-  in more extreme cases, by using `try/rescue`. In other words,
-  an asynchronous task should be thought of as an extension of a
-  process rather than a mechanism to isolate it from all errors.
-
-  If you don't want to link the caller to the task, then you
-  must use a supervised task with `Task.Supervisor` and call
-  `Task.Supervisor.async_nolink/2`.
-
-  In any case, avoid any of the following:
-
-    * Setting `:trap_exit` to `true` - trapping exits should be
-      used only in special circumstances as it would make your
-      process immune to not only exits from the task but from
-      any other processes.
-
-      Moreover, even when trapping exists, calling `await` will
-      still exit if the task has terminated without sending its
-      result back.
-
-    * Unlinking the task process started with `async`/`await`.
-      If you unlink the processes and the task does not belong
-      to any supervisor, you may leave dangling tasks in case
-      the parent dies.
-
-  ## Message format
-
-  The reply sent by the task will be in the format `{ref, result}`,
-  where `ref` is the monitor reference held by the task struct
-  and `result` is the return value of the task function.
+  Similar to `async/1`, but the task is specified by the given
+  module, function and arguments.
   """
   @spec async(module, atom, [term]) :: t
   def async(mod, fun, args) do
     mfa = {mod, fun, args}
-    owner = self()
-    pid = Task.Supervised.spawn_link(owner, get_info(owner), mfa)
+    pid = :proc_lib.spawn_link(Task.Supervised, :async, [self, get_info(self), mfa])
     ref = Process.monitor(pid)
-    send(pid, {owner, ref})
-    %Task{pid: pid, ref: ref, owner: owner}
+    send(pid, {self(), ref})
+    %Task{pid: pid, ref: ref}
   end
 
   defp get_info(self) do
@@ -296,40 +189,18 @@ defmodule Task do
   A timeout, in milliseconds, can be given with default value
   of `5000`. In case the task process dies, this function will
   exit with the same reason as the task.
-
-  If the timeout is exceeded, `await` will exit; however,
-  the task will continue to run. When the calling process exits, its
-  exit signal will terminate the task if it is not trapping exits.
-
-  This function assumes the task's monitor is still active or the monitor's
-  `:DOWN` message is in the message queue. If it has been demonitored, or the
-  message already received, this function will wait for the duration of the
-  timeout awaiting the message.
-
-  This function can only be called once for any given task. If you want
-  to be able to check multiple times if a long-running task has finished
-  its computation, use `yield/2` instead.
-
-  ## Compatibility with OTP behaviours
-
-  It is not recommended to `await` a long-running task inside an OTP
-  behaviour such as `GenServer`. Instead, you should match on the message
-  coming from a task inside your `handle_info` callback.
   """
   @spec await(t, timeout) :: term | no_return
-  def await(task, timeout \\ 5000)
-
-  def await(%Task{owner: owner} = task, _) when owner != self() do
-    raise ArgumentError, invalid_owner_error(task)
-  end
-
-  def await(%Task{ref: ref} = task, timeout) do
+  def await(%Task{ref: ref}=task, timeout \\ 5000) do
     receive do
       {^ref, reply} ->
         Process.demonitor(ref, [:flush])
         reply
-      {:DOWN, ^ref, _, proc, reason} ->
-        exit({reason(reason, proc), {__MODULE__, :await, [task, timeout]}})
+      {:DOWN, ^ref, _, _, :noconnection} ->
+        mfa = {__MODULE__, :await, [task, timeout]}
+        exit({{:nodedown, node(task.pid)}, mfa})
+      {:DOWN, ^ref, _, _, reason} ->
+        exit({reason, {__MODULE__, :await, [task, timeout]}})
     after
       timeout ->
         Process.demonitor(ref, [:flush])
@@ -337,290 +208,47 @@ defmodule Task do
     end
   end
 
-  @doc false
-  # TODO: Remove on 2.0
-  def find(tasks, msg) do
-    IO.warn "Task.find/2 is deprecated, please match on the message directly"
-    do_find(tasks, msg)
-  end
+  @doc """
+  Receives a group of tasks and a message and finds
+  a task that matches the given message.
 
-  defp do_find(tasks, {ref, reply}) when is_reference(ref) do
+  This function returns a tuple with the task and the
+  returned value in case the message matches a task that
+  exited with success, it raises in case the found task
+  failed or `nil` if no task was found.
+
+  This function is useful in situations where multiple
+  tasks are spawned and their results are collected
+  later on. For example, a `GenServer` can spawn tasks,
+  store the tasks in a list and later use `Task.find/2`
+  to see if incoming messages are from any of the tasks.
+  """
+  @spec find([t], any) :: {term, t} | nil | no_return
+  def find(tasks, msg)
+
+  def find(tasks, {ref, reply}) when is_reference(ref) do
     Enum.find_value tasks, fn
-      %Task{ref: ^ref} = task ->
+      %Task{ref: task_ref} = t when ref == task_ref ->
         Process.demonitor(ref, [:flush])
-        {reply, task}
+        {reply, t}
       %Task{} ->
         nil
     end
   end
 
-  defp do_find(tasks, {:DOWN, ref, _, proc, reason} = msg) when is_reference(ref) do
-    find = fn %Task{ref: task_ref} -> task_ref == ref end
-    if Enum.find(tasks, find) do
-      exit({reason(reason, proc), {__MODULE__, :find, [tasks, msg]}})
-    end
-  end
-
-  defp do_find(_tasks, _msg) do
-    nil
-  end
-
-  @doc """
-  Temporarily blocks the current process waiting for a task reply.
-
-  Returns `{:ok, reply}` if the reply is received, `nil` if
-  no reply has arrived, or `{:exit, reason}` if the task has already
-  exited. Keep in mind that normally a task failure also causes
-  the process owning the task to exit. Therefore this function can
-  return `{:exit, reason}` only if
-
-    * the task process exited with the reason `:normal`
-    * it isn't linked to the caller
-    * the caller is trapping exits
-
-  A timeout, in milliseconds, can be given with default value
-  of `5000`. If the time runs out before a message from
-  the task is received, this function will return `nil`
-  and the monitor will remain active. Therefore `yield/2` can be
-  called multiple times on the same task.
-
-  This function assumes the task's monitor is still active or the
-  monitor's `:DOWN` message is in the message queue. If it has been
-  demonitored or the message already received, this function will wait
-  for the duration of the timeout awaiting the message.
-  """
-  @spec yield(t, timeout) :: {:ok, term} | {:exit, term} | nil
-  def yield(task, timeout \\ 5_000)
-
-  def yield(%Task{owner: owner} = task, _) when owner != self() do
-    raise ArgumentError, invalid_owner_error(task)
-  end
-
-  def yield(%Task{ref: ref} = task, timeout) do
-    receive do
-      {^ref, reply} ->
-        Process.demonitor(ref, [:flush])
-        {:ok, reply}
-      {:DOWN, ^ref, _, proc, :noconnection} ->
-        exit({reason(:noconnection, proc), {__MODULE__, :yield, [task, timeout]}})
-      {:DOWN, ^ref, _, _, reason} ->
-        {:exit, reason}
-    after
-      timeout ->
+  def find(tasks, {:DOWN, ref, _, _, reason} = msg) when is_reference(ref) do
+    find = fn(%Task{ref: task_ref}) -> task_ref == ref end
+    case Enum.find(tasks, find) do
+      %Task{pid: pid} when reason == :noconnection ->
+        exit({{:nodedown, node(pid)}, {__MODULE__, :find, [tasks, msg]}})
+      %Task{} ->
+        exit({reason, {__MODULE__, :find, [tasks, msg]}})
+      nil ->
         nil
     end
   end
 
-  @doc """
-  Yields to multiple tasks in the given time interval.
-
-  This function receives a list of tasks and waits for their
-  replies in the given time interval. It returns a list
-  of tuples of two elements, with the task as the first element
-  and the yielded result as the second.
-
-  Similarly to `yield/2`, each task's result will be
-
-    * `{:ok, term}` if the task has successfully reported its
-      result back in the given time interval
-    * `{:exit, reason}` if the task has died
-    * `nil` if the task keeps running past the timeout
-
-  Check `yield/2` for more information.
-
-  ## Example
-
-  `Task.yield_many/2` allows developers to spawn multiple tasks
-  and retrieve the results received in a given timeframe.
-  If we combine it with `Task.shutdown/2`, it allows us to gather
-  those results and cancel the tasks that have not replied in time.
-
-  Let's see an example.
-
-      tasks =
-        for i <- 1..10 do
-          Task.async(fn ->
-            :timer.sleep(i * 1000)
-            i
-          end)
-        end
-
-      tasks_with_results = Task.yield_many(tasks, 5000)
-
-      results = Enum.map(tasks_with_results, fn {task, res} ->
-        # Shutdown the tasks that did not reply nor exit
-        res || Task.shutdown(task, :brutal_kill)
-      end)
-
-      # Here we are matching only on {:ok, value} and
-      # ignoring {:exit, _} (crashed tasks) and `nil` (no replies)
-      for {:ok, value} <- results do
-        IO.inspect value
-      end
-
-  In the example above, we create tasks that sleep from 1
-  up to 10 seconds and return the amount of seconds they slept.
-  If you execute the code all at once, you should see 1 up to 5
-  printed, as those were the tasks that have replied in the
-  given time. All other tasks will have been shut down using
-  the `Task.shutdown/2` call.
-  """
-  @spec yield_many([t], timeout) :: [{t, {:ok, term} | {:exit, term} | nil}]
-  def yield_many(tasks, timeout \\ 5000) do
-    timeout_ref = make_ref()
-    timer_ref = Process.send_after(self(), timeout_ref, timeout)
-    try do
-      yield_many(tasks, timeout_ref, :infinity)
-    catch
-      {:noconnection, reason} ->
-        exit({reason, {__MODULE__, :yield_many, [tasks, timeout]}})
-    after
-      Process.cancel_timer(timer_ref)
-      receive do: (^timeout_ref -> :ok), after: (0 -> :ok)
-    end
-  end
-
-  defp yield_many([%Task{ref: ref, owner: owner}=task | rest], timeout_ref, timeout) do
-    if owner != self() do
-      raise ArgumentError, invalid_owner_error(task)
-    end
-
-    receive do
-      {^ref, reply} ->
-        Process.demonitor(ref, [:flush])
-        [{task, {:ok, reply}} | yield_many(rest, timeout_ref, timeout)]
-
-      {:DOWN, ^ref, _, proc, :noconnection} ->
-        throw({:noconnection, reason(:noconnection, proc)})
-
-      {:DOWN, ^ref, _, _, reason} ->
-        [{task, {:exit, reason}} | yield_many(rest, timeout_ref, timeout)]
-
-      ^timeout_ref ->
-        [{task, nil} | yield_many(rest, timeout_ref, 0)]
-
-    after
-      timeout ->
-        [{task, nil} | yield_many(rest, timeout_ref, 0)]
-
-    end
-  end
-
-  defp yield_many([], _timeout_ref, _timeout) do
-    []
-  end
-
-  @doc """
-  Unlinks and shuts down the task, and then checks for a reply.
-
-  Returns `{:ok, reply}` if the reply is received while shutting down the task,
-  `{:exit, reason}` if the task died, otherwise `nil`.
-
-  The shutdown method is either a timeout or `:brutal_kill`. In case
-  of a `timeout`, a `:shutdown` exit signal is sent to the task process
-  and if it does not exit within the timeout, it is killed. With `:brutal_kill`
-  the task is killed straight away. In case the task terminates abnormally
-  (possibly killed by another process), this function will exit with the same reason.
-
-  It is not required to call this function when terminating the caller, unless
-  exiting with reason `:normal` or if the task is trapping exits. If the caller is
-  exiting with a reason other than `:normal` and the task is not trapping exits, the
-  caller's exit signal will stop the task. The caller can exit with reason
-  `:shutdown` to shutdown all of its linked processes, including tasks, that
-  are not trapping exits without generating any log messages.
-
-  This function assumes the task's monitor is still active or the monitor's
-  `:DOWN` message is in the message queue. If it has been demonitored, or the
-  message already received, this function will block forever awaiting the message.
-  """
-  @spec shutdown(t, timeout | :brutal_kill) :: {:ok, term} | {:exit, term} | nil
-  def shutdown(task, shutdown \\ 5_000)
-
-  def shutdown(%Task{pid: nil} = task, _) do
-    raise ArgumentError, "task #{inspect task} does not have an associated task process"
-  end
-
-  def shutdown(%Task{owner: owner} = task, _) when owner != self() do
-    raise ArgumentError, invalid_owner_error(task)
-  end
-
-  def shutdown(%Task{pid: pid} = task, :brutal_kill) do
-    exit(pid, :kill)
-
-    case shutdown_receive(task, :brutal_kill, :infinity) do
-      {:down, proc, :noconnection} ->
-        exit({reason(:noconnection, proc), {__MODULE__, :shutdown, [task, :brutal_kill]}})
-      {:down, _, reason} ->
-        {:exit, reason}
-      result ->
-        result
-    end
-  end
-
-  def shutdown(%Task{pid: pid} = task, timeout) do
-    exit(pid, :shutdown)
-    case shutdown_receive(task, :shutdown, timeout) do
-      {:down, proc, :noconnection} ->
-        exit({reason(:noconnection, proc), {__MODULE__, :shutdown, [task, timeout]}})
-      {:down, _, reason} ->
-        {:exit, reason}
-      result ->
-        result
-    end
-  end
-
-  ## Helpers
-
-  defp reason(:noconnection, proc), do: {:nodedown, monitor_node(proc)}
-  defp reason(reason, _),           do: reason
-
-  defp monitor_node(pid) when is_pid(pid), do: node(pid)
-  defp monitor_node({_, node}),            do: node
-
-  # spawn a process to ensure task gets exit signal if process dies from exit signal
-  # between unlink and exit.
-  defp exit(task, reason) do
-    caller = self()
-    ref = make_ref()
-    enforcer = spawn(fn() -> enforce_exit(task, reason, caller, ref) end)
-    Process.unlink(task)
-    Process.exit(task, reason)
-    send(enforcer, {:done, ref})
-    :ok
-  end
-
-  defp enforce_exit(pid, reason, caller, ref) do
-    mon = Process.monitor(caller)
-    receive do
-      {:done, ^ref}          -> :ok
-      {:DOWN, ^mon, _, _, _} -> Process.exit(pid, reason)
-    end
-  end
-
-  defp shutdown_receive(%{ref: ref} = task, type, timeout) do
-    receive do
-      {:DOWN, ^ref, _, _, :shutdown} when type in [:shutdown, :timeout_kill] ->
-        flush_reply(ref)
-      {:DOWN, ^ref, _, _, :killed} when type == :brutal_kill ->
-        flush_reply(ref)
-      {:DOWN, ^ref, _, proc, reason} ->
-        flush_reply(ref) || {:down, proc, reason}
-    after
-      timeout ->
-        Process.exit(task.pid, :kill)
-        shutdown_receive(task, :timeout_kill, :infinity)
-    end
-  end
-
-  defp flush_reply(ref) do
-    receive do
-      {^ref, reply} -> {:ok, reply}
-    after
-      0 -> nil
-    end
-  end
-
-  defp invalid_owner_error(task) do
-    "task #{inspect task} must be queried from the owner but was queried from #{inspect self()}"
+  def find(_tasks, _msg) do
+    nil
   end
 end