change some doc examples to iex style

Author: Igor Kapkov

lib/eex/lib/eex.ex

@@ -5,8 +5,8 @@ defmodule EEx do
   EEx stands for Embedded Elixir. It allows you to embed
   Elixir code inside a string in a robust way:
 
-      EEx.eval_string "foo <%= bar %>", [bar: "baz"]
-      #=> "foo baz"
+      iex> EEx.eval_string "foo <%= bar %>", [bar: "baz"]
+      "foo baz"
 
   ## API
 
@@ -31,7 +31,7 @@ defmodule EEx do
 
   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.
@@ -79,8 +79,8 @@ defmodule EEx do
   An example is the `@` macro which allows easy data access
   in a template:
 
-      EEx.eval_string "<%= @foo %>", assigns: [foo: 1]
-      #=> 1
+      iex> EEx.eval_string "<%= @foo %>", assigns: [foo: 1]
+      "1"
 
   In other words, <%= @foo %> is simply translated to:
 
@@ -97,12 +97,12 @@ defmodule EEx do
 
   ## Examples
 
-      defmodule Sample do
-        require EEx
-        EEx.function_from_string :def, :sample, "<%= a + b %>", [:a, :b]
-      end
-
-      Sample.sample(1, 2) #=> "3"
+      iex> defmodule Sample do
+      ...>   require EEx
+      ...>   EEx.function_from_string :def, :sample, "<%= a + b %>", [:a, :b]
+      ...> end
+      iex> Sample.sample(1, 2)
+      "3"
 
   """
   defmacro function_from_string(kind, name, source, args \\ [], options \\ []) do
@@ -177,8 +177,8 @@ defmodule EEx do
 
   ## Examples
 
-      EEx.eval_string "foo <%= bar %>", [bar: "baz"]
-      #=> "foo baz"
+      iex> EEx.eval_string "foo <%= bar %>", [bar: "baz"]
+      "foo baz"
 
   """
   def eval_string(source, bindings \\ [], options \\ []) do
@@ -195,8 +195,7 @@ defmodule EEx do
       foo <%= bar %>
 
       # iex
-      EEx.eval_file "sample.ex", [bar: "baz"]
-      #=> "foo baz"
+      EEx.eval_file "sample.ex", [bar: "baz"] #=> "foo baz"
 
   """
   def eval_file(filename, bindings \\ [], options \\ []) do

lib/eex/lib/eex/smart_engine.ex

@@ -63,8 +63,8 @@ defmodule EEx.AssignsEngine do
         use EEx.AssignsEngine
       end
 
-      EEx.eval_string("<%= @foo %>", assigns: [foo: 1])
-      #=> 1
+      iex> EEx.eval_string("<%= @foo %>", assigns: [foo: 1])
+      "1"
 
   In the example above, we can access the value `foo` under
   the binding `assigns` using `@foo`. This is useful when

lib/eex/test/eex_test.exs

@@ -45,6 +45,9 @@ end
 defmodule EExTest do
   use ExUnit.Case, async: true
 
+  doctest EEx
+  doctest EEx.AssignsEngine
+
   test "evaluates simple string" do
     assert_eval "foo bar", "foo bar"
   end

lib/elixir/lib/access.ex

@@ -11,15 +11,15 @@ defprotocol Access do
   and dictionary like types:
 
       iex> keywords = [a: 1, b: 2]
-      ...> keywords[:a]
+      iex> keywords[:a]
       1
 
       iex> map = %{ a: 1, b: 2 }
-      ...> map[:a]
+      iex> map[:a]
       1
 
       iex> star_ratings = %{ 1.0 => "★", 1.5 => "★☆", 2.0 => "★★" }
-      ...> star_ratings[1.5]
+      iex> star_ratings[1.5]
       "★☆"
 
   The key access must be implemented using the `===` operator.

lib/elixir/lib/bitwise.ex

@@ -15,7 +15,7 @@ defmodule Bitwise do
   You can select to include only or skip operators by passing options:
 
       iex> use Bitwise, only_operators: true
-      ...> 1 &&& 1
+      iex> 1 &&& 1
       1
 
   """

lib/elixir/lib/code.ex

@@ -136,14 +136,14 @@ defmodule Code do
   ## Examples
 
       iex> contents = quote(hygiene: [vars: false], do: a + b)
-      ...> Code.eval_quoted(contents, [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
+      iex> Code.eval_quoted(contents, [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
       {3, [a: 1, b: 2]}
 
   For convenience, you can pass `__ENV__` as the `opts` argument and
   all options will be automatically extracted from the current environment:
 
       iex> contents = quote(hygiene: [vars: false], do: a + b)
-      ...> Code.eval_quoted(contents, [a: 1, b: 2], __ENV__)
+      iex> Code.eval_quoted(contents, [a: 1, b: 2], __ENV__)
       {3, [a: 1, b: 2]}
 
   """

lib/elixir/lib/dict.ex

@@ -21,8 +21,8 @@ defmodule Dict do
   protocol:
 
       iex> dict = dict_impl.new
-      ...> dict = Dict.put(dict, :hello, :world)
-      ...> dict[:hello]
+      iex> dict = Dict.put(dict, :hello, :world)
+      iex> dict[:hello]
       :world
 
   As well as the `Enumerable` and `Collectable` protocols.
@@ -88,7 +88,7 @@ defmodule Dict do
   ## Examples
 
       iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> Enum.sort(Dict.keys(d))
+      iex> Enum.sort(Dict.keys(d))
       [:a,:b]
 
   """
@@ -104,7 +104,7 @@ defmodule Dict do
   ## Examples
 
       iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> Enum.sort(Dict.values(d))
+      iex> Enum.sort(Dict.values(d))
       [1,2]
 
   """
@@ -119,7 +119,7 @@ defmodule Dict do
   ## Examples
 
       iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> Dict.size(d)
+      iex> Dict.size(d)
       2
 
   """
@@ -205,8 +205,8 @@ defmodule Dict do
   ## Examples
 
       iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> d = Dict.put(d, :a, 3)
-      ...> Dict.get(d, :a)
+      iex> d = Dict.put(d, :a, 3)
+      iex> Dict.get(d, :a)
       3
 
   """
@@ -221,8 +221,8 @@ defmodule Dict do
   ## Examples
 
       iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> d = Dict.put_new(d, :a, 3)
-      ...> Dict.get(d, :a)
+      iex> d = Dict.put_new(d, :a, 3)
+      iex> Dict.get(d, :a)
       1
 
   """
@@ -238,12 +238,12 @@ defmodule Dict do
   ## Examples
 
       iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> d = Dict.delete(d, :a)
-      ...> Dict.get(d, :a)
+      iex> d = Dict.delete(d, :a)
+      iex> Dict.get(d, :a)
       nil
 
       iex> d = Enum.into([b: 2], dict_impl.new)
-      ...> Dict.delete(d, :a) == d
+      iex> Dict.delete(d, :a) == d
       true
 
   """
@@ -266,17 +266,17 @@ defmodule Dict do
   ## Examples
 
       iex> d1 = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> d2 = Enum.into([a: 3, d: 4], dict_impl.new)
-      ...> d = Dict.merge(d1, d2)
-      ...> [a: Dict.get(d, :a), b: Dict.get(d, :b), d: Dict.get(d, :d)]
+      iex> d2 = Enum.into([a: 3, d: 4], dict_impl.new)
+      iex> d = Dict.merge(d1, d2)
+      iex> [a: Dict.get(d, :a), b: Dict.get(d, :b), d: Dict.get(d, :d)]
       [a: 3, b: 2, d: 4]
 
       iex> d1 = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> d2 = Enum.into([a: 3, d: 4], dict_impl.new)
-      ...> d = Dict.merge(d1, d2, fn(_k, v1, v2) ->
+      iex> d2 = Enum.into([a: 3, d: 4], dict_impl.new)
+      iex> d = Dict.merge(d1, d2, fn(_k, v1, v2) ->
       ...>   v1 + v2
       ...> end)
-      ...> [a: Dict.get(d, :a), b: Dict.get(d, :b), d: Dict.get(d, :d)]
+      iex> [a: Dict.get(d, :a), b: Dict.get(d, :b), d: Dict.get(d, :d)]
       [a: 4, b: 2, d: 4]
 
   """
@@ -301,18 +301,18 @@ defmodule Dict do
   ## Examples
 
       iex> dict = Enum.into([a: 1], dict_impl.new)
-      ...> {v, d} = Dict.pop dict, :a
-      ...> {v, Enum.sort(d)}
+      iex> {v, d} = Dict.pop dict, :a
+      iex> {v, Enum.sort(d)}
       {1,[]}
 
       iex> dict = Enum.into([a: 1], dict_impl.new)
-      ...> {v, d} = Dict.pop dict, :b
-      ...> {v, Enum.sort(d)}
+      iex> {v, d} = Dict.pop dict, :b
+      iex> {v, Enum.sort(d)}
       {nil,[a: 1]}
 
       iex> dict = Enum.into([a: 1], dict_impl.new)
-      ...> {v, d} = Dict.pop dict, :b, 3
-      ...> {v, Enum.sort(d)}
+      iex> {v, d} = Dict.pop dict, :b, 3
+      iex> {v, Enum.sort(d)}
       {3,[a: 1]}
 
   """
@@ -328,8 +328,8 @@ defmodule Dict do
   ## Examples
 
       iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> d = Dict.update!(d, :a, fn(val) -> -val end)
-      ...> Dict.get(d, :a)
+      iex> d = Dict.update!(d, :a, fn(val) -> -val end)
+      iex> Dict.get(d, :a)
       -1
 
   """
@@ -346,8 +346,8 @@ defmodule Dict do
   ## Examples
 
       iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> d = Dict.update(d, :c, 3, fn(val) -> -val end)
-      ...> Dict.get(d, :c)
+      iex> d = Dict.update(d, :c, 3, fn(val) -> -val end)
+      iex> Dict.get(d, :c)
       3
 
   """
@@ -366,18 +366,18 @@ defmodule Dict do
   ## Examples
 
       iex> d = Enum.into([a: 1, b: 2, c: 3, d: 4], dict_impl.new)
-      ...> { d1, d2 } = Dict.split(d, [:a, :c, :e])
-      ...> { Dict.to_list(d1) |> Enum.sort, Dict.to_list(d2) |> Enum.sort }
+      iex> { d1, d2 } = Dict.split(d, [:a, :c, :e])
+      iex> { Dict.to_list(d1) |> Enum.sort, Dict.to_list(d2) |> Enum.sort }
       { [a: 1, c: 3], [b: 2, d: 4] }
 
       iex> d = Enum.into([], dict_impl.new)
-      ...> { d1, d2 } = Dict.split(d, [:a, :c])
-      ...> { Dict.to_list(d1), Dict.to_list(d2) }
+      iex> { d1, d2 } = Dict.split(d, [:a, :c])
+      iex> { Dict.to_list(d1), Dict.to_list(d2) }
       { [], [] }
 
       iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> { d1, d2 } = Dict.split(d, [:a, :b, :c])
-      ...> { Dict.to_list(d1) |> Enum.sort, Dict.to_list(d2) }
+      iex> { d1, d2 } = Dict.split(d, [:a, :b, :c])
+      iex> { Dict.to_list(d1) |> Enum.sort, Dict.to_list(d2) }
       { [a: 1, b: 2], [] }
 
   """
@@ -393,13 +393,13 @@ defmodule Dict do
   ## Examples
 
       iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> d = Dict.drop(d, [:a, :c, :d])
-      ...> Dict.to_list(d)
+      iex> d = Dict.drop(d, [:a, :c, :d])
+      iex> Dict.to_list(d)
       [b: 2]
 
       iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...> d = Dict.drop(d, [:c, :d])
-      ...> Dict.to_list(d) |> Enum.sort
+      iex> d = Dict.drop(d, [:c, :d])
+      iex> Dict.to_list(d) |> Enum.sort
       [a: 1, b: 2]
 
   """
@@ -416,13 +416,11 @@ defmodule Dict do
   ## Examples
 
       iex> d = Enum.into([a: 1, b: 2], dict_impl.new)
-      ...>
-      ...> d = Dict.take(d, [:a, :c, :d])
-      ...> Dict.to_list(d)
+      iex> d = Dict.take(d, [:a, :c, :d])
+      iex> Dict.to_list(d)
       [a: 1]
-      ...>
-      ...> d = Dict.take(d, [:c, :d])
-      ...> Dict.to_list(d)
+      iex> d = Dict.take(d, [:c, :d])
+      iex> Dict.to_list(d)
       []
 
   """
@@ -447,13 +445,13 @@ defmodule Dict do
   ## Examples
 
       iex> a = Enum.into([a: 2, b: 3, f: 5, c: 123], dict_impl.new)
-      ...> b = [a: 2, b: 3, f: 5, c: 123]
-      ...> Dict.equal?(a, b)
+      iex> b = [a: 2, b: 3, f: 5, c: 123]
+      iex> Dict.equal?(a, b)
       true
 
       iex> a = Enum.into([a: 2, b: 3, f: 5, c: 123], dict_impl.new)
-      ...> b = []
-      ...> Dict.equal?(a, b)
+      iex> b = []
+      iex> Dict.equal?(a, b)
       false
 
   """