Skip to content

Instantly share code, notes, and snippets.

@manpages

manpages/docs.erl.iex.out

Created May 18, 2013 09:07
Show Gist options
  • Save manpages/5603803 to your computer and use it in GitHub Desktop.
Save manpages/5603803 to your computer and use it in GitHub Desktop.
Download ZIP
Result of printing huge data structure with what appears to be width overflow.
Raw
docs.erl.iex.out
This file has been truncated, but you can view the full file.
Warning: could not run smart terminal, falling back to dumb one
Interactive Elixir (0.8.3.dev) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> { :ok,
[ [ modules: [ { ExDoc.ModuleNode,
Application.Behaviour,
"Application.Behaviour",
"This module is a convenience to define application module callbacks.\n\nIn Erlang/OTP, an application is a component that can be started\nand stopped as a unit, and which can be re-used in other systems\nas well.\n\nThe first step to achieve this is to define an application specification.\nFor example, if your application is named `:my_app`, an app specification\nshould exist at `ebin/my_app.app`. This file is usually defined by\nbuild tools like Mix.\n\nThen, with the app specification in hands, we must also define an\napplication module callback that controls how to start and stop\nsuch applications. This module is about defining such callbacks.\n\nThere are two callbacks required to be implemented:\n\n1. `start(type, args)` - It must return `{ :ok, pid }` or\n `{ :ok, pid, state }`, where `pid` is the process identifier\n of the supervisor tree root;\n\n2. `stop(state)` receives the state returned by `start` and should\n do any necessary cleaning up. Notice that shutting down the supervisor\n is automatically handled by the VM;\n\nWhen using this module, it simply tags the module behaviour as\n`:application` and defines a default `stop/1` callback. The `start/2`\nstill needs to be defined by the user.\n\nYou can learn more about the `:application` module, the application\nspecification and the application module callbacks below:\n\nhttp://www.erlang.org/doc/man/application.html\nhttp://www.erlang.org/doc/design_principles/applications.html\nhttp://learnyousomeerlang.com/building-otp-applications\n\n## Example\n\n defmodule MyApp do\n use Application.Behaviour\n\n def start(_type, args) do\n MyApp.Sup.start_link(args)\n end\n end\n\n",
[],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/application/behaviour.ex#L1",
[],
nil,
"Application.Behaviour",
1,
nil },
{ ExDoc.ModuleNode,
Behaviour,
"Behaviour",
"A convenience module for defining behaviours.\nBehaviours can be referenced by other modules\nin order to ensure they implement the proper\ncallbacks.\n\nFor example, you can specify the `URI.Parser`\nbehaviour as follow:\n\n defmodule URI.Parser do\n use Behaviour\n\n @doc \"Parses the given URL\"\n defcallback parse(uri_info :: URI.Info.t) :: URI.Info.t\n\n @doc \"Defines a default port\"\n defcallback default_port() :: integer\n end\n\nAnd then a specific module may use it as:\n\n defmodule URI.HTTP do\n @behaviour URI.Parser\n def default_port(), do: 80\n def parse(info), do: info\n end\n\nIn case the behaviour changes or URI.HTTP does\nnot implement one of the callbacks, a warning\nwill be raised.\n\n## Implementation\n\nBehaviours since Erlang R15 must be defined via\n`@callback` attributes. `defcallback` is a simple\nmechanism that defines the `@callback` attribute\naccording to the type specification and also allows\ndocs and defines a custom function signature.\n\nThe callbacks and their documentation can be retrieved\nvia the `__behaviour__` callback function.\n",
[ { ExDoc.FunctionNode,
:defcallback,
1,
"defcallback/1",
"Defines a callback according to the given type specification.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/behaviour.ex#L48",
:defmacro,
48,
[ { :fun,
[ line: 52 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/behaviour.ex#L1",
[],
nil,
"Behaviour",
1,
nil },
{ ExDoc.ModuleNode,
Bitwise,
"Bitwise",
"This module provide macros and operators for bitwise operators.\nThese macros can be used in guards.\n\nThe easiest way to use is to simply import them into\nyour module:\n\n iex> use Bitwise\n ...> bnot 1\n -2\n\n iex> use Bitwise\n ...> 1 &&& 1\n 1\n\nYou can select to include only or skip operators by passing options:\n\n iex> use Bitwise, only_operators: true\n ...> 1 &&& 1\n 1\n\n",
[ { ExDoc.FunctionNode,
:&&&,
2,
"&&&/2",
"Bitwise and as operator.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L71",
:defmacro,
71,
[ { :left,
[ line: 71 ],
nil },
{ :right,
[ line: 71 ],
nil } ] },
{ ExDoc.FunctionNode,
:<<<,
2,
"<<</2",
"Arithmetic bitshift left as operator.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L113",
:defmacro,
113,
[ { :left,
[ line: 113 ],
nil },
{ :right,
[ line: 113 ],
nil } ] },
{ ExDoc.FunctionNode,
:>>>,
2,
">>>/2",
"Arithmetic bitshift right as operator.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L127",
:defmacro,
127,
[ { :left,
[ line: 127 ],
nil },
{ :right,
[ line: 127 ],
nil } ] },
{ ExDoc.FunctionNode,
:^^^,
2,
"^^^/2",
"Bitwise xor as operator.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L99",
:defmacro,
99,
[ { :left,
[ line: 99 ],
nil },
{ :right,
[ line: 99 ],
nil } ] },
{ ExDoc.FunctionNode,
:__using__,
1,
"__using__/1",
"Allow a developer to use this module in their programs with\nthe following options:\n\n* `:only_operators` - Include only operators;\n* `:skip_operators` - Skip operators;\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L33",
:defmacro,
33,
[ { :options,
[ line: 33 ],
nil } ] },
{ ExDoc.FunctionNode,
:band,
2,
"band/2",
"Bitwise and.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L64",
:defmacro,
64,
[ { :left,
[ line: 64 ],
nil },
{ :right,
[ line: 64 ],
nil } ] },
{ ExDoc.FunctionNode,
:bnot,
1,
"bnot/1",
"Bitwise not.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L50",
:defmacro,
50,
[ { :expr,
[ line: 50 ],
nil } ] },
{ ExDoc.FunctionNode,
:bor,
2,
"bor/2",
"Bitwise or.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L78",
:defmacro,
78,
[ { :left,
[ line: 78 ],
nil },
{ :right,
[ line: 78 ],
nil } ] },
{ ExDoc.FunctionNode,
:bsl,
2,
"bsl/2",
"Arithmetic bitshift left.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L106",
:defmacro,
106,
[ { :left,
[ line: 106 ],
nil },
{ :right,
[ line: 106 ],
nil } ] },
{ ExDoc.FunctionNode,
:bsr,
2,
"bsr/2",
"Arithmetic bitshift right.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L120",
:defmacro,
120,
[ { :left,
[ line: 120 ],
nil },
{ :right,
[ line: 120 ],
nil } ] },
{ ExDoc.FunctionNode,
:bxor,
2,
"bxor/2",
"Bitwise xor.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L92",
:defmacro,
92,
[ { :left,
[ line: 92 ],
nil },
{ :right,
[ line: 92 ],
nil } ] },
{ ExDoc.FunctionNode,
:|||,
2,
"|||/2",
"Bitwise or as operator.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L85",
:defmacro,
85,
[ { :left,
[ line: 85 ],
nil },
{ :right,
[ line: 85 ],
nil } ] },
{ ExDoc.FunctionNode,
:~~~,
1,
"~~~/1",
"Bitwise not as operator.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L57",
:defmacro,
57,
[ { :expr,
[ line: 57 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/bitwise.ex#L1",
[],
nil,
"Bitwise",
1,
nil },
{ ExDoc.ModuleNode,
Code,
"Code",
"The Code module is responsible to manage code compilation,\ncode evaluation and code loading.\n\nIt complements (Erlang's code module)[1] to add behavior\nwhich is specific to Elixir.\n\n [1]: (www.erlang.org/doc/man/code.html)\n\n",
[ { ExDoc.FunctionNode,
:append_path,
1,
"append_path/1",
"Appends a path to Erlang VM code path.\nThe path is expanded with `Path.expand` before added.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L40",
:def,
40,
[ { :path,
[ line: 40 ],
nil } ] },
{ ExDoc.FunctionNode,
:compile_quoted,
2,
"compile_quoted/2",
"Compiles the quoted expression and returns a list of tuples where\nthe first element is the module name and the second one is its\nbinary.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L278",
:def,
278,
[ { :quoted,
[ line: 278 ],
nil },
{ ://,
[ line: 278 ],
[ { :file,
[ line: 278 ],
nil },
"nofile" ] } ] },
{ ExDoc.FunctionNode,
:compile_string,
2,
"compile_string/2",
"Compiles the given string and returns a list of tuples where\nthe first element is the module name and the second one is its\nbinary.\n\nFor compiling many files at once, check `Kernel.ParallelCompiler`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L269",
:def,
269,
[ { :string,
[ line: 269 ],
nil },
{ ://,
[ line: 269 ],
[ { :file,
[ line: 269 ],
nil },
"nofile" ] } ] },
{ ExDoc.FunctionNode,
:compiler_options,
0,
"compiler_options/0",
"Loads the compilation options from the code server.\nCheck compiler_options/1 for more information.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L239",
:def,
239,
[] },
{ ExDoc.FunctionNode,
:compiler_options,
1,
"compiler_options/1",
"Sets compilation options. Those options are global\nsince they are stored by Elixir's Code Server.\n\nAvailable options are:\n\n* docs - when true, retain documentation in the compiled module.\n True by default;\n* debug_info - when true, retain debug information in the compiled module.\n This allows a developer to reconstruct the original source\n code, for such reasons, false by default;\n* ignore_module_conflict - when true, override modules that were already defined\n without raising errors, false by default;\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L258",
:def,
258,
[ { :opts,
[ line: 258 ],
nil } ] },
{ ExDoc.FunctionNode,
:delete_path,
1,
"delete_path/1",
"Deletes a path from Erlang VM code path.\nThe path is expanded with `Path.expand` before deleted.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L56",
:def,
56,
[ { :path,
[ line: 56 ],
nil } ] },
{ ExDoc.FunctionNode,
:ensure_compiled,
1,
"ensure_compiled/1",
"Ensures the given module is compiled and loaded. If the module\nis already loaded, it works as no-op. If the module was not\nloaded yet, it checks if it needs to be compiled first and just\nthen tries to load it.\n\nIf it succeeds loading the module anyhow, it returns\n`{ :module, module }`. If not, returns `{ :error, reason }` with\nthe error reason.\n\nCheck `ensure_loaded/1` for more information on module loading\nand when to use `ensure_loaded/1` or `ensure_compiled/1`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L345",
:def,
345,
[ { :module,
[ line: 345 ],
nil } ] },
{ ExDoc.FunctionNode,
:ensure_compiled?,
1,
"ensure_compiled?/1",
"Similar to `ensure_compiled/1`, but returns a boolean in case\nit could be ensured or not.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L366",
:def,
366,
[ { :module,
[ line: 366 ],
nil } ] },
{ ExDoc.FunctionNode,
:ensure_loaded,
1,
"ensure_loaded/1",
"Ensures the given module is loaded. If the module is already\nloaded, it works as no-op. If the module was not loaded yet,\nit tries to load it.\n\nIf it succeeds loading the module anyhow, it returns\n`{ :module, module }`. If not, returns `{ :error, reason }` with\nthe error reason.\n\n## Code loading on the Erlang VM\n\nErlang has two modes to load code: interactive and embedded.\n\nBy default, the Erlang VM runs on interactive mode, where modules\nare loaded as needed. In embedded mode the opposite happens, as all\nmodules need to be loaded upfront or explicitly.\n\nTherefore, this function is useful to check if a module is loaded\nbefore using it and react accordingly. For example, the `URI` module\nuses this function to check if a specific parser exists for a given\nURI scheme.\n\n## Code.ensure_compiled\n\nElixir also contains an `ensure_compiled/1` function that is a\nsuperset of `ensure_loaded/1`.\n\nSince Elixir's compilation happens in parallel, in some situations\nyou may need to use a module but it was not compiled yet, therefore\nit can't even be loaded.\n\n`ensure_compiled/1` puts a halt in the current process until the\nmodule we are depending on is available.\n\nIn most of the cases, `ensure_loaded` is enough. `ensure_compiled`\nmust be used just in same rare conditions, usually involving macros\nthat needs to invoke a module for callback information.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L320",
:def,
320,
[ { :module,
[ line: 320 ],
nil } ] },
{ ExDoc.FunctionNode,
:ensure_loaded?,
1,
"ensure_loaded?/1",
"Similar to `ensure_loaded/1`, but returns a boolean in case\nit could be ensured or not.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L328",
:def,
328,
[ { :module,
[ line: 328 ],
nil } ] },
{ ExDoc.FunctionNode,
:eval,
3,
"eval/3",
"Evalutes the contents given by string. The second argument is the\nbinding (which should be a keyword) followed by a keyword list of\nenvironment options. Those options can be:\n\n* `:file` - the file to be considered in the evaluation\n* `:line` - the line the script starts\n* `:delegate_locals_to` - delegate local calls to the given module,\n the default is to not delegate\n\nBesides, the following scope values can be configured:\n\n* `:aliases` - a list of tuples with the alias and its target\n* `:requires` - a list of modules required\n* `:functions` - a list of tuples where the first element is a module\n and the second a list of imported function names and arity\n* `:macros` - a list of tuples where the first element is a module\n and the second a list of imported macro names and arity\n\nNotice that setting any ov the values above overrides Elixir default\nvalues. For example, setting `:requires` to `[]`, will no longer\nautomatically required the `Kernel` module, in the same way setting\n`:macros` will no longer auto-import `Kernel` macros as `if`, `case`,\netc.\n\n## Examples\n\n iex> Code.eval(\"a + b\", [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)\n { 3, [ {:a, 1}, {:b, 2} ] }\n\nFor convenience, you can my pass `__ENV__` as argument and\nall imports, requires and aliases will be automatically carried\nover:\n\n iex> Code.eval(\"a + b\", [a: 1, b: 2], __ENV__)\n { 3, [ {:a, 1}, {:b, 2} ] }\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L98",
:def,
98,
[ { :string,
[ line: 98 ],
nil },
{ ://,
[ line: 98 ],
[ { :binding,
[ line: 98 ],
nil },
[] ] },
{ ://,
[ line: 98 ],
[ { :opts,
[ line: 98 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:eval_quoted,
3,
"eval_quoted/3",
"Evalutes the quoted contents.\n\nThis function accepts a list of environment options.\nCheck `Code.eval` for more information.\n\n## Examples\n\n iex> contents = quote(hygiene: [vars: false], do: a + b)\n ...> Code.eval_quoted(contents, [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)\n { 3, [ {:a, 1}, {:b, 2} ] }\n\nFor convenience, you can my pass `__ENV__` as argument and\nall options will be automatically extracted from the environment:\n\n iex> contents = quote(hygiene: [vars: false], do: a + b)\n ...> Code.eval_quoted(contents, [a: 1, b: 2], __ENV__)\n { 3, [ {:a, 1}, {:b, 2} ] }\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L130",
:def,
130,
[ { :quoted,
[ line: 130 ],
nil },
{ ://,
[ line: 130 ],
[ { :binding,
[ line: 130 ],
nil },
[] ] },
{ ://,
[ line: 130 ],
[ { :opts,
[ line: 130 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:load_file,
2,
"load_file/2",
"Loads the given `file`. Accepts `relative_to` as an argument\nto tell where the file is located. If the file was already\nrequired/loaded, loads it again. It returns all the modules\ndefined in the file.\n\nNotice that if `load_file` is invoked by different processes\nconcurrently, the target file will be invoked concurrently\nin many times. I.e. if `load_file` is called N times with\na given file, the given file will be loaded N times. Check\n`require_file` if you don't want a file to be loaded concurrently.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L199",
:def,
199,
[ { :file,
[ line: 199 ],
nil },
{ ://,
[ line: 199 ],
[ { :relative_to,
[ line: 199 ],
nil },
nil ] } ] },
{ ExDoc.FunctionNode,
:loaded_files,
0,
"loaded_files/0",
"Returns all the loaded files.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L22",
:def,
22,
[] },
{ ExDoc.FunctionNode,
:prepend_path,
1,
"prepend_path/1",
"Prepends a path to Erlang VM code path.\nThe path is expanded with `Path.expand` before added.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L48",
:def,
48,
[ { :path,
[ line: 48 ],
nil } ] },
{ ExDoc.FunctionNode,
:require_file,
2,
"require_file/2",
"Requires the given `file`. Accepts `relative_to` as an argument\nto tell where the file is located. If the file was already\nrequired/loaded, loads it again. It returns all the modules\ndefined in the file.\n\nNotice that if `require_file` is invoked by different processes\nconcurrently, the first process to invoke `require_file` acquires\na lock and the remaining ones will block until the file is\navailable. I.e. if `require_file` is called N times with a given\nfile, the given file will be loaded only once. Check `load_file`\nif you want a file to be loaded concurrently.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L220",
:def,
220,
[ { :file,
[ line: 220 ],
nil },
{ ://,
[ line: 220 ],
[ { :relative_to,
[ line: 220 ],
nil },
nil ] } ] },
{ ExDoc.FunctionNode,
:string_to_ast,
2,
"string_to_ast/2",
"Converts the given string to AST. It returns `{ :ok, ast }`\nif it succeeds, `{ :error, { line, error, token } }` otherwise.\n\n## Options\n\n* `:file` - The filename to be used in stacktraces\n and the file reported in the __ENV__ variable.\n\n* `:line` - The line reported in the __ENV__ variable.\n\n* `:existing_atoms_only` - When true, raises an error\n when non-existing atoms are found by the tokenizer.\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L157",
:def,
157,
[ { :string,
[ line: 157 ],
nil },
{ ://,
[ line: 157 ],
[ { :opts,
[ line: 157 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:string_to_ast!,
2,
"string_to_ast!/2",
"Converts the given string to AST. It returns the ast if it succeeds,\nraises an exception otherwise. The exception is a TokenMissingError\nin case a token is missing (usually because the expression is incomplete),\nSyntaxError otherwise.\n\nCheck `Code.string_to_ast/2` for options information.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L176",
:def,
176,
[ { :string,
[ line: 176 ],
nil },
{ ://,
[ line: 176 ],
[ { :opts,
[ line: 176 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:unload_files,
1,
"unload_files/1",
"Removes the given files from the loaded files list.\nThe modules defined in the file are not removed,\ncalling this function only removes it from the list,\nallowing it to be required again.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L32",
:def,
32,
[ { :files,
[ line: 32 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/code.ex#L1",
[],
nil,
"Code",
1,
nil },
{ ExDoc.ModuleNode,
Dict,
"Dict",
"This module specifies the Dict API expected to be\nimplemented by different dictionaries. It also provides\nfunctions that redirect to the underlying Dict, allowing\na developer to work with different Dict implementations\nusing one API.\n\nTo create a new dict, use the `new` functions defined\nby each dict type:\n\n HashDict.new #=> creates an empty HashDict\n\nFor simplicity's sake, in the examples below everytime\n`new` is used, it implies one of the module-specific\ncalls like above. Likewise, when the result of a function\ninvocation is shown in the form `[a: 1, b: 2]`, it implies\nthat the returned value is actually of the same dict type\nas the input one.\n\n## Protocols\n\nBesides implementing the functions in this module, all\ndictionaries are also required to implement the `Access`\nprotocol:\n\n iex> dict = HashDict.new\n ...> dict = Dict.put(dict, :hello, :world)\n ...> dict[:hello]\n :world\n\nAnd also the `Enum.Iterator` protocol, allowing one to write:\n\n Enum.each(dict, fn ({ k, v }) ->\n IO.puts \"\#{k}: \#{v}\"\n end)\n\n",
[ { ExDoc.FunctionNode,
:values,
1,
"values/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L62",
:defcallback,
62,
[ { :t,
[ line: 62 ],
[] } ] },
{ ExDoc.FunctionNode,
:update,
4,
"update/4",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L61",
:defcallback,
61,
[ { :t,
[ line: 61 ],
[] },
{ :key,
[ line: 61 ],
[] },
{ :value,
[ line: 61 ],
[] },
{ :"->",
[ line: 61 ],
[ { [ { :value,
[ line: 61 ],
[] } ],
{ :value,
[ line: 61 ],
[] } } ] } ] },
{ ExDoc.FunctionNode,
:update,
3,
"update/3",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L60",
:defcallback,
60,
[ { :t,
[ line: 60 ],
[] },
{ :key,
[ line: 60 ],
[] },
{ :"->",
[ line: 60 ],
[ { [ { :value,
[ line: 60 ],
[] } ],
{ :value,
[ line: 60 ],
[] } } ] } ] },
{ ExDoc.FunctionNode,
:to_list,
1,
"to_list/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L59",
:defcallback,
59,
[ { :t,
[ line: 59 ],
[] } ] },
{ ExDoc.FunctionNode,
:size,
1,
"size/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L58",
:defcallback,
58,
[ { :t,
[ line: 58 ],
[] } ] },
{ ExDoc.FunctionNode,
:put_new,
3,
"put_new/3",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L57",
:defcallback,
57,
[ { :t,
[ line: 57 ],
[] },
{ :key,
[ line: 57 ],
[] },
{ :value,
[ line: 57 ],
[] } ] },
{ ExDoc.FunctionNode,
:put,
3,
"put/3",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L56",
:defcallback,
56,
[ { :t,
[ line: 56 ],
[] },
{ :key,
[ line: 56 ],
[] },
{ :value,
[ line: 56 ],
[] } ] },
{ ExDoc.FunctionNode,
:merge,
3,
"merge/3",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L55",
:defcallback,
55,
[ { :t,
[ line: 55 ],
[] },
{ :t,
[ line: 55 ],
[] },
{ :"->",
[ line: 55 ],
[ { [ { :key,
[ line: 55 ],
[] },
{ :value,
[ line: 55 ],
[] },
{ :value,
[ line: 55 ],
[] } ],
{ :value,
[ line: 55 ],
[] } } ] } ] },
{ ExDoc.FunctionNode,
:merge,
2,
"merge/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L54",
:defcallback,
54,
[ { :t,
[ line: 54 ],
[] },
{ :t,
[ line: 54 ],
[] } ] },
{ ExDoc.FunctionNode,
:keys,
1,
"keys/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L53",
:defcallback,
53,
[ { :t,
[ line: 53 ],
[] } ] },
{ ExDoc.FunctionNode,
:has_key?,
2,
"has_key?/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L52",
:defcallback,
52,
[ { :t,
[ line: 52 ],
[] },
{ :key,
[ line: 52 ],
[] } ] },
{ ExDoc.FunctionNode,
:get!,
2,
"get!/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L51",
:defcallback,
51,
[ { :t,
[ line: 51 ],
[] },
{ :key,
[ line: 51 ],
[] } ] },
{ ExDoc.FunctionNode,
:get,
3,
"get/3",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L50",
:defcallback,
50,
[ { :t,
[ line: 50 ],
[] },
{ :key,
[ line: 50 ],
[] },
{ :value,
[ line: 50 ],
[] } ] },
{ ExDoc.FunctionNode,
:get,
2,
"get/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L49",
:defcallback,
49,
[ { :t,
[ line: 49 ],
[] },
{ :key,
[ line: 49 ],
[] } ] },
{ ExDoc.FunctionNode,
:equal?,
2,
"equal?/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L48",
:defcallback,
48,
[ { :t,
[ line: 48 ],
[] },
{ :t,
[ line: 48 ],
[] } ] },
{ ExDoc.FunctionNode,
:empty,
1,
"empty/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L47",
:defcallback,
47,
[ { :t,
[ line: 47 ],
[] } ] },
{ ExDoc.FunctionNode,
:delete,
2,
"delete/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L46",
:defcallback,
46,
[ { :t,
[ line: 46 ],
[] },
{ :key,
[ line: 46 ],
[] } ] },
{ ExDoc.FunctionNode,
:delete,
2,
"delete/2",
"Removes the entry stored under the given key from `dict`.\nIf `dict` does not contain `key`, returns the dictionary unchanged.\n\n## Examples\n\n iex> d = HashDict.new([a: 1, b: 2])\n ...> d = Dict.delete(d, :a)\n ...> Dict.get(d, :a)\n nil\n\n iex> d = HashDict.new([b: 2])\n ...> Dict.delete(d, :a) == d\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L253",
:def,
253,
[ { :dict,
[ line: 253 ],
nil },
{ :key,
[ line: 253 ],
nil } ] },
{ ExDoc.FunctionNode,
:empty,
1,
"empty/1",
"Returns an empty dict of the same type as `dict`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L335",
:def,
335,
[ { :dict,
[ line: 335 ],
nil } ] },
{ ExDoc.FunctionNode,
:equal?,
2,
"equal?/2",
"Check if two dicts are equal, if the dicts are of different types they're\nfirst converted to lists.\n\n## Examples\n\n iex> a = HashDict.new(a: 2, b: 3, f: 5, c: 123)\n ...> b = List.Dict.new(a: 2, b: 3, f: 5, c: 123)\n ...> Dict.equal?(a, b)\n true\n\n iex> a = HashDict.new(a: 2, b: 3, f: 5, c: 123)\n ...> b = []\n ...> Dict.equal?(a, b)\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L357",
:def,
357,
[ { :a,
[ line: 357 ],
nil },
{ :b,
[ line: 357 ],
nil } ] },
{ ExDoc.FunctionNode,
:fetch,
2,
"fetch/2",
"Returns the `{ :ok, value }` associated with `key` in `dict`.\nIf `dict` does not contain `key`, returns `:error`.\n\n## Examples\n\n iex> d = HashDict.new([a: 1])\n ...> Dict.fetch(d, :a)\n { :ok, 1 }\n\n iex> d = HashDict.new([a: 1])\n ...> Dict.fetch(d, :b)\n :error\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L199",
:def,
199,
[ { :dict,
[ line: 199 ],
nil },
{ :key,
[ line: 199 ],
nil } ] },
{ ExDoc.FunctionNode,
:get,
3,
"get/3",
"Returns the value associated with `key` in `dict`. If `dict` does not\ncontain `key`, returns `default` (or nil if not provided).\n\n## Examples\n\n iex> d = HashDict.new([a: 1])\n ...> Dict.get(d, :a)\n 1\n\n iex> d = HashDict.new([a: 1])\n ...> Dict.get(d, :b)\n nil\n\n iex> d = HashDict.new([a: 1])\n ...> Dict.get(d, :b, 3)\n 3\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L160",
:def,
160,
[ { :dict,
[ line: 160 ],
nil },
{ :key,
[ line: 160 ],
nil },
{ ://,
[ line: 160 ],
[ { :default,
[ line: 160 ],
nil },
nil ] } ] },
{ ExDoc.FunctionNode,
:get!,
2,
"get!/2",
"Returns the value associated with `key` in `dict`. If `dict` does not\ncontain `key`, it raises `KeyError`.\n\n## Examples\n\n iex> d = HashDict.new([a: 1])\n ...> Dict.get(d, :a)\n 1\n iex> d = HashDict.new([a: 1])\n ...> Dict.get!(d, :b)\n ** (KeyError) key not found: :b\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L179",
:def,
179,
[ { :dict,
[ line: 179 ],
nil },
{ :key,
[ line: 179 ],
nil } ] },
{ ExDoc.FunctionNode,
:has_key?,
2,
"has_key?/2",
"Returns whether the given key exists in the given dict.\n\n## Examples\n\n iex> d = HashDict.new([a: 1])\n ...> Dict.has_key?(d, :a)\n true\n\n iex> d = HashDict.new([a: 1])\n ...> Dict.has_key?(d, :b)\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L137",
:def,
137,
[ { :dict,
[ line: 137 ],
nil },
{ :key,
[ line: 137 ],
nil } ] },
{ ExDoc.FunctionNode,
:keys,
1,
"keys/1",
"Returns a list containing all dict's keys.\nThe keys are not guaranteed to be sorted, unless\nthe underlying dict implementation defines so.\n\n## Examples\n\n iex> d = HashDict.new([a: 1, b: 2])\n ...> Enum.sort(Dict.keys(d))\n [:a,:b]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L88",
:def,
88,
[ { :dict,
[ line: 88 ],
nil } ] },
{ ExDoc.FunctionNode,
:merge,
2,
"merge/2",
"Merges the given enum into the dict. In case one of the enum entries\nalread exist in the dict, it is given higher preference.\n\n## Examples\n\n iex> d1 = HashDict.new([a: 1, b: 2])\n ...> d2 = HashDict.new([a: 3, d: 4])\n ...> d = Dict.merge(d1, d2)\n ...> [a: Dict.get(d, :a), b: Dict.get(d, :b), d: Dict.get(d, :d)]\n [a: 3, b: 2, d: 4]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L271",
:def,
271,
[ { :dict,
[ line: 271 ],
nil },
{ :enum,
[ line: 271 ],
nil } ] },
{ ExDoc.FunctionNode,
:merge,
3,
"merge/3",
"Merges the given enum into the dict. In case one of the enum entries\nalread exist in the dict, the given function is invoked to solve\nconflicts.\n\n## Examples\n\n iex> d1 = HashDict.new([a: 1, b: 2])\n ...> d2 = HashDict.new([a: 3, d: 4])\n ...> d = Dict.merge(d1, d2, fn(_k, v1, v2) ->\n ...> v1 + v2\n ...> end)\n ...> [a: Dict.get(d, :a), b: Dict.get(d, :b), d: Dict.get(d, :d)]\n [a: 4, b: 2, d: 4]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L292",
:def,
292,
[ { :dict,
[ line: 292 ],
nil },
{ :enum,
[ line: 292 ],
nil },
{ :fun,
[ line: 292 ],
nil } ] },
{ ExDoc.FunctionNode,
:put,
3,
"put/3",
"Stores the given `value` under `key` in `dict`.\nIf `dict` already has `key`, the stored value is replaced by the new one.\n\n## Examples\n\n iex> d = HashDict.new([a: 1, b: 2])\n ...> d = Dict.put(d, :a, 3)\n ...> Dict.get(d, :a)\n 3\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L216",
:def,
216,
[ { :dict,
[ line: 216 ],
nil },
{ :key,
[ line: 216 ],
nil },
{ :val,
[ line: 216 ],
nil } ] },
{ ExDoc.FunctionNode,
:put_new,
3,
"put_new/3",
"Puts the given `value` under `key` in `dict` unless `key` already exists.\n\n## Examples\n\n iex> d = HashDict.new([a: 1, b: 2])\n ...> d = Dict.put_new(d, :a, 3)\n ...> Dict.get(d, :a)\n 1\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L232",
:def,
232,
[ { :dict,
[ line: 232 ],
nil },
{ :key,
[ line: 232 ],
nil },
{ :val,
[ line: 232 ],
nil } ] },
{ ExDoc.FunctionNode,
:size,
1,
"size/1",
"Returns the number of elements in `dict`.\n\n## Examples\n\n iex> d = HashDict.new([a: 1, b: 2])\n ...> Dict.size(d)\n 2\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L118",
:def,
118,
[ { :dict,
[ line: 118 ],
nil } ] },
{ ExDoc.FunctionNode,
:to_list,
1,
"to_list/1",
"Returns a list of key-value pairs stored in `dict`.\nNo particular order is enforced.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L378",
:def,
378,
[ { :dict,
[ line: 378 ],
nil } ] },
{ ExDoc.FunctionNode,
:update,
3,
"update/3",
"Update a value in `dict` by calling `fun` on the value to get a new\nvalue. An exception is generated if `key` is not present in the dict.\n\n## Examples\n\n iex> d = HashDict.new([a: 1, b: 2])\n ...> d = Dict.update(d, :a, fn(val) -> -val end)\n ...> Dict.get(d, :a)\n -1\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L309",
:def,
309,
[ { :dict,
[ line: 309 ],
nil },
{ :key,
[ line: 309 ],
nil },
{ :fun,
[ line: 309 ],
nil } ] },
{ ExDoc.FunctionNode,
:update,
4,
"update/4",
"Update a value in `dict` by calling `fun` on the value to get a new value. If\n`key` is not present in `dict` then `initial` will be stored as the first\nvalue.\n\n## Examples\n\n iex> d = HashDict.new([a: 1, b: 2])\n ...> d = Dict.update(d, :c, 3, fn(val) -> -val end)\n ...> Dict.get(d, :c)\n 3\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L327",
:def,
327,
[ { :dict,
[ line: 327 ],
nil },
{ :key,
[ line: 327 ],
nil },
{ :initial,
[ line: 327 ],
nil },
{ :fun,
[ line: 327 ],
nil } ] },
{ ExDoc.FunctionNode,
:values,
1,
"values/1",
"Returns a list containing all dict's values.\n\n## Examples\n\n iex> d = HashDict.new([a: 1, b: 2])\n ...> Enum.sort(Dict.values(d))\n [1,2]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L103",
:def,
103,
[ { :dict,
[ line: 103 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/dict.ex#L1",
[],
:behaviour,
"Dict",
1,
nil },
{ ExDoc.ModuleNode,
EEx,
"EEx",
"EEx stands for Embedded Elixir. It allows you to embed\nElixir code inside a string in a robust way:\n\n EEx.eval_string \"foo <%= bar %>\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n## API\n\nThis module provides 3 main APIs for you to use:\n\n1) Evaluate a string (`eval_string`) or a file (`eval_file`)\n directly. This is the simplest API to use but also the\n slowest, since the code is evaluated and not compiled before;\n\n2) Define a function from a string (`function_from_string`)\n or a file (`function_from_file`). This allows you to embed\n the template as a function inside a module which will then\n be compiled. This is the preferred API if you have access\n to the template at compilation time;\n\n3) Compile a string (`compile_string`) or a file (`compile_file`)\n into Elixir syntax tree. This is the API used by both functions\n above and is available to you if you want to provide your own\n ways of handling the compiled template.\n\n## Engine\n\nEEx has the concept of engines which allows you to modify or\ntransform the code extracted from the given string or file.\n\nBy default, `EEx` uses the `EEx.SmartEngine` that provides some\nconveniences on top of the simple `EEx.Engine`.\n\n### Tags\n\n`EEx.SmartEngine` supports the following tags:\n\n <% Elixir expression - inline with output %>\n <%= Elixir expression - replace with result %>\n <%% EEx quotation - returns the contents inside %>\n <%# Comments - they are discarded from source %>\n\nAll expressions that output something to the template\n**must** use the equals sign (`=`). Since everything in\nElixir is a macro, there are no exceptions for this rule.\nFor example, while some template languages would special-\ncase `if` clauses, they are treated the same in EEx and\nalso require `=` in order to have their result printed:\n\n <%= if true do %>\n It is obviously true\n <% else %>\n This will never appear\n <% end %>\n\nNotice that different engines may have different rules\nfor each tag. Other tags may be added in future versions.\n\n### Macros\n\n`EEx.SmartEngine` also adds some macros to your template.\nAn example is the `@` macro which allows easy data access\nin a template:\n\n EEx.eval_string \"<%= @foo %>\", assigns: [foo: 1]\n #=> 1\n\nIn other words, <%= @foo %> is simply translated to:\n\n <%= Keyword.get assigns, :foo %>\n\nThe assigns extension is useful when the number of variables\nrequired by the template is not specified at compilation time.\n",
[ { ExDoc.FunctionNode,
:compile_file,
2,
"compile_file/2",
"Get a `filename` and generate a quoted expression\nthat can be evaluated by Elixir or compiled to a function.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L150",
:def,
150,
[ { :filename,
[ line: 150 ],
nil },
{ ://,
[ line: 150 ],
[ { :options,
[ line: 150 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:compile_string,
2,
"compile_string/2",
"Get a string `source` and generate a quoted expression\nthat can be evaluated by Elixir or compiled to a function.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L142",
:def,
142,
[ { :source,
[ line: 142 ],
nil },
{ ://,
[ line: 142 ],
[ { :options,
[ line: 142 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:eval_file,
3,
"eval_file/3",
"Get a `filename` and evaluate the values using the `bindings`.\n\n## Examples\n\n # sample.ex\n foo <%= bar %>\n\n # iex\n EEx.eval_file \"sample.ex\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L182",
:def,
182,
[ { :filename,
[ line: 182 ],
nil },
{ ://,
[ line: 182 ],
[ { :bindings,
[ line: 182 ],
nil },
[] ] },
{ ://,
[ line: 182 ],
[ { :options,
[ line: 182 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:eval_string,
3,
"eval_string/3",
"Get a string `source` and evaluate the values using the `bindings`.\n\n## Examples\n\n EEx.eval_string \"foo <%= bar %>\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L164",
:def,
164,
[ { :source,
[ line: 164 ],
nil },
{ ://,
[ line: 164 ],
[ { :bindings,
[ line: 164 ],
nil },
[] ] },
{ ://,
[ line: 164 ],
[ { :options,
[ line: 164 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:function_from_file,
5,
"function_from_file/5",
"Generates a function definition from the file contents.\nThe kind (`:def` or `:defp`) must be given, the\nfunction name, its arguments and the compilation options.\n\nThis function is useful in case you have templates but\nyou want to precompile inside a module for speed.\n\n## Examples\n\n # sample.eex\n <%= a + b %>\n\n # sample.ex\n defmodule Sample do\n require EEx\n EEx.function_from_file :def, :sample, \"sample.eex\", [:a, :b]\n end\n\n # iex\n Sample.sample(1, 2) #=> \"3\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L127",
:defmacro,
127,
[ { :kind,
[ line: 127 ],
nil },
{ :name,
[ line: 127 ],
nil },
{ :filename,
[ line: 127 ],
nil },
{ ://,
[ line: 127 ],
[ { :args,
[ line: 127 ],
nil },
[] ] },
{ ://,
[ line: 127 ],
[ { :options,
[ line: 127 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:function_from_string,
5,
"function_from_string/5",
"Generates a function definition from the string.\nThe kind (`:def` or `:defp`) must be given, the\nfunction name, its arguments and the compilation options.\n\n## Examples\n\n defmodule Sample do\n require EEx\n EEx.function_from_string :def, :sample, \"<%= a + b %>\", [:a, :b]\n end\n\n Sample.sample(1, 2) #=> \"3\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L95",
:defmacro,
95,
[ { :kind,
[ line: 95 ],
nil },
{ :name,
[ line: 95 ],
nil },
{ :source,
[ line: 95 ],
nil },
{ ://,
[ line: 95 ],
[ { :args,
[ line: 95 ],
nil },
[] ] },
{ ://,
[ line: 95 ],
[ { :options,
[ line: 95 ],
nil },
[] ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L3",
[ { ExDoc.ModuleNode,
EEx.AssignsEngine,
"AssignsEngine",
"An abstract engine that, when used with the\n`TransformerEngine`, allows a developer to access\nassigns using `@` as syntax.\n\nThis engine is included by default on the SmartEngine.\n\n## Examples\n\n defmodule MyEngine do\n use EEx.TransformerEngine\n use EEx.AssignsEngine\n end\n\n EEx.eval_string(\"<%= @foo %>\", assigns: [foo: 1])\n #=> 1\n\nIn the example above, we can access the value `foo` under\nthe binding `assigns` using `@foo`. This is useful when\na template, after compiled, may receive different assigns\nand the developer don't want to recompile it for each\nvariable set.\n",
[],
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex/smart_engine.ex#L47",
[],
nil,
"EEx.AssignsEngine",
47,
{ ExDoc.ModuleNode,
EEx,
"EEx",
"EEx stands for Embedded Elixir. It allows you to embed\nElixir code inside a string in a robust way:\n\n EEx.eval_string \"foo <%= bar %>\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n## API\n\nThis module provides 3 main APIs for you to use:\n\n1) Evaluate a string (`eval_string`) or a file (`eval_file`)\n directly. This is the simplest API to use but also the\n slowest, since the code is evaluated and not compiled before;\n\n2) Define a function from a string (`function_from_string`)\n or a file (`function_from_file`). This allows you to embed\n the template as a function inside a module which will then\n be compiled. This is the preferred API if you have access\n to the template at compilation time;\n\n3) Compile a string (`compile_string`) or a file (`compile_file`)\n into Elixir syntax tree. This is the API used by both functions\n above and is available to you if you want to provide your own\n ways of handling the compiled template.\n\n## Engine\n\nEEx has the concept of engines which allows you to modify or\ntransform the code extracted from the given string or file.\n\nBy default, `EEx` uses the `EEx.SmartEngine` that provides some\nconveniences on top of the simple `EEx.Engine`.\n\n### Tags\n\n`EEx.SmartEngine` supports the following tags:\n\n <% Elixir expression - inline with output %>\n <%= Elixir expression - replace with result %>\n <%% EEx quotation - returns the contents inside %>\n <%# Comments - they are discarded from source %>\n\nAll expressions that output something to the template\n**must** use the equals sign (`=`). Since everything in\nElixir is a macro, there are no exceptions for this rule.\nFor example, while some template languages would special-\ncase `if` clauses, they are treated the same in EEx and\nalso require `=` in order to have their result printed:\n\n <%= if true do %>\n It is obviously true\n <% else %>\n This will never appear\n <% end %>\n\nNotice that different engines may have different rules\nfor each tag. Other tags may be added in future versions.\n\n### Macros\n\n`EEx.SmartEngine` also adds some macros to your template.\nAn example is the `@` macro which allows easy data access\nin a template:\n\n EEx.eval_string \"<%= @foo %>\", assigns: [foo: 1]\n #=> 1\n\nIn other words, <%= @foo %> is simply translated to:\n\n <%= Keyword.get assigns, :foo %>\n\nThe assigns extension is useful when the number of variables\nrequired by the template is not specified at compilation time.\n",
[ { ExDoc.FunctionNode,
:compile_file,
2,
"compile_file/2",
"Get a `filename` and generate a quoted expression\nthat can be evaluated by Elixir or compiled to a function.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L150",
:def,
150,
[ { :filename,
[ line: 150 ],
nil },
{ ://,
[ line: 150 ],
[ { :options,
[ line: 150 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:compile_string,
2,
"compile_string/2",
"Get a string `source` and generate a quoted expression\nthat can be evaluated by Elixir or compiled to a function.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L142",
:def,
142,
[ { :source,
[ line: 142 ],
nil },
{ ://,
[ line: 142 ],
[ { :options,
[ line: 142 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:eval_file,
3,
"eval_file/3",
"Get a `filename` and evaluate the values using the `bindings`.\n\n## Examples\n\n # sample.ex\n foo <%= bar %>\n\n # iex\n EEx.eval_file \"sample.ex\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L182",
:def,
182,
[ { :filename,
[ line: 182 ],
nil },
{ ://,
[ line: 182 ],
[ { :bindings,
[ line: 182 ],
nil },
[] ] },
{ ://,
[ line: 182 ],
[ { :options,
[ line: 182 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:eval_string,
3,
"eval_string/3",
"Get a string `source` and evaluate the values using the `bindings`.\n\n## Examples\n\n EEx.eval_string \"foo <%= bar %>\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L164",
:def,
164,
[ { :source,
[ line: 164 ],
nil },
{ ://,
[ line: 164 ],
[ { :bindings,
[ line: 164 ],
nil },
[] ] },
{ ://,
[ line: 164 ],
[ { :options,
[ line: 164 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:function_from_file,
5,
"function_from_file/5",
"Generates a function definition from the file contents.\nThe kind (`:def` or `:defp`) must be given, the\nfunction name, its arguments and the compilation options.\n\nThis function is useful in case you have templates but\nyou want to precompile inside a module for speed.\n\n## Examples\n\n # sample.eex\n <%= a + b %>\n\n # sample.ex\n defmodule Sample do\n require EEx\n EEx.function_from_file :def, :sample, \"sample.eex\", [:a, :b]\n end\n\n # iex\n Sample.sample(1, 2) #=> \"3\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L127",
:defmacro,
127,
[ { :kind,
[ line: 127 ],
nil },
{ :name,
[ line: 127 ],
nil },
{ :filename,
[ line: 127 ],
nil },
{ ://,
[ line: 127 ],
[ { :args,
[ line: 127 ],
nil },
[] ] },
{ ://,
[ line: 127 ],
[ { :options,
[ line: 127 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:function_from_string,
5,
"function_from_string/5",
"Generates a function definition from the string.\nThe kind (`:def` or `:defp`) must be given, the\nfunction name, its arguments and the compilation options.\n\n## Examples\n\n defmodule Sample do\n require EEx\n EEx.function_from_string :def, :sample, \"<%= a + b %>\", [:a, :b]\n end\n\n Sample.sample(1, 2) #=> \"3\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L95",
:defmacro,
95,
[ { :kind,
[ line: 95 ],
nil },
{ :name,
[ line: 95 ],
nil },
{ :source,
[ line: 95 ],
nil },
{ ://,
[ line: 95 ],
[ { :args,
[ line: 95 ],
nil },
[] ] },
{ ://,
[ line: 95 ],
[ { :options,
[ line: 95 ],
nil },
[] ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L3",
[],
nil,
"EEx",
3,
nil } },
{ ExDoc.ModuleNode,
EEx.Engine,
"Engine",
"This is the basic EEx engine that ships with Elixir.\nAn engine needs to implement two functions:\n\n* `handle_text(buffer, text)` - it receives the buffer,\n the text and must return a new quoted expression;\n\n* `handle_expr(buffer, marker, expr)` - it receives the buffer,\n the marker, the expr and must return a new quoted expression;\n\n The marker is what follows exactly after `<%`. For example,\n `<% foo %>` has an empty marker, but `<%= foo %>` has `'='`\n as marker. The allowed markers so far are:\n\n * `''`\n * `'='`\n\n Read `handle_expr/3` below for more information about the markers\n implemented by default by this engine.\n",
[ { ExDoc.FunctionNode,
:behaviour_info,
1,
"behaviour_info/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex/engine.ex#L53",
:def,
53,
[ { :atom1,
53,
:guess } ] },
{ ExDoc.FunctionNode,
:handle_expr,
3,
"handle_expr/3",
"Implements expressions according to the markers.\n\n <% Elixir expression - inline with output %>\n <%= Elixir expression - replace with result %>\n\nAll other markers are not implemented by this engine.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex/engine.ex#L38",
:def,
38,
[ { :buffer,
[ line: 38 ],
nil },
{ :list2,
38,
:guess },
{ :expr,
[ line: 38 ],
nil } ] },
{ ExDoc.FunctionNode,
:handle_text,
2,
"handle_text/2",
"The default implementation simply concatenates text to the buffer.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex/engine.ex#L26",
:def,
26,
[ { :buffer,
[ line: 26 ],
nil },
{ :text,
[ line: 26 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex/engine.ex#L1",
[],
nil,
"EEx.Engine",
1,
{ ExDoc.ModuleNode,
EEx,
"EEx",
"EEx stands for Embedded Elixir. It allows you to embed\nElixir code inside a string in a robust way:\n\n EEx.eval_string \"foo <%= bar %>\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n## API\n\nThis module provides 3 main APIs for you to use:\n\n1) Evaluate a string (`eval_string`) or a file (`eval_file`)\n directly. This is the simplest API to use but also the\n slowest, since the code is evaluated and not compiled before;\n\n2) Define a function from a string (`function_from_string`)\n or a file (`function_from_file`). This allows you to embed\n the template as a function inside a module which will then\n be compiled. This is the preferred API if you have access\n to the template at compilation time;\n\n3) Compile a string (`compile_string`) or a file (`compile_file`)\n into Elixir syntax tree. This is the API used by both functions\n above and is available to you if you want to provide your own\n ways of handling the compiled template.\n\n## Engine\n\nEEx has the concept of engines which allows you to modify or\ntransform the code extracted from the given string or file.\n\nBy default, `EEx` uses the `EEx.SmartEngine` that provides some\nconveniences on top of the simple `EEx.Engine`.\n\n### Tags\n\n`EEx.SmartEngine` supports the following tags:\n\n <% Elixir expression - inline with output %>\n <%= Elixir expression - replace with result %>\n <%% EEx quotation - returns the contents inside %>\n <%# Comments - they are discarded from source %>\n\nAll expressions that output something to the template\n**must** use the equals sign (`=`). Since everything in\nElixir is a macro, there are no exceptions for this rule.\nFor example, while some template languages would special-\ncase `if` clauses, they are treated the same in EEx and\nalso require `=` in order to have their result printed:\n\n <%= if true do %>\n It is obviously true\n <% else %>\n This will never appear\n <% end %>\n\nNotice that different engines may have different rules\nfor each tag. Other tags may be added in future versions.\n\n### Macros\n\n`EEx.SmartEngine` also adds some macros to your template.\nAn example is the `@` macro which allows easy data access\nin a template:\n\n EEx.eval_string \"<%= @foo %>\", assigns: [foo: 1]\n #=> 1\n\nIn other words, <%= @foo %> is simply translated to:\n\n <%= Keyword.get assigns, :foo %>\n\nThe assigns extension is useful when the number of variables\nrequired by the template is not specified at compilation time.\n",
[ { ExDoc.FunctionNode,
:compile_file,
2,
"compile_file/2",
"Get a `filename` and generate a quoted expression\nthat can be evaluated by Elixir or compiled to a function.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L150",
:def,
150,
[ { :filename,
[ line: 150 ],
nil },
{ ://,
[ line: 150 ],
[ { :options,
[ line: 150 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:compile_string,
2,
"compile_string/2",
"Get a string `source` and generate a quoted expression\nthat can be evaluated by Elixir or compiled to a function.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L142",
:def,
142,
[ { :source,
[ line: 142 ],
nil },
{ ://,
[ line: 142 ],
[ { :options,
[ line: 142 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:eval_file,
3,
"eval_file/3",
"Get a `filename` and evaluate the values using the `bindings`.\n\n## Examples\n\n # sample.ex\n foo <%= bar %>\n\n # iex\n EEx.eval_file \"sample.ex\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L182",
:def,
182,
[ { :filename,
[ line: 182 ],
nil },
{ ://,
[ line: 182 ],
[ { :bindings,
[ line: 182 ],
nil },
[] ] },
{ ://,
[ line: 182 ],
[ { :options,
[ line: 182 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:eval_string,
3,
"eval_string/3",
"Get a string `source` and evaluate the values using the `bindings`.\n\n## Examples\n\n EEx.eval_string \"foo <%= bar %>\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L164",
:def,
164,
[ { :source,
[ line: 164 ],
nil },
{ ://,
[ line: 164 ],
[ { :bindings,
[ line: 164 ],
nil },
[] ] },
{ ://,
[ line: 164 ],
[ { :options,
[ line: 164 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:function_from_file,
5,
"function_from_file/5",
"Generates a function definition from the file contents.\nThe kind (`:def` or `:defp`) must be given, the\nfunction name, its arguments and the compilation options.\n\nThis function is useful in case you have templates but\nyou want to precompile inside a module for speed.\n\n## Examples\n\n # sample.eex\n <%= a + b %>\n\n # sample.ex\n defmodule Sample do\n require EEx\n EEx.function_from_file :def, :sample, \"sample.eex\", [:a, :b]\n end\n\n # iex\n Sample.sample(1, 2) #=> \"3\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L127",
:defmacro,
127,
[ { :kind,
[ line: 127 ],
nil },
{ :name,
[ line: 127 ],
nil },
{ :filename,
[ line: 127 ],
nil },
{ ://,
[ line: 127 ],
[ { :args,
[ line: 127 ],
nil },
[] ] },
{ ://,
[ line: 127 ],
[ { :options,
[ line: 127 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:function_from_string,
5,
"function_from_string/5",
"Generates a function definition from the string.\nThe kind (`:def` or `:defp`) must be given, the\nfunction name, its arguments and the compilation options.\n\n## Examples\n\n defmodule Sample do\n require EEx\n EEx.function_from_string :def, :sample, \"<%= a + b %>\", [:a, :b]\n end\n\n Sample.sample(1, 2) #=> \"3\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L95",
:defmacro,
95,
[ { :kind,
[ line: 95 ],
nil },
{ :name,
[ line: 95 ],
nil },
{ :source,
[ line: 95 ],
nil },
{ ://,
[ line: 95 ],
[ { :args,
[ line: 95 ],
nil },
[] ] },
{ ://,
[ line: 95 ],
[ { :options,
[ line: 95 ],
nil },
[] ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L3",
[],
nil,
"EEx",
3,
nil } },
{ ExDoc.ModuleNode,
EEx.SmartEngine,
"SmartEngine",
"An engine meant for end-user usage that includes\n`AssignsEngine` and other conveniences. Read\n`EEx.AssignsEngine` for examples.\n",
[ { ExDoc.FunctionNode,
:handle_expr,
3,
"handle_expr/3",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex/smart_engine.ex#L89",
:def,
89,
[ { :buffer,
[ line: 89 ],
nil },
{ :mark,
[ line: 89 ],
nil },
{ :expr,
[ line: 89 ],
nil } ] },
{ ExDoc.FunctionNode,
:handle_text,
2,
"handle_text/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex/smart_engine.ex#L89",
:def,
89,
[ { :buffer,
[ line: 89 ],
nil },
{ :text,
[ line: 89 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex/smart_engine.ex#L88",
[],
nil,
"EEx.SmartEngine",
88,
{ ExDoc.ModuleNode,
EEx,
"EEx",
"EEx stands for Embedded Elixir. It allows you to embed\nElixir code inside a string in a robust way:\n\n EEx.eval_string \"foo <%= bar %>\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n## API\n\nThis module provides 3 main APIs for you to use:\n\n1) Evaluate a string (`eval_string`) or a file (`eval_file`)\n directly. This is the simplest API to use but also the\n slowest, since the code is evaluated and not compiled before;\n\n2) Define a function from a string (`function_from_string`)\n or a file (`function_from_file`). This allows you to embed\n the template as a function inside a module which will then\n be compiled. This is the preferred API if you have access\n to the template at compilation time;\n\n3) Compile a string (`compile_string`) or a file (`compile_file`)\n into Elixir syntax tree. This is the API used by both functions\n above and is available to you if you want to provide your own\n ways of handling the compiled template.\n\n## Engine\n\nEEx has the concept of engines which allows you to modify or\ntransform the code extracted from the given string or file.\n\nBy default, `EEx` uses the `EEx.SmartEngine` that provides some\nconveniences on top of the simple `EEx.Engine`.\n\n### Tags\n\n`EEx.SmartEngine` supports the following tags:\n\n <% Elixir expression - inline with output %>\n <%= Elixir expression - replace with result %>\n <%% EEx quotation - returns the contents inside %>\n <%# Comments - they are discarded from source %>\n\nAll expressions that output something to the template\n**must** use the equals sign (`=`). Since everything in\nElixir is a macro, there are no exceptions for this rule.\nFor example, while some template languages would special-\ncase `if` clauses, they are treated the same in EEx and\nalso require `=` in order to have their result printed:\n\n <%= if true do %>\n It is obviously true\n <% else %>\n This will never appear\n <% end %>\n\nNotice that different engines may have different rules\nfor each tag. Other tags may be added in future versions.\n\n### Macros\n\n`EEx.SmartEngine` also adds some macros to your template.\nAn example is the `@` macro which allows easy data access\nin a template:\n\n EEx.eval_string \"<%= @foo %>\", assigns: [foo: 1]\n #=> 1\n\nIn other words, <%= @foo %> is simply translated to:\n\n <%= Keyword.get assigns, :foo %>\n\nThe assigns extension is useful when the number of variables\nrequired by the template is not specified at compilation time.\n",
[ { ExDoc.FunctionNode,
:compile_file,
2,
"compile_file/2",
"Get a `filename` and generate a quoted expression\nthat can be evaluated by Elixir or compiled to a function.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L150",
:def,
150,
[ { :filename,
[ line: 150 ],
nil },
{ ://,
[ line: 150 ],
[ { :options,
[ line: 150 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:compile_string,
2,
"compile_string/2",
"Get a string `source` and generate a quoted expression\nthat can be evaluated by Elixir or compiled to a function.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L142",
:def,
142,
[ { :source,
[ line: 142 ],
nil },
{ ://,
[ line: 142 ],
[ { :options,
[ line: 142 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:eval_file,
3,
"eval_file/3",
"Get a `filename` and evaluate the values using the `bindings`.\n\n## Examples\n\n # sample.ex\n foo <%= bar %>\n\n # iex\n EEx.eval_file \"sample.ex\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L182",
:def,
182,
[ { :filename,
[ line: 182 ],
nil },
{ ://,
[ line: 182 ],
[ { :bindings,
[ line: 182 ],
nil },
[] ] },
{ ://,
[ line: 182 ],
[ { :options,
[ line: 182 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:eval_string,
3,
"eval_string/3",
"Get a string `source` and evaluate the values using the `bindings`.\n\n## Examples\n\n EEx.eval_string \"foo <%= bar %>\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L164",
:def,
164,
[ { :source,
[ line: 164 ],
nil },
{ ://,
[ line: 164 ],
[ { :bindings,
[ line: 164 ],
nil },
[] ] },
{ ://,
[ line: 164 ],
[ { :options,
[ line: 164 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:function_from_file,
5,
"function_from_file/5",
"Generates a function definition from the file contents.\nThe kind (`:def` or `:defp`) must be given, the\nfunction name, its arguments and the compilation options.\n\nThis function is useful in case you have templates but\nyou want to precompile inside a module for speed.\n\n## Examples\n\n # sample.eex\n <%= a + b %>\n\n # sample.ex\n defmodule Sample do\n require EEx\n EEx.function_from_file :def, :sample, \"sample.eex\", [:a, :b]\n end\n\n # iex\n Sample.sample(1, 2) #=> \"3\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L127",
:defmacro,
127,
[ { :kind,
[ line: 127 ],
nil },
{ :name,
[ line: 127 ],
nil },
{ :filename,
[ line: 127 ],
nil },
{ ://,
[ line: 127 ],
[ { :args,
[ line: 127 ],
nil },
[] ] },
{ ://,
[ line: 127 ],
[ { :options,
[ line: 127 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:function_from_string,
5,
"function_from_string/5",
"Generates a function definition from the string.\nThe kind (`:def` or `:defp`) must be given, the\nfunction name, its arguments and the compilation options.\n\n## Examples\n\n defmodule Sample do\n require EEx\n EEx.function_from_string :def, :sample, \"<%= a + b %>\", [:a, :b]\n end\n\n Sample.sample(1, 2) #=> \"3\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L95",
:defmacro,
95,
[ { :kind,
[ line: 95 ],
nil },
{ :name,
[ line: 95 ],
nil },
{ :source,
[ line: 95 ],
nil },
{ ://,
[ line: 95 ],
[ { :args,
[ line: 95 ],
nil },
[] ] },
{ ://,
[ line: 95 ],
[ { :options,
[ line: 95 ],
nil },
[] ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L3",
[],
nil,
"EEx",
3,
nil } },
{ ExDoc.ModuleNode,
EEx.TransformerEngine,
"TransformerEngine",
"An abstract engine that is meant to be used and\nbuilt upon in other modules. This engine implements\nthe `EEx.Engine` behavior and provides a `transform`\noverridable directive that allows a developer to\ncustomize the expression returned by the engine.\n\nCheck `EEx.AssignsEngine` and `EEx.SmartEngine` for\nexamples of using this module.\n",
[],
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex/smart_engine.ex#L1",
[],
nil,
"EEx.TransformerEngine",
1,
{ ExDoc.ModuleNode,
EEx,
"EEx",
"EEx stands for Embedded Elixir. It allows you to embed\nElixir code inside a string in a robust way:\n\n EEx.eval_string \"foo <%= bar %>\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n## API\n\nThis module provides 3 main APIs for you to use:\n\n1) Evaluate a string (`eval_string`) or a file (`eval_file`)\n directly. This is the simplest API to use but also the\n slowest, since the code is evaluated and not compiled before;\n\n2) Define a function from a string (`function_from_string`)\n or a file (`function_from_file`). This allows you to embed\n the template as a function inside a module which will then\n be compiled. This is the preferred API if you have access\n to the template at compilation time;\n\n3) Compile a string (`compile_string`) or a file (`compile_file`)\n into Elixir syntax tree. This is the API used by both functions\n above and is available to you if you want to provide your own\n ways of handling the compiled template.\n\n## Engine\n\nEEx has the concept of engines which allows you to modify or\ntransform the code extracted from the given string or file.\n\nBy default, `EEx` uses the `EEx.SmartEngine` that provides some\nconveniences on top of the simple `EEx.Engine`.\n\n### Tags\n\n`EEx.SmartEngine` supports the following tags:\n\n <% Elixir expression - inline with output %>\n <%= Elixir expression - replace with result %>\n <%% EEx quotation - returns the contents inside %>\n <%# Comments - they are discarded from source %>\n\nAll expressions that output something to the template\n**must** use the equals sign (`=`). Since everything in\nElixir is a macro, there are no exceptions for this rule.\nFor example, while some template languages would special-\ncase `if` clauses, they are treated the same in EEx and\nalso require `=` in order to have their result printed:\n\n <%= if true do %>\n It is obviously true\n <% else %>\n This will never appear\n <% end %>\n\nNotice that different engines may have different rules\nfor each tag. Other tags may be added in future versions.\n\n### Macros\n\n`EEx.SmartEngine` also adds some macros to your template.\nAn example is the `@` macro which allows easy data access\nin a template:\n\n EEx.eval_string \"<%= @foo %>\", assigns: [foo: 1]\n #=> 1\n\nIn other words, <%= @foo %> is simply translated to:\n\n <%= Keyword.get assigns, :foo %>\n\nThe assigns extension is useful when the number of variables\nrequired by the template is not specified at compilation time.\n",
[ { ExDoc.FunctionNode,
:compile_file,
2,
"compile_file/2",
"Get a `filename` and generate a quoted expression\nthat can be evaluated by Elixir or compiled to a function.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L150",
:def,
150,
[ { :filename,
[ line: 150 ],
nil },
{ ://,
[ line: 150 ],
[ { :options,
[ line: 150 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:compile_string,
2,
"compile_string/2",
"Get a string `source` and generate a quoted expression\nthat can be evaluated by Elixir or compiled to a function.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L142",
:def,
142,
[ { :source,
[ line: 142 ],
nil },
{ ://,
[ line: 142 ],
[ { :options,
[ line: 142 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:eval_file,
3,
"eval_file/3",
"Get a `filename` and evaluate the values using the `bindings`.\n\n## Examples\n\n # sample.ex\n foo <%= bar %>\n\n # iex\n EEx.eval_file \"sample.ex\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L182",
:def,
182,
[ { :filename,
[ line: 182 ],
nil },
{ ://,
[ line: 182 ],
[ { :bindings,
[ line: 182 ],
nil },
[] ] },
{ ://,
[ line: 182 ],
[ { :options,
[ line: 182 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:eval_string,
3,
"eval_string/3",
"Get a string `source` and evaluate the values using the `bindings`.\n\n## Examples\n\n EEx.eval_string \"foo <%= bar %>\", [bar: \"baz\"]\n #=> \"foo baz\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L164",
:def,
164,
[ { :source,
[ line: 164 ],
nil },
{ ://,
[ line: 164 ],
[ { :bindings,
[ line: 164 ],
nil },
[] ] },
{ ://,
[ line: 164 ],
[ { :options,
[ line: 164 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:function_from_file,
5,
"function_from_file/5",
"Generates a function definition from the file contents.\nThe kind (`:def` or `:defp`) must be given, the\nfunction name, its arguments and the compilation options.\n\nThis function is useful in case you have templates but\nyou want to precompile inside a module for speed.\n\n## Examples\n\n # sample.eex\n <%= a + b %>\n\n # sample.ex\n defmodule Sample do\n require EEx\n EEx.function_from_file :def, :sample, \"sample.eex\", [:a, :b]\n end\n\n # iex\n Sample.sample(1, 2) #=> \"3\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L127",
:defmacro,
127,
[ { :kind,
[ line: 127 ],
nil },
{ :name,
[ line: 127 ],
nil },
{ :filename,
[ line: 127 ],
nil },
{ ://,
[ line: 127 ],
[ { :args,
[ line: 127 ],
nil },
[] ] },
{ ://,
[ line: 127 ],
[ { :options,
[ line: 127 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:function_from_string,
5,
"function_from_string/5",
"Generates a function definition from the string.\nThe kind (`:def` or `:defp`) must be given, the\nfunction name, its arguments and the compilation options.\n\n## Examples\n\n defmodule Sample do\n require EEx\n EEx.function_from_string :def, :sample, \"<%= a + b %>\", [:a, :b]\n end\n\n Sample.sample(1, 2) #=> \"3\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L95",
:defmacro,
95,
[ { :kind,
[ line: 95 ],
nil },
{ :name,
[ line: 95 ],
nil },
{ :source,
[ line: 95 ],
nil },
{ ://,
[ line: 95 ],
[ { :args,
[ line: 95 ],
nil },
[] ] },
{ ://,
[ line: 95 ],
[ { :options,
[ line: 95 ],
nil },
[] ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/eex/lib/eex.ex#L3",
[],
nil,
"EEx",
3,
nil } } ],
nil,
"EEx",
3,
nil },
{ ExDoc.ModuleNode,
Enum,
"Enum",
"Provides a set of algorithms that enumerate over collections according to the\n`Enum.Iterator` protocol. Most of the functions in this module have two\nflavours. If a given collection implements the mentioned protocol (like\nlist, for instance), you can do:\n\n Enum.map([1,2,3], fn(x) -> x * 2 end)\n\nDepending on the type of the collection, the user-provided function will\naccept a certain type of argument. For dicts, the argument is always a\n`{ key, value }` tuple.\n",
[ { ExDoc.FunctionNode,
:all?,
2,
"all?/2",
"Invokes the given `fun` for each item in the `collection` and returns true if\neach invocation returns true as well, otherwise it short-circuits and returns\nfalse.\n\n## Examples\n\n iex> Enum.all?([2,4,6], fn(x) -> rem(x, 2) == 0 end)\n true\n\n iex> Enum.all?([2,3,4], fn(x) -> rem(x, 2) == 0 end)\n false\n\nIf no function is given, it defaults to checking if\nall items in the collection evaluate to true.\n\n iex> Enum.all?([1,2,3])\n true\n iex> Enum.all?([1,nil,3])\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L177",
:def,
177,
[ { :collection,
[ line: 177 ],
nil },
{ ://,
[ line: 177 ],
[ { :fun,
[ line: 177 ],
nil },
{ :fn,
[ line: 177 ],
[ [ do: { :"->",
[ line: 177 ],
[ { [ { :x,
[ line: 177 ],
nil } ],
{ :x,
[ line: 177 ],
nil } } ] } ] ] } ] } ] },
{ ExDoc.FunctionNode,
:any?,
2,
"any?/2",
"Invokes the given `fun` for each item in the `collection` and returns true if\nat least one invocation returns true. Returns false otherwise.\n\n## Examples\n\n iex> Enum.any?([2,4,6], fn(x) -> rem(x, 2) == 1 end)\n false\n\n iex> Enum.any?([2,3,4], fn(x) -> rem(x, 2) == 1 end)\n true\n\nIf no function is given, it defaults to checking if\nat least one item in the collection evaluates to true.\n\n iex> Enum.any?([false,false,false])\n false\n iex> Enum.any?([false,true,false])\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L216",
:def,
216,
[ { :collection,
[ line: 216 ],
nil },
{ ://,
[ line: 216 ],
[ { :fun,
[ line: 216 ],
nil },
{ :fn,
[ line: 216 ],
[ [ do: { :"->",
[ line: 216 ],
[ { [ { :x,
[ line: 216 ],
nil } ],
{ :x,
[ line: 216 ],
nil } } ] } ] ] } ] } ] },
{ ExDoc.FunctionNode,
:at!,
2,
"at!/2",
"Finds the element at the given index (zero-based).\nRaises out of bounds error in case the given position\nis outside the range of the collection.\n\nExpects an ordered collection.\n\n ## Examples\n\n iex> Enum.at!([2,4,6], 0)\n 2\n iex> Enum.at!([2,4,6], 2)\n 6\n iex> Enum.at!([2,4,6], 4)\n ** (Enum.OutOfBoundsError) out of bounds error\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L249",
:def,
249,
[ { :collection,
[ line: 249 ],
nil },
{ :n,
[ line: 249 ],
nil } ] },
{ ExDoc.FunctionNode,
:count,
1,
"count/1",
"Returns the collection size.\n\n## Examples\n\n iex> Enum.count([1,2,3])\n 3\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L131",
:def,
131,
[ { :collection,
[ line: 131 ],
nil } ] },
{ ExDoc.FunctionNode,
:count,
2,
"count/2",
"Counts for how many items the function returns true.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L139",
:def,
139,
[ { :collection,
[ line: 139 ],
nil },
{ :fun,
[ line: 139 ],
nil } ] },
{ ExDoc.FunctionNode,
:drop,
2,
"drop/2",
"Drops the first `count` items from the collection.\nExpects an ordered collection.\n\n## Examples\n\n iex> Enum.drop([1,2,3], 2)\n [3]\n iex> Enum.drop([1,2,3], 10)\n []\n iex> Enum.drop([1,2,3], 0)\n [1,2,3]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L277",
:def,
277,
[ { :collection,
[ line: 277 ],
nil },
{ :count,
[ line: 277 ],
nil } ] },
{ ExDoc.FunctionNode,
:drop_while,
2,
"drop_while/2",
"Drops items at the beginning of `collection` while `fun` returns true.\nExpects an ordered collection.\n\n## Examples\n\n iex> Enum.drop_while([1,2,3,4,5], fn(x) -> x < 3 end)\n [3,4,5]\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L305",
:def,
305,
[ { :collection,
[ line: 305 ],
nil },
{ :fun,
[ line: 305 ],
nil } ] },
{ ExDoc.FunctionNode,
:each,
2,
"each/2",
"Invokes the given `fun` for each item in the `collection`.\nReturns the `collection` itself. `fun` can take two parameters,\nin which case the second parameter will be the iteration index.\n\n## Examples\n\n Enum.each(['some', 'example'], fn(x) -> IO.puts x end)\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L329",
:def,
329,
[ { :collection,
[ line: 329 ],
nil },
{ :fun,
[ line: 329 ],
nil } ] },
{ ExDoc.FunctionNode,
:empty?,
1,
"empty?/1",
"Returns true if the `collection` is empty, otherwise false.\n\n## Examples\n\n iex> Enum.empty?([])\n true\n iex> Enum.empty?([1,2,3])\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L101",
:def,
101,
[ { :collection,
[ line: 101 ],
nil } ] },
{ ExDoc.FunctionNode,
:equal?,
2,
"equal?/2",
"Returns true if the first collection is equal to the second, every element in\nboth collections is iterated through, as soon as an element differs, it\nreturns false.\n\n## Examples\n\n iex> Enum.equal?([], [])\n true\n iex> Enum.equal?(1 .. 3, [1, 2, 3])\n true\n iex> Enum.equal?(1 .. 3, [])\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L368",
:def,
368,
[ { :a,
[ line: 368 ],
nil },
{ :b,
[ line: 368 ],
nil } ] },
{ ExDoc.FunctionNode,
:equal?,
3,
"equal?/3",
"Returns true if the first collection is equal to the second, every element in\nboth collections is iterated through and compared with the passed function,\nas soon as an element differs, it returns false.\n\nPlease note that the first parameter passed to the compare function isn't\nensured to be an element from the first collection.\n\n## Examples\n\n iex> Enum.equal?([], [], &1 === &2)\n true\n iex> Enum.equal?([1 .. 3], [[1, 2, 3]], Enum.equal?(&1, &2))\n true\n iex> Enum.equal?(1 .. 3, [1.0, 2.0, 3.0], &1 === &2)\n false\n iex> Enum.equal?(1 .. 3, [], &1 === &2)\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L426",
:def,
426,
[ { :a,
[ line: 430 ],
nil },
{ :b,
[ line: 430 ],
nil },
{ :fun,
[ line: 434 ],
nil } ] },
{ ExDoc.FunctionNode,
:filter,
2,
"filter/2",
"Filters the collection, i.e. returns only those elements\nfor which `fun` returns true.\n\n## Examples\n\n iex> Enum.filter([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)\n [2]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L482",
:def,
482,
[ { :collection,
[ line: 482 ],
nil },
{ :fun,
[ line: 482 ],
nil } ] },
{ ExDoc.FunctionNode,
:filter_map,
3,
"filter_map/3",
"Filters the collection and maps its values in one pass.\n\n## Examples\n\n iex> Enum.filter_map([1, 2, 3], fn(x) -> rem(x, 2) == 0 end, &1 * 2)\n [4]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L505",
:def,
505,
[ { :collection,
[ line: 505 ],
nil },
{ :filter,
[ line: 505 ],
nil },
{ :mapper,
[ line: 505 ],
nil } ] },
{ ExDoc.FunctionNode,
:find,
3,
"find/3",
"Returns the first item for which `fun` returns a truthy value. If no such\nitem is found, returns `ifnone`.\n\n## Examples\n\n iex> Enum.find([2,4,6], fn(x) -> rem(x, 2) == 1 end)\n nil\n\n iex> Enum.find([2,4,6], 0, fn(x) -> rem(x, 2) == 1 end)\n 0\n\n iex> Enum.find([2,3,4], fn(x) -> rem(x, 2) == 1 end)\n 3\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L537",
:def,
537,
[ { :collection,
[ line: 537 ],
nil },
{ ://,
[ line: 537 ],
[ { :ifnone,
[ line: 537 ],
nil },
nil ] },
{ :fun,
[ line: 537 ],
nil } ] },
{ ExDoc.FunctionNode,
:find_index,
2,
"find_index/2",
"Similar to find, but returns the index (count starts with 0)\nof the item instead of the element itself.\n\nExpects an ordered collection.\n\n## Examples\n\n iex> Enum.find_index([2,4,6], fn(x) -> rem(x, 2) == 1 end)\n nil\n\n iex> Enum.find_index([2,3,4], fn(x) -> rem(x, 2) == 1 end)\n 1\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L599",
:def,
599,
[ { :collection,
[ line: 599 ],
nil },
{ :fun,
[ line: 599 ],
nil } ] },
{ ExDoc.FunctionNode,
:find_value,
3,
"find_value/3",
"Similar to find, but returns the value of the function\ninvocation instead of the element itself.\n\n## Examples\n\n iex> Enum.find_value([2,4,6], fn(x) -> rem(x, 2) == 1 end)\n nil\n\n iex> Enum.find_value([2,3,4], fn(x) -> rem(x, 2) == 1 end)\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L568",
:def,
568,
[ { :collection,
[ line: 568 ],
nil },
{ ://,
[ line: 568 ],
[ { :ifnone,
[ line: 568 ],
nil },
nil ] },
{ :fun,
[ line: 568 ],
nil } ] },
{ ExDoc.FunctionNode,
:first,
1,
"first/1",
"Returns the first item in the collection or nil otherwise.\n\n## Examples\n\n iex> Enum.first([])\n nil\n iex> Enum.first([1,2,3])\n 1\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L624",
:def,
624,
[ { :collection,
[ line: 627 ],
nil } ] },
{ ExDoc.FunctionNode,
:join,
2,
"join/2",
"Joins the given `collection` according to `joiner`.\nJoiner can be either a binary or a list and the\nresult will be of the same type as joiner. If\njoiner is not passed at all, it defaults to an\nempty binary.\n\nAll items in the collection must be convertible\nto binary, otherwise an error is raised.\n\n## Examples\n\n iex> Enum.join([1,2,3])\n \"123\"\n iex> Enum.join([1,2,3], \" = \")\n \"1 = 2 = 3\"\n iex> Enum.join([1,2,3], ' = ')\n '1 = 2 = 3'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L657",
:def,
657,
[ { :collection,
[ line: 657 ],
nil },
{ ://,
[ line: 657 ],
[ { :joiner,
[ line: 657 ],
nil },
"" ] } ] },
{ ExDoc.FunctionNode,
:map,
2,
"map/2",
"Returns a new collection, where each item is the result\nof invoking `fun` on each corresponding item of `collection`.\n`fun` can take two parameters, in which case the second parameter\nwill be the iteration index.\n\nFor dicts, the function accepts a key-value tuple.\n\n## Examples\n\n iex> Enum.map([1, 2, 3], fn(x) -> x * 2 end)\n [2, 4, 6]\n\n iex> Enum.map([a: 1, b: 2], fn({k, v}) -> { k, -v } end)\n [a: -1, b: -2]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L694",
:def,
694,
[ { :collection,
[ line: 694 ],
nil },
{ :fun,
[ line: 694 ],
nil } ] },
{ ExDoc.FunctionNode,
:map_join,
3,
"map_join/3",
"Maps and joins the given `collection` in one pass.\nJoiner can be either a binary or a list and the\nresult will be of the same type as joiner. If\njoiner is not passed at all, it defaults to an\nempty binary.\n\nAll items in the collection must be convertible\nto binary, otherwise an error is raised.\n\n## Examples\n\n iex> Enum.map_join([1,2,3], &1 * 2)\n \"246\"\n iex> Enum.map_join([1,2,3], \" = \", &1 * 2)\n \"2 = 4 = 6\"\n iex> Enum.map_join([1,2,3], ' = ', &1 * 2)\n '2 = 4 = 6'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L735",
:def,
735,
[ { :collection,
[ line: 735 ],
nil },
{ ://,
[ line: 735 ],
[ { :joiner,
[ line: 735 ],
nil },
"" ] },
{ :mapper,
[ line: 735 ],
nil } ] },
{ ExDoc.FunctionNode,
:map_reduce,
3,
"map_reduce/3",
"Invokes the given `fun` for each item in the `collection`\nwhile also keeping an accumulator. Returns a tuple where\nthe first element is the mapped collection and the second\none is the final accumulator.\n\nFor dicts, the first tuple element has to be a { key, value }\ntuple itself.\n\n## Examples\n\n iex> Enum.map_reduce([1, 2, 3], 0, fn(x, acc) -> { x * 2, x + acc } end)\n { [2, 4, 6], 6 }\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L770",
:def,
770,
[ { :collection,
[ line: 770 ],
nil },
{ :acc,
[ line: 770 ],
nil },
{ :f,
[ line: 770 ],
nil } ] },
{ ExDoc.FunctionNode,
:max,
1,
"max/1",
"Returns the maximum value.\nRaises empty error in case the collection is empty.\n\n## Examples\n\n iex> Enum.max([1,2,3])\n 3\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L1114",
:def,
1114,
[ { :collection,
[ line: 1114 ],
nil } ] },
{ ExDoc.FunctionNode,
:max,
2,
"max/2",
"Returns the maximum value.\nRaises empty error in case the collection is empty.\n\n## Examples\n\n iex> Enum.max([\"a\", \"aa\", \"aaa\"], fn(x) -> String.length(x) end)\n \"aaa\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L1140",
:def,
1140,
[ { :collection,
[ line: 1140 ],
nil },
{ :fun,
[ line: 1140 ],
nil } ] },
{ ExDoc.FunctionNode,
:member?,
2,
"member?/2",
"Checks if the `value` exists within the `collection`.\n\n## Examples\n\n iex> Enum.member?(1..10, 5)\n true\n iex> Enum.member?([:a, :b, :c], :d)\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L117",
:def,
117,
[ { :collection,
[ line: 117 ],
nil },
{ :value,
[ line: 117 ],
nil } ] },
{ ExDoc.FunctionNode,
:min,
1,
"min/1",
"Returns the manimum value.\nRaises empty error in case the collection is empty.\n\n## Examples\n\n iex> Enum.min([1,2,3])\n 1\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L1164",
:def,
1164,
[ { :collection,
[ line: 1164 ],
nil } ] },
{ ExDoc.FunctionNode,
:min,
2,
"min/2",
"Returns the manimum value.\nRaises empty error in case the collection is empty.\n\n## Examples\n\n iex> Enum.min([\"a\", \"aa\", \"aaa\"], fn(x) -> String.length(x) end)\n \"a\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L1189",
:def,
1189,
[ { :collection,
[ line: 1189 ],
nil },
{ :fun,
[ line: 1189 ],
nil } ] },
{ ExDoc.FunctionNode,
:partition,
2,
"partition/2",
"Partitions `collection` into two where the first one contains elements\nfor which `fun` returns a truthy value, and the second one -- for which `fun`\nreturns false or nil.\n\n## Examples\n\n iex> Enum.partition([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)\n { [2], [1,3] }\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L795",
:def,
795,
[ { :collection,
[ line: 795 ],
nil },
{ :fun,
[ line: 795 ],
nil } ] },
{ ExDoc.FunctionNode,
:reduce,
3,
"reduce/3",
"Invokes `fun` for each element in the collection passing that element and the\naccumulator `acc` as arguments. `fun`'s return value is stored in `acc`.\nReturns the accumulator.\n\n## Examples\n\n iex> Enum.reduce([1, 2, 3], 0, fn(x, acc) -> x + acc end)\n 6\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L820",
:def,
820,
[ { :collection,
[ line: 820 ],
nil },
{ :acc,
[ line: 820 ],
nil },
{ :fun,
[ line: 820 ],
nil } ] },
{ ExDoc.FunctionNode,
:reverse,
1,
"reverse/1",
"Reverses the collection.\n\n## Examples\n\n iex> Enum.reverse([1, 2, 3])\n [3, 2, 1]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L843",
:def,
843,
[ { :collection,
[ line: 843 ],
nil } ] },
{ ExDoc.FunctionNode,
:sort,
1,
"sort/1",
"Returns a sorted list of collection elements. Uses the merge sort algorithm.\n\n## Examples\n\n iex> Enum.sort([3,2,1])\n [1,2,3]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L864",
:def,
864,
[ { :collection,
[ line: 864 ],
nil } ] },
{ ExDoc.FunctionNode,
:sort,
2,
"sort/2",
"Returns a sorted list of collection elements. Uses the merge sort algorithm.\n\n## Examples\n\n iex> Enum.sort([1,2,3], &1 > &2)\n [3,2,1]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L887",
:def,
887,
[ { :collection,
[ line: 887 ],
nil },
{ :fun,
[ line: 887 ],
nil } ] },
{ ExDoc.FunctionNode,
:split,
2,
"split/2",
"Splits the enumerable into two collections, leaving `count`\nelements in the first one. If `count` is a negative number,\nit starts couting from the back to the beginning of the\ncollection.\n\nBe aware that a negative `count` implies the collection\nwill be iterate twice. One to calculate the position and\nanother one to do the actual splitting.\n\n## Examples\n\n iex> Enum.split([1,2,3], 2)\n { [1,2], [3] }\n iex> Enum.split([1,2,3], 10)\n { [1,2,3], [] }\n iex> Enum.split([1,2,3], 0)\n { [], [1,2,3] }\n iex> Enum.split([1,2,3], -1)\n { [1,2], [3] }\n iex> Enum.split([1,2,3], -5)\n { [], [1,2,3] }\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L925",
:def,
925,
[ { :collection,
[ line: 925 ],
nil },
{ :count,
[ line: 925 ],
nil } ] },
{ ExDoc.FunctionNode,
:split_while,
2,
"split_while/2",
"Splits `collection` in two while `fun` returns true.\n\n## Examples\n\n iex> Enum.split_while([1,2,3,4], fn(x) -> x < 3 end)\n { [1, 2], [3, 4] }\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L952",
:def,
952,
[ { :collection,
[ line: 952 ],
nil },
{ :fun,
[ line: 952 ],
nil } ] },
{ ExDoc.FunctionNode,
:take,
2,
"take/2",
"Takes the first `count` items from the collection. Expects an ordered\ncollection.\n\n## Examples\n\n iex> Enum.take([1,2,3], 2)\n [1,2]\n iex> Enum.take([1,2,3], 10)\n [1,2,3]\n iex> Enum.take([1,2,3], 0)\n []\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L981",
:def,
981,
[ { :collection,
[ line: 985 ],
nil },
{ :count,
[ line: 985 ],
nil } ] },
{ ExDoc.FunctionNode,
:take_while,
2,
"take_while/2",
"Takes the items at the beginning of `collection` while `fun` returns true.\nExpects an ordered collection.\n\n## Examples\n\n iex> Enum.take_while([1,2,3], fn(x) -> x < 3 end)\n [1, 2]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L1014",
:def,
1014,
[ { :collection,
[ line: 1014 ],
nil },
{ :fun,
[ line: 1014 ],
nil } ] },
{ ExDoc.FunctionNode,
:to_list,
1,
"to_list/1",
"Convert `collection` to a list.\n\n## Examples\n\n iex> Enum.to_list(1 .. 3)\n [1, 2, 3]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L1037",
:def,
1037,
[ { :collection,
[ line: 1037 ],
nil } ] },
{ ExDoc.FunctionNode,
:uniq,
2,
"uniq/2",
"Iterates the enumerable removing all duplicated items.\n\n## Examples\n\n iex> Enum.uniq([1,2,3,2,1])\n [1, 2, 3]\n\n iex> Enum.uniq([{1,:x}, {2,:y}, {1,:z}], fn {x,_} -> x end)\n [{1,:x}, {2,:y}]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L1068",
:def,
1068,
[ { :collection,
[ line: 1068 ],
nil },
{ ://,
[ line: 1068 ],
[ { :fun,
[ line: 1068 ],
nil },
{ :fn,
[ line: 1068 ],
[ [ do: { :"->",
[ line: 1068 ],
[ { [ { :x,
[ line: 1068 ],
nil } ],
{ :x,
[ line: 1068 ],
nil } } ] } ] ] } ] } ] },
{ ExDoc.FunctionNode,
:zip,
2,
"zip/2",
"Zips corresponding elements from two collections into one list\nof tuples. The number of elements in the resulting list is\ndictated by the first enum. In case the second list is shorter,\nvalues are filled with nil.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L1090",
:def,
1090,
[ { :coll1,
[ line: 1090 ],
nil },
{ :coll2,
[ line: 1090 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L67",
[],
nil,
"Enum",
67,
nil },
{ ExDoc.ModuleNode,
ExUnit,
"ExUnit",
"Basic unit test structure for Elixir.\n\n## Example\n\nA basic setup for ExUnit is shown below:\n\n # File: assertion_test.exs\n\n # 1) Start ExUnit. You can pass some options as argument (list below)\n ExUnit.start\n\n # 2) Next we create a new TestCase and use ExUnit.Case\n defmodule AssertionTest do\n # 3) Notice we pass async: true, this runs the test case\n # concurrently with other test cases\n use ExUnit.Case, async: true\n\n # 4) A test is a function whose name starts with\n # test and receives a context\n def test_always_pass(_) do\n assert true\n end\n\n # 5) It is recommended to use the test macro instead of def\n test \"the truth\" do\n assert true\n end\n end\n\nTo run the test above, all you need to to is to run the file\nusing elixir from command line. Assuming you named your file\nassertion_test.exs, you can run it as:\n\n bin/elixir assertion_test.exs\n\n## Case, callbacks and assertions\n\nCheck `ExUnit.Case` and `ExUnit.Callbacks` for more information about\ndefining test cases.\n\nThe `ExUnit.Assertions` module contains a set of macros to easily\ngenerate assertions with appropriate error messages.\n\n",
[ { ExDoc.FunctionNode,
:configure,
1,
"configure/1",
"Configures ExUnit.\n\n## Options\n\nExUnit supports the following options given to start:\n\n* `:formatter` - The formatter that will print results.\n Defaults to `ExUnit.CLIFormatter`;\n\n* `:max_cases` - Maximum number of cases to run in parallel.\n Defaults to `:erlang.system_info(:schedulers_online)`;\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L102",
:def,
102,
[ { :options,
[ line: 102 ],
nil } ] },
{ ExDoc.FunctionNode,
:run,
0,
"run/0",
"API used to run the tests. It is invoked automatically\nif ExUnit is started via `ExUnit.start`.\n\nReturns the number of failures.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L112",
:def,
112,
[] },
{ ExDoc.FunctionNode,
:start,
1,
"start/1",
"Starts up ExUnit and automatically set it up to run\ntests at the VM exit. It accepts a set of options to\nconfigure `ExUnit` (the same ones accepted by `configure/1`).\n\nIn case you want to run tests manually, skip calling this\nfunction and rely on `configure/1` and `run/0` instead.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L71",
:def,
71,
[ { ://,
[ line: 71 ],
[ { :options,
[ line: 71 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:stop,
1,
"stop/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L98",
:def,
98,
[ { :_state,
[ line: 98 ],
:guess } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L1",
[ { ExDoc.ModuleNode,
ExUnit.Assertions,
"Assertions",
"This module contains a set of assertions functions that are\nimported by default into your test cases.\n\nIn general, a developer will want to use the general\n`assert` macro in tests. The macro tries to be smart\nand provide good reporting whenever there is a failure.\nFor example, `assert some_fun() == 10` will fail (assuming\n`some_fun()` returns 13):\n\n Expected 10 to be equal to 13\n\nThis module also provides other small convenient functions\nlike `assert_in_delta` and `assert_raise` to easily handle other\ncommon cases as checking a float number or handling exceptions.\n",
[ { ExDoc.FunctionNode,
:assert,
1,
"assert/1",
"Asserts the `expected` value is true.\n\n`assert` in general tries to be smart and provide a good\nreporting whenever there is a failure. For example,\n`assert 10 > 15` is going to fail with a message:\n\n Expected 10 to be more than 15\n\n## Examples\n\n assert true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L52",
:defmacro,
52,
[ { :expected,
[ line: 52 ],
nil } ] },
{ ExDoc.FunctionNode,
:assert,
2,
"assert/2",
"Asserts the `expected` value is true.\nIf it fails, raises the given `message`.\n\n## Examples\n\n assert false, \"it will never be true\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L223",
:def,
223,
[ { :expected,
[ line: 223 ],
nil },
{ :message,
[ line: 223 ],
nil } ] },
{ ExDoc.FunctionNode,
:assert,
4,
"assert/4",
"Asserts the `expected` value is true.\nIf it fails, it raises an expectation error\nusing the given expected and actual values.\n\n## Examples\n\n assert this > that, this, that, reason: \"more than\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L238",
:def,
238,
[ { :value,
[ line: 238 ],
nil },
{ :expected,
[ line: 238 ],
nil },
{ :actual,
[ line: 238 ],
nil },
{ :opts,
[ line: 238 ],
nil } ] },
{ ExDoc.FunctionNode,
:assert_in_delta,
4,
"assert_in_delta/4",
"Asserts the `expected` and `received` are within `delta`.\n\n## Examples\n\n assert_in_delta 1.1, 1.5, 0.2\n assert_in_delta 10, 15, 4\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L357",
:def,
357,
[ { :expected,
[ line: 357 ],
nil },
{ :received,
[ line: 357 ],
nil },
{ :delta,
[ line: 357 ],
nil },
{ ://,
[ line: 357 ],
[ { :message,
[ line: 357 ],
nil },
nil ] } ] },
{ ExDoc.FunctionNode,
:assert_raise,
2,
"assert_raise/2",
"Asserts the `exception` is raised during `function` execution.\nReturns the rescued exception, fails otherwise.\n\n## Examples\n\n assert_raise ArithmeticError, fn ->\n 1 + \"test\"\n end\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L331",
:def,
331,
[ { :exception,
[ line: 331 ],
nil },
{ :function,
[ line: 331 ],
nil } ] },
{ ExDoc.FunctionNode,
:assert_raise,
3,
"assert_raise/3",
"Asserts the `exception` is raised during `function` execution with\nthe `expected_message`. Returns the rescued exception, fails otherwise.\n\n## Examples\n\n assert_raise ArithmeticError, \"bad argument in arithmetic expression\", fn ->\n 1 + \"test\"\n end\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L313",
:def,
313,
[ { :exception,
[ line: 313 ],
nil },
{ :message,
[ line: 313 ],
nil },
{ :function,
[ line: 313 ],
nil } ] },
{ ExDoc.FunctionNode,
:assert_receive,
3,
"assert_receive/3",
"Assets a message was or is going to be received. Differently from\n`assert_received`, it has a default timeout time of 100 miliseconds.\n\nThe given `expected` content must be a pattern.\n\n## Examples\n\n assert_receive :hello\n\nAsserts against a larger timeout:\n\n assert_receive :hello, 20_000\n\nYou can also match against specific patterns:\n\n assert_receive { :hello, _ }\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L265",
:defmacro,
265,
[ { :expected,
[ line: 265 ],
nil },
{ ://,
[ line: 265 ],
[ { :timeout,
[ line: 265 ],
nil },
100 ] },
{ ://,
[ line: 265 ],
[ { :message,
[ line: 265 ],
nil },
nil ] } ] },
{ ExDoc.FunctionNode,
:assert_received,
2,
"assert_received/2",
"Asserts a message was received and is in the current process mailbox.\nThe given `expected` content must to be a match pattern.\n\nTimeout is set to 0, so there is no waiting time.\n\n## Examples\n\n self <- :hello\n assert_received :hello\n\nYou can also match against specific patterns:\n\n self <- { :hello, \"world\" }\n assert_received { :hello, _ }\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L286",
:defmacro,
286,
[ { :expected,
[ line: 286 ],
nil },
{ ://,
[ line: 286 ],
[ { :message,
[ line: 286 ],
nil },
nil ] } ] },
{ ExDoc.FunctionNode,
:catch_error,
1,
"catch_error/1",
"Asserts the given `expression` will cause an error.\nReturns the error or fails otherwise.\n\n## Examples\n\n assert catch_error(error 1) == 1\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L399",
:defmacro,
399,
[ { :expression,
[ line: 399 ],
nil } ] },
{ ExDoc.FunctionNode,
:catch_exit,
1,
"catch_exit/1",
"Asserts the given `expression` will exit.\nReturns the exit status/message or fails otherwise.\n\n## Examples\n\n assert catch_exit(exit 1) == 1\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L386",
:defmacro,
386,
[ { :expression,
[ line: 386 ],
nil } ] },
{ ExDoc.FunctionNode,
:catch_throw,
1,
"catch_throw/1",
"Asserts the given `expression` will throw a value.\nReturns the thrown value or fails otherwise.\n\n## Examples\n\n assert catch_throw(throw 1) == 1\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L373",
:defmacro,
373,
[ { :expression,
[ line: 373 ],
nil } ] },
{ ExDoc.FunctionNode,
:flunk,
1,
"flunk/1",
"Fails with a message.\n\n## Examples\n\n flunk \"This should raise an error\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L503",
:def,
503,
[ { ://,
[ line: 503 ],
[ { :message,
[ line: 503 ],
nil },
"Epic Fail!" ] } ] },
{ ExDoc.FunctionNode,
:refute,
1,
"refute/1",
"Refutes the `expected` value is true.\n\n`refute` in general tries to be smart and provide a good\nreporting whenever there is a failure.\n\n## Examples\n\n refute false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L72",
:defmacro,
72,
[ { :expected,
[ line: 72 ],
nil } ] },
{ ExDoc.FunctionNode,
:refute,
2,
"refute/2",
"Asserts the `not_expected` value is nil or false.\nIn case it is a truthy value, raises the given message.\n\n## Examples\n\n refute true, \"This will obviously fail\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L425",
:def,
425,
[ { :not_expected,
[ line: 425 ],
nil },
{ :message,
[ line: 425 ],
nil } ] },
{ ExDoc.FunctionNode,
:refute_in_delta,
4,
"refute_in_delta/4",
"Asserts the `expected` and `received` are not within `delta`.\n\n## Examples\n\n refute_in_delta 1.1, 1.2, 0.2\n refute_in_delta 10, 11, 2\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L486",
:def,
486,
[ { :expected,
[ line: 486 ],
nil },
{ :received,
[ line: 486 ],
nil },
{ :delta,
[ line: 486 ],
nil },
{ ://,
[ line: 486 ],
[ { :message,
[ line: 486 ],
nil },
nil ] } ] },
{ ExDoc.FunctionNode,
:refute_receive,
3,
"refute_receive/3",
"Asserts a message was not received and won't be during\na timeout value.\n\nThe `not_expected` contents must be a match pattern.\n\n## Examples\n\n refute_receive :bye\n\nRefute received with a explicit timeout:\n\n refute_receive :bye, 1000\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L444",
:defmacro,
444,
[ { :not_expected,
[ line: 444 ],
nil },
{ ://,
[ line: 444 ],
[ { :timeout,
[ line: 444 ],
nil },
100 ] },
{ ://,
[ line: 444 ],
[ { :message,
[ line: 444 ],
nil },
nil ] } ] },
{ ExDoc.FunctionNode,
:refute_received,
2,
"refute_received/2",
"Asserts a message was not received (i.e. it is not in the current process mailbox).\nThe `not_expected` contents must be a match pattern.\n\nTimeout is set to 0, so there is no waiting time.\n\n## Examples\n\n self <- :hello\n refute_received :bye\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L460",
:defmacro,
460,
[ { :not_expected,
[ line: 460 ],
nil },
{ ://,
[ line: 460 ],
[ { :message,
[ line: 460 ],
nil },
nil ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/assertions.ex#L20",
[],
nil,
"ExUnit.Assertions",
20,
{ ExDoc.ModuleNode,
ExUnit,
"ExUnit",
"Basic unit test structure for Elixir.\n\n## Example\n\nA basic setup for ExUnit is shown below:\n\n # File: assertion_test.exs\n\n # 1) Start ExUnit. You can pass some options as argument (list below)\n ExUnit.start\n\n # 2) Next we create a new TestCase and use ExUnit.Case\n defmodule AssertionTest do\n # 3) Notice we pass async: true, this runs the test case\n # concurrently with other test cases\n use ExUnit.Case, async: true\n\n # 4) A test is a function whose name starts with\n # test and receives a context\n def test_always_pass(_) do\n assert true\n end\n\n # 5) It is recommended to use the test macro instead of def\n test \"the truth\" do\n assert true\n end\n end\n\nTo run the test above, all you need to to is to run the file\nusing elixir from command line. Assuming you named your file\nassertion_test.exs, you can run it as:\n\n bin/elixir assertion_test.exs\n\n## Case, callbacks and assertions\n\nCheck `ExUnit.Case` and `ExUnit.Callbacks` for more information about\ndefining test cases.\n\nThe `ExUnit.Assertions` module contains a set of macros to easily\ngenerate assertions with appropriate error messages.\n\n",
[ { ExDoc.FunctionNode,
:configure,
1,
"configure/1",
"Configures ExUnit.\n\n## Options\n\nExUnit supports the following options given to start:\n\n* `:formatter` - The formatter that will print results.\n Defaults to `ExUnit.CLIFormatter`;\n\n* `:max_cases` - Maximum number of cases to run in parallel.\n Defaults to `:erlang.system_info(:schedulers_online)`;\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L102",
:def,
102,
[ { :options,
[ line: 102 ],
nil } ] },
{ ExDoc.FunctionNode,
:run,
0,
"run/0",
"API used to run the tests. It is invoked automatically\nif ExUnit is started via `ExUnit.start`.\n\nReturns the number of failures.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L112",
:def,
112,
[] },
{ ExDoc.FunctionNode,
:start,
1,
"start/1",
"Starts up ExUnit and automatically set it up to run\ntests at the VM exit. It accepts a set of options to\nconfigure `ExUnit` (the same ones accepted by `configure/1`).\n\nIn case you want to run tests manually, skip calling this\nfunction and rely on `configure/1` and `run/0` instead.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L71",
:def,
71,
[ { ://,
[ line: 71 ],
[ { :options,
[ line: 71 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:stop,
1,
"stop/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L98",
:def,
98,
[ { :_state,
[ line: 98 ],
:guess } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L1",
[],
nil,
"ExUnit",
1,
nil } },
{ ExDoc.ModuleNode,
ExUnit.CLIFormatter,
"CLIFormatter",
"Formatter responsible for printing raw text\non the CLI\n",
[ { ExDoc.FunctionNode,
:case_finished,
2,
"case_finished/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L29",
:def,
29,
[ { :_id,
[ line: 29 ],
:guess },
{ :_test_case,
[ line: 29 ],
:guess } ] },
{ ExDoc.FunctionNode,
:case_started,
2,
"case_started/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L25",
:def,
25,
[ { :_id,
[ line: 25 ],
:guess },
{ :_test_case,
[ line: 25 ],
:guess } ] },
{ ExDoc.FunctionNode,
:code_change,
3,
"code_change/3",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L111",
:def,
111,
[ { :_old,
[ line: 111 ],
:guess },
{ :state,
[ line: 111 ],
nil },
{ :_extra,
[ line: 111 ],
:guess } ] },
{ ExDoc.FunctionNode,
:handle_call,
3,
"handle_call/3",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L95",
:def,
95,
[ { :arg1,
[ line: 95 ],
:guess },
{ :arg2,
[ line: 95 ],
:guess },
{ :state,
[ line: 95 ],
nil } ] },
{ ExDoc.FunctionNode,
:handle_cast,
2,
"handle_cast/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L103",
:def,
103,
[ { :arg1,
[ line: 103 ],
:guess },
{ :state,
[ line: 103 ],
nil } ] },
{ ExDoc.FunctionNode,
:handle_info,
2,
"handle_info/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L99",
:def,
99,
[ { :_msg,
[ line: 99 ],
:guess },
{ :state,
[ line: 99 ],
nil } ] },
{ ExDoc.FunctionNode,
:init,
1,
"init/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L91",
:def,
91,
[ { :args,
[ line: 91 ],
nil } ] },
{ ExDoc.FunctionNode,
:suite_finished,
2,
"suite_finished/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L21",
:def,
21,
[ { :id,
[ line: 21 ],
nil },
{ :ms,
[ line: 21 ],
nil } ] },
{ ExDoc.FunctionNode,
:suite_started,
1,
"suite_started/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L16",
:def,
16,
[ { :_opts,
[ line: 16 ],
:guess } ] },
{ ExDoc.FunctionNode,
:terminate,
2,
"terminate/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L107",
:def,
107,
[ { :reason,
[ line: 107 ],
nil },
{ :state,
[ line: 107 ],
nil } ] },
{ ExDoc.FunctionNode,
:test_finished,
2,
"test_finished/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L37",
:def,
37,
[ { :id,
[ line: 37 ],
nil },
{ :test,
[ line: 37 ],
nil } ] },
{ ExDoc.FunctionNode,
:test_started,
2,
"test_started/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L33",
:def,
33,
[ { :_id,
[ line: 33 ],
:guess },
{ :_test,
[ line: 33 ],
:guess } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/cli_formatter.ex#L1",
[],
nil,
"ExUnit.CLIFormatter",
1,
{ ExDoc.ModuleNode,
ExUnit,
"ExUnit",
"Basic unit test structure for Elixir.\n\n## Example\n\nA basic setup for ExUnit is shown below:\n\n # File: assertion_test.exs\n\n # 1) Start ExUnit. You can pass some options as argument (list below)\n ExUnit.start\n\n # 2) Next we create a new TestCase and use ExUnit.Case\n defmodule AssertionTest do\n # 3) Notice we pass async: true, this runs the test case\n # concurrently with other test cases\n use ExUnit.Case, async: true\n\n # 4) A test is a function whose name starts with\n # test and receives a context\n def test_always_pass(_) do\n assert true\n end\n\n # 5) It is recommended to use the test macro instead of def\n test \"the truth\" do\n assert true\n end\n end\n\nTo run the test above, all you need to to is to run the file\nusing elixir from command line. Assuming you named your file\nassertion_test.exs, you can run it as:\n\n bin/elixir assertion_test.exs\n\n## Case, callbacks and assertions\n\nCheck `ExUnit.Case` and `ExUnit.Callbacks` for more information about\ndefining test cases.\n\nThe `ExUnit.Assertions` module contains a set of macros to easily\ngenerate assertions with appropriate error messages.\n\n",
[ { ExDoc.FunctionNode,
:configure,
1,
"configure/1",
"Configures ExUnit.\n\n## Options\n\nExUnit supports the following options given to start:\n\n* `:formatter` - The formatter that will print results.\n Defaults to `ExUnit.CLIFormatter`;\n\n* `:max_cases` - Maximum number of cases to run in parallel.\n Defaults to `:erlang.system_info(:schedulers_online)`;\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L102",
:def,
102,
[ { :options,
[ line: 102 ],
nil } ] },
{ ExDoc.FunctionNode,
:run,
0,
"run/0",
"API used to run the tests. It is invoked automatically\nif ExUnit is started via `ExUnit.start`.\n\nReturns the number of failures.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L112",
:def,
112,
[] },
{ ExDoc.FunctionNode,
:start,
1,
"start/1",
"Starts up ExUnit and automatically set it up to run\ntests at the VM exit. It accepts a set of options to\nconfigure `ExUnit` (the same ones accepted by `configure/1`).\n\nIn case you want to run tests manually, skip calling this\nfunction and rely on `configure/1` and `run/0` instead.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L71",
:def,
71,
[ { ://,
[ line: 71 ],
[ { :options,
[ line: 71 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:stop,
1,
"stop/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L98",
:def,
98,
[ { :_state,
[ line: 98 ],
:guess } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L1",
[],
nil,
"ExUnit",
1,
nil } },
{ ExDoc.ModuleNode,
ExUnit.Callbacks,
"Callbacks",
"This module defines four callbacks: `setup_all`, `teardown_all`,\n`setup` and `teardown`. Those callbacks are defined via macros\nand receives a keyword list of metadata. The callback may\noptionally define extra data which will be available in the test\ncases.\n\n## Examples\n\n defmodule AssertionTest do\n use ExUnit.Case, async: true\n\n setup do\n IO.puts \"This is a setup callback\"\n\n # Returns extra metadata\n { :ok, [hello: \"world\"] }\n end\n\n setup context do\n # We can access the test name in the context\n IO.puts \"Setting up: \#{context[:test]}\"\n\n # The metadata returned by the previous setup as well\n assert context[:hello] == \"world\"\n\n # No metadata\n :ok\n end\n\n test \"always pass\" do\n assert true\n end\n end\n\n",
[ { ExDoc.FunctionNode,
:setup,
2,
"setup/2",
"Called before the start of each test.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/callbacks.ex#L85",
:defmacro,
85,
[ { ://,
[ line: 85 ],
[ { :var,
[ line: 85 ],
nil },
{ :quote,
[ line: 85 ],
[ [ do: { :_,
[ line: 85 ],
nil } ] ] } ] },
{ :block,
[ line: 85 ],
nil } ] },
{ ExDoc.FunctionNode,
:setup_all,
2,
"setup_all/2",
"Called before the start of a case.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/callbacks.ex#L108",
:defmacro,
108,
[ { ://,
[ line: 108 ],
[ { :var,
[ line: 108 ],
nil },
{ :quote,
[ line: 108 ],
[ [ do: { :_,
[ line: 108 ],
nil } ] ] } ] },
{ :block,
[ line: 108 ],
nil } ] },
{ ExDoc.FunctionNode,
:teardown,
2,
"teardown/2",
"Called after the finish of each test. Note that, if the test crasches with an exit\nmessage `teardown` will not be run.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/callbacks.ex#L97",
:defmacro,
97,
[ { ://,
[ line: 97 ],
[ { :var,
[ line: 97 ],
nil },
{ :quote,
[ line: 97 ],
[ [ do: { :_,
[ line: 97 ],
nil } ] ] } ] },
{ :block,
[ line: 97 ],
nil } ] },
{ ExDoc.FunctionNode,
:teardown_all,
2,
"teardown_all/2",
"Called after the finish of each case.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/callbacks.ex#L119",
:defmacro,
119,
[ { ://,
[ line: 119 ],
[ { :var,
[ line: 119 ],
nil },
{ :quote,
[ line: 119 ],
[ [ do: { :_,
[ line: 119 ],
nil } ] ] } ] },
{ :block,
[ line: 119 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/callbacks.ex#L1",
[],
nil,
"ExUnit.Callbacks",
1,
{ ExDoc.ModuleNode,
ExUnit,
"ExUnit",
"Basic unit test structure for Elixir.\n\n## Example\n\nA basic setup for ExUnit is shown below:\n\n # File: assertion_test.exs\n\n # 1) Start ExUnit. You can pass some options as argument (list below)\n ExUnit.start\n\n # 2) Next we create a new TestCase and use ExUnit.Case\n defmodule AssertionTest do\n # 3) Notice we pass async: true, this runs the test case\n # concurrently with other test cases\n use ExUnit.Case, async: true\n\n # 4) A test is a function whose name starts with\n # test and receives a context\n def test_always_pass(_) do\n assert true\n end\n\n # 5) It is recommended to use the test macro instead of def\n test \"the truth\" do\n assert true\n end\n end\n\nTo run the test above, all you need to to is to run the file\nusing elixir from command line. Assuming you named your file\nassertion_test.exs, you can run it as:\n\n bin/elixir assertion_test.exs\n\n## Case, callbacks and assertions\n\nCheck `ExUnit.Case` and `ExUnit.Callbacks` for more information about\ndefining test cases.\n\nThe `ExUnit.Assertions` module contains a set of macros to easily\ngenerate assertions with appropriate error messages.\n\n",
[ { ExDoc.FunctionNode,
:configure,
1,
"configure/1",
"Configures ExUnit.\n\n## Options\n\nExUnit supports the following options given to start:\n\n* `:formatter` - The formatter that will print results.\n Defaults to `ExUnit.CLIFormatter`;\n\n* `:max_cases` - Maximum number of cases to run in parallel.\n Defaults to `:erlang.system_info(:schedulers_online)`;\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L102",
:def,
102,
[ { :options,
[ line: 102 ],
nil } ] },
{ ExDoc.FunctionNode,
:run,
0,
"run/0",
"API used to run the tests. It is invoked automatically\nif ExUnit is started via `ExUnit.start`.\n\nReturns the number of failures.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L112",
:def,
112,
[] },
{ ExDoc.FunctionNode,
:start,
1,
"start/1",
"Starts up ExUnit and automatically set it up to run\ntests at the VM exit. It accepts a set of options to\nconfigure `ExUnit` (the same ones accepted by `configure/1`).\n\nIn case you want to run tests manually, skip calling this\nfunction and rely on `configure/1` and `run/0` instead.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L71",
:def,
71,
[ { ://,
[ line: 71 ],
[ { :options,
[ line: 71 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:stop,
1,
"stop/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L98",
:def,
98,
[ { :_state,
[ line: 98 ],
:guess } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L1",
[],
nil,
"ExUnit",
1,
nil } },
{ ExDoc.ModuleNode,
ExUnit.Case,
"Case",
"This module is meant to be used in other modules\nas a way to configure and prepare them for testing.\n\nWhen used, it allows the following options:\n\n* :async - configure Elixir to run that specific test case\n in parallel with others. Must be used for performance\n when your test cases do not change any global state;\n\nThis module automatically includes all callbacks defined\nin `ExUnit.Callbacks`. Read it for more information.\n\n## Examples\n\n defmodule AssertionTest do\n use ExUnit.Case, async: true\n\n def test_always_pass\n assert true\n end\n end\n\n",
[ { ExDoc.FunctionNode,
:test,
3,
"test/3",
"Provides a convenient macro that allows a test to be\ndefined with a string. This macro automatically inserts\nthe atom :ok as the last line of the test. That said,\na passing test always returns :ok, but, more important,\nit forces Elixir to not tail call optimize the test and\ntherefore avoiding hiding lines from the backtrace.\n\n## Examples\n\n test \"true is equal to true\" do\n assert true == true\n end\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/case.ex#L67",
:defmacro,
67,
[ { :message,
[ line: 67 ],
nil },
{ ://,
[ line: 67 ],
[ { :var,
[ line: 67 ],
nil },
{ :quote,
[ line: 67 ],
[ [ do: { :_,
[ line: 67 ],
nil } ] ] } ] },
{ :contents,
[ line: 67 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/case.ex#L1",
[],
nil,
"ExUnit.Case",
1,
{ ExDoc.ModuleNode,
ExUnit,
"ExUnit",
"Basic unit test structure for Elixir.\n\n## Example\n\nA basic setup for ExUnit is shown below:\n\n # File: assertion_test.exs\n\n # 1) Start ExUnit. You can pass some options as argument (list below)\n ExUnit.start\n\n # 2) Next we create a new TestCase and use ExUnit.Case\n defmodule AssertionTest do\n # 3) Notice we pass async: true, this runs the test case\n # concurrently with other test cases\n use ExUnit.Case, async: true\n\n # 4) A test is a function whose name starts with\n # test and receives a context\n def test_always_pass(_) do\n assert true\n end\n\n # 5) It is recommended to use the test macro instead of def\n test \"the truth\" do\n assert true\n end\n end\n\nTo run the test above, all you need to to is to run the file\nusing elixir from command line. Assuming you named your file\nassertion_test.exs, you can run it as:\n\n bin/elixir assertion_test.exs\n\n## Case, callbacks and assertions\n\nCheck `ExUnit.Case` and `ExUnit.Callbacks` for more information about\ndefining test cases.\n\nThe `ExUnit.Assertions` module contains a set of macros to easily\ngenerate assertions with appropriate error messages.\n\n",
[ { ExDoc.FunctionNode,
:configure,
1,
"configure/1",
"Configures ExUnit.\n\n## Options\n\nExUnit supports the following options given to start:\n\n* `:formatter` - The formatter that will print results.\n Defaults to `ExUnit.CLIFormatter`;\n\n* `:max_cases` - Maximum number of cases to run in parallel.\n Defaults to `:erlang.system_info(:schedulers_online)`;\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L102",
:def,
102,
[ { :options,
[ line: 102 ],
nil } ] },
{ ExDoc.FunctionNode,
:run,
0,
"run/0",
"API used to run the tests. It is invoked automatically\nif ExUnit is started via `ExUnit.start`.\n\nReturns the number of failures.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L112",
:def,
112,
[] },
{ ExDoc.FunctionNode,
:start,
1,
"start/1",
"Starts up ExUnit and automatically set it up to run\ntests at the VM exit. It accepts a set of options to\nconfigure `ExUnit` (the same ones accepted by `configure/1`).\n\nIn case you want to run tests manually, skip calling this\nfunction and rely on `configure/1` and `run/0` instead.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L71",
:def,
71,
[ { ://,
[ line: 71 ],
[ { :options,
[ line: 71 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:stop,
1,
"stop/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L98",
:def,
98,
[ { :_state,
[ line: 98 ],
:guess } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L1",
[],
nil,
"ExUnit",
1,
nil } },
{ ExDoc.ModuleNode,
ExUnit.CaseTemplate,
"CaseTemplate",
"This module allows a developer to define a test case\ntemplate to be used throughout his tests. This is useful\nwhen there are a set of functions that should be shared\nbetween tests or a set of setup/teardown callbacks.\n\nBy using this module, the callbacks and assertions\navailable for regular test cases will also be available.\n\n## Example\n\n defmodule MyCase do\n use ExUnit.CaseTemplate\n\n setup do\n IO.puts \"This will run before each test that uses this case\"\n end\n end\n\n defmodule MyTest do\n use MyCase, async: true\n\n test \"truth\" do\n assert true\n end\n end\n\n",
[ { ExDoc.FunctionNode,
:using,
2,
"using/2",
"Allows a developer to code to be invoked when\nthis module is used.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/case_template.ex#L60",
:defmacro,
60,
[ { ://,
[ line: 60 ],
[ { :var,
[ line: 60 ],
nil },
{ :quote,
[ line: 60 ],
[ [ do: { :_,
[ line: 60 ],
nil } ] ] } ] },
{ :list2,
60,
:guess } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/case_template.ex#L1",
[],
nil,
"ExUnit.CaseTemplate",
1,
{ ExDoc.ModuleNode,
ExUnit,
"ExUnit",
"Basic unit test structure for Elixir.\n\n## Example\n\nA basic setup for ExUnit is shown below:\n\n # File: assertion_test.exs\n\n # 1) Start ExUnit. You can pass some options as argument (list below)\n ExUnit.start\n\n # 2) Next we create a new TestCase and use ExUnit.Case\n defmodule AssertionTest do\n # 3) Notice we pass async: true, this runs the test case\n # concurrently with other test cases\n use ExUnit.Case, async: true\n\n # 4) A test is a function whose name starts with\n # test and receives a context\n def test_always_pass(_) do\n assert true\n end\n\n # 5) It is recommended to use the test macro instead of def\n test \"the truth\" do\n assert true\n end\n end\n\nTo run the test above, all you need to to is to run the file\nusing elixir from command line. Assuming you named your file\nassertion_test.exs, you can run it as:\n\n bin/elixir assertion_test.exs\n\n## Case, callbacks and assertions\n\nCheck `ExUnit.Case` and `ExUnit.Callbacks` for more information about\ndefining test cases.\n\nThe `ExUnit.Assertions` module contains a set of macros to easily\ngenerate assertions with appropriate error messages.\n\n",
[ { ExDoc.FunctionNode,
:configure,
1,
"configure/1",
"Configures ExUnit.\n\n## Options\n\nExUnit supports the following options given to start:\n\n* `:formatter` - The formatter that will print results.\n Defaults to `ExUnit.CLIFormatter`;\n\n* `:max_cases` - Maximum number of cases to run in parallel.\n Defaults to `:erlang.system_info(:schedulers_online)`;\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L102",
:def,
102,
[ { :options,
[ line: 102 ],
nil } ] },
{ ExDoc.FunctionNode,
:run,
0,
"run/0",
"API used to run the tests. It is invoked automatically\nif ExUnit is started via `ExUnit.start`.\n\nReturns the number of failures.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L112",
:def,
112,
[] },
{ ExDoc.FunctionNode,
:start,
1,
"start/1",
"Starts up ExUnit and automatically set it up to run\ntests at the VM exit. It accepts a set of options to\nconfigure `ExUnit` (the same ones accepted by `configure/1`).\n\nIn case you want to run tests manually, skip calling this\nfunction and rely on `configure/1` and `run/0` instead.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L71",
:def,
71,
[ { ://,
[ line: 71 ],
[ { :options,
[ line: 71 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:stop,
1,
"stop/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L98",
:def,
98,
[ { :_state,
[ line: 98 ],
:guess } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L1",
[],
nil,
"ExUnit",
1,
nil } },
{ ExDoc.ModuleNode,
ExUnit.DocTest,
"DocTest",
"ExUnit.DocTest implements functionality similar to [Python's\ndoctest](http://docs.python.org/2/library/doctest.html).\n\nIn a nutshell, it allows us to generate tests from the code\nexamples existing in module/function/macro's documentation.\nIn order to do that, one needs to invoke `doctest/1` macro\nfrom their test case and write their examples according\nto some guidelines.\n\nThe syntax for examples is as follows. Every new test starts\non a new line, with an \"iex>\" prefix. Multiline expressions\ncan be employed if the following lines start with either\n\"...>\" (recommended) or \"iex>\" prefix.\n\nThe expected result should start at the next line after \"iex>\"\nor \"...>\" line(s) and is terminated either by a newline, new\n\"iex>\" prefix or end of the string literal.\n\n## Examples\n\nCurrently, the only way to run doctests is to include them into\nan ExUnit case with a `doctest` macro:\n\n defmodule MyModule.Test do\n use ExUnit.Case, async: true\n doctest MyModule\n end\n\nThe `doctest` macro is going to loop all functions and macros\ndefined in `MyModule`, parsing their documentation in search for\ncode examples.\n\nA very basic example is:\n\n iex> 1+1\n 2\n\nMultiline is also supported:\n\n iex> Enum.map [1,2,3], fn(x) ->\n ...> x * 2\n ...> end\n [2,4,6]\n\nSimilarly to iex you can use numbers in your \"prompts\":\n\n iex(1)> [1+2,\n ...(1)> 3]\n [3,3]\n\nThis is useful in two use cases:\n\n* Being able to refer to specific numbered scenarios\n* Copy-pasting examples from an actual iex sessions\n\nWe also allow you to select or skip some functions when calling\n`doctest`. See its documentation documentation for more info.\n\n## Exceptions\n\nYou can also showcase expressions raising an exception, for example:\n\n iex(1)> binary_to_atom((fn() -> 1 end).())\n ** (ArgumentError) argument error\n\nWhat DocTest will be looking for is a line starting with \"** (\" and it\nwill parse it accordingly to extract the exception name and the message.\nAt this moment, the exception parser would make the parser treat the next\nline as a start of a completely new expression (if it is prefixed with iex>)\nor a no-op line with documentation. Thus, multiline messages are not\nsupported.\n\n## When not to use doctest\n\nIn general, doctests are not recommended when your code examples contain\nside effects. For example, if a doctest prints to standard output, doctest\nwill not try to capture the output.\n\nSimilarly, doctest does not run in any kind of side box. So any module\ndefined in a code example is going to linger throughout the whole test suite\nrun.\n",
[ { ExDoc.FunctionNode,
:doctest,
2,
"doctest/2",
"This macro is used to generate ExUnit test cases for doctests.\n\nThere are three ways this macro can be used:\n\n* `doctest(Module)` — will generate tests for all doctests found\n in the module `Module`\n\nOptions can also be supplied:\n\n* `:except` — generate tests for all functions except those listed\n (list of `{function, arity}` tuples)\n\n* `:only` — generate tests only forfunctions listed\n (list of `{function, arity}` tuples)\n\n* `:import` — when true, one can test a function defined in the module\n without referring to the module name. However, this is not\n feasible when there is a clash with a number module like\n Kernel. In these cases, `import` should be set to `false`\n and a full `M.f` construct should be used.\n\n## Examples\n\n doctest MyModule, except: [trick_fun: 1]\n\nThis macro is auto-imported into every `ExUnit.Case`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/doc_test.ex#L116",
:defmacro,
116,
[ { :mod,
[ line: 116 ],
nil },
{ ://,
[ line: 116 ],
[ { :opts,
[ line: 116 ],
nil },
[] ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/doc_test.ex#L1",
[],
nil,
"ExUnit.DocTest",
1,
{ ExDoc.ModuleNode,
ExUnit,
"ExUnit",
"Basic unit test structure for Elixir.\n\n## Example\n\nA basic setup for ExUnit is shown below:\n\n # File: assertion_test.exs\n\n # 1) Start ExUnit. You can pass some options as argument (list below)\n ExUnit.start\n\n # 2) Next we create a new TestCase and use ExUnit.Case\n defmodule AssertionTest do\n # 3) Notice we pass async: true, this runs the test case\n # concurrently with other test cases\n use ExUnit.Case, async: true\n\n # 4) A test is a function whose name starts with\n # test and receives a context\n def test_always_pass(_) do\n assert true\n end\n\n # 5) It is recommended to use the test macro instead of def\n test \"the truth\" do\n assert true\n end\n end\n\nTo run the test above, all you need to to is to run the file\nusing elixir from command line. Assuming you named your file\nassertion_test.exs, you can run it as:\n\n bin/elixir assertion_test.exs\n\n## Case, callbacks and assertions\n\nCheck `ExUnit.Case` and `ExUnit.Callbacks` for more information about\ndefining test cases.\n\nThe `ExUnit.Assertions` module contains a set of macros to easily\ngenerate assertions with appropriate error messages.\n\n",
[ { ExDoc.FunctionNode,
:configure,
1,
"configure/1",
"Configures ExUnit.\n\n## Options\n\nExUnit supports the following options given to start:\n\n* `:formatter` - The formatter that will print results.\n Defaults to `ExUnit.CLIFormatter`;\n\n* `:max_cases` - Maximum number of cases to run in parallel.\n Defaults to `:erlang.system_info(:schedulers_online)`;\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L102",
:def,
102,
[ { :options,
[ line: 102 ],
nil } ] },
{ ExDoc.FunctionNode,
:run,
0,
"run/0",
"API used to run the tests. It is invoked automatically\nif ExUnit is started via `ExUnit.start`.\n\nReturns the number of failures.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L112",
:def,
112,
[] },
{ ExDoc.FunctionNode,
:start,
1,
"start/1",
"Starts up ExUnit and automatically set it up to run\ntests at the VM exit. It accepts a set of options to\nconfigure `ExUnit` (the same ones accepted by `configure/1`).\n\nIn case you want to run tests manually, skip calling this\nfunction and rely on `configure/1` and `run/0` instead.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L71",
:def,
71,
[ { ://,
[ line: 71 ],
[ { :options,
[ line: 71 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:stop,
1,
"stop/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L98",
:def,
98,
[ { :_state,
[ line: 98 ],
:guess } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L1",
[],
nil,
"ExUnit",
1,
nil } },
{ ExDoc.ModuleNode,
ExUnit.Formatter,
"Formatter",
"This module simply defines the callbacks\nexpected by an ExUnit.Formatter.\n",
[ { ExDoc.FunctionNode,
:test_finished,
2,
"test_finished/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/formatter.ex#L21",
:defcallback,
21,
[ { :id,
[ line: 21 ],
[] },
{ :::,
[ line: 21 ],
[ { :test,
21,
nil },
{ { :.,
[ line: 21 ],
[ ExUnit.Test,
:t ] },
[ line: 21 ],
[] } ] } ] },
{ ExDoc.FunctionNode,
:test_started,
2,
"test_started/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/formatter.ex#L20",
:defcallback,
20,
[ { :id,
[ line: 20 ],
[] },
{ :::,
[ line: 20 ],
[ { :test,
20,
nil },
{ { :.,
[ line: 20 ],
[ ExUnit.Test,
:t ] },
[ line: 20 ],
[] } ] } ] },
{ ExDoc.FunctionNode,
:case_finished,
2,
"case_finished/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/formatter.ex#L18",
:defcallback,
18,
[ { :id,
[ line: 18 ],
[] },
{ :test_case,
[ line: 18 ],
[] } ] },
{ ExDoc.FunctionNode,
:case_started,
2,
"case_started/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/formatter.ex#L17",
:defcallback,
17,
[ { :id,
[ line: 17 ],
[] },
{ :test_case,
[ line: 17 ],
[] } ] },
{ ExDoc.FunctionNode,
:suite_finished,
2,
"suite_finished/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/formatter.ex#L15",
:defcallback,
15,
[ { :id,
[ line: 15 ],
[] },
{ :::,
[ line: 15 ],
[ { :miliseconds,
15,
nil },
{ :pos_integer,
[ line: 15 ],
[] } ] } ] },
{ ExDoc.FunctionNode,
:suite_started,
1,
"suite_started/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/formatter.ex#L14",
:defcallback,
14,
[ { :::,
[ line: 14 ],
[ { :opts,
14,
nil },
{ :list,
[ line: 14 ],
[] } ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit/formatter.ex#L1",
[],
:behaviour,
"ExUnit.Formatter",
1,
{ ExDoc.ModuleNode,
ExUnit,
"ExUnit",
"Basic unit test structure for Elixir.\n\n## Example\n\nA basic setup for ExUnit is shown below:\n\n # File: assertion_test.exs\n\n # 1) Start ExUnit. You can pass some options as argument (list below)\n ExUnit.start\n\n # 2) Next we create a new TestCase and use ExUnit.Case\n defmodule AssertionTest do\n # 3) Notice we pass async: true, this runs the test case\n # concurrently with other test cases\n use ExUnit.Case, async: true\n\n # 4) A test is a function whose name starts with\n # test and receives a context\n def test_always_pass(_) do\n assert true\n end\n\n # 5) It is recommended to use the test macro instead of def\n test \"the truth\" do\n assert true\n end\n end\n\nTo run the test above, all you need to to is to run the file\nusing elixir from command line. Assuming you named your file\nassertion_test.exs, you can run it as:\n\n bin/elixir assertion_test.exs\n\n## Case, callbacks and assertions\n\nCheck `ExUnit.Case` and `ExUnit.Callbacks` for more information about\ndefining test cases.\n\nThe `ExUnit.Assertions` module contains a set of macros to easily\ngenerate assertions with appropriate error messages.\n\n",
[ { ExDoc.FunctionNode,
:configure,
1,
"configure/1",
"Configures ExUnit.\n\n## Options\n\nExUnit supports the following options given to start:\n\n* `:formatter` - The formatter that will print results.\n Defaults to `ExUnit.CLIFormatter`;\n\n* `:max_cases` - Maximum number of cases to run in parallel.\n Defaults to `:erlang.system_info(:schedulers_online)`;\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L102",
:def,
102,
[ { :options,
[ line: 102 ],
nil } ] },
{ ExDoc.FunctionNode,
:run,
0,
"run/0",
"API used to run the tests. It is invoked automatically\nif ExUnit is started via `ExUnit.start`.\n\nReturns the number of failures.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L112",
:def,
112,
[] },
{ ExDoc.FunctionNode,
:start,
1,
"start/1",
"Starts up ExUnit and automatically set it up to run\ntests at the VM exit. It accepts a set of options to\nconfigure `ExUnit` (the same ones accepted by `configure/1`).\n\nIn case you want to run tests manually, skip calling this\nfunction and rely on `configure/1` and `run/0` instead.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L71",
:def,
71,
[ { ://,
[ line: 71 ],
[ { :options,
[ line: 71 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:stop,
1,
"stop/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L98",
:def,
98,
[ { :_state,
[ line: 98 ],
:guess } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/ex_unit/lib/ex_unit.ex#L1",
[],
nil,
"ExUnit",
1,
nil } } ],
nil,
"ExUnit",
1,
nil },
{ ExDoc.ModuleNode,
Exception,
"Exception",
"Several convenience functions to work and pretty print\nexceptions and stacktraces.\n",
[ { ExDoc.FunctionNode,
:format_entry,
2,
"format_entry/2",
"Receives a tuple representing a stacktrace entry and formats it.\nThe current working directory may be given as argument, which\nis used to prettify the stacktrace.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/exception.ex#L158",
:def,
158,
[ { :entry,
[ line: 158 ],
nil },
{ ://,
[ line: 158 ],
[ { :cwd,
[ line: 158 ],
nil },
nil ] } ] },
{ ExDoc.FunctionNode,
:format_file_line,
3,
"format_file_line/3",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/exception.ex#L254",
:def,
254,
[ { :file,
[ line: 254 ],
nil },
{ :line,
[ line: 254 ],
nil },
{ :cwd,
[ line: 254 ],
nil } ] },
{ ExDoc.FunctionNode,
:format_stacktrace,
1,
"format_stacktrace/1",
"Formats the stacktrace.\n\nA stacktrace must be given as argument. If not, this function\ncalculates the current stacktrace and formats it. As consequence,\nthe value of `System.stacktrace` is changed.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/exception.ex#L190",
:def,
190,
[ { ://,
[ line: 190 ],
[ { :trace,
[ line: 190 ],
nil },
nil ] } ] },
{ ExDoc.FunctionNode,
:normalize,
1,
"normalize/1",
"Normalizes an exception converting Erlang exceptions\nto Elixir exceptions. Useful when interfacing Erlang\ncode with Elixir code.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/exception.ex#L103",
:def,
103,
[ { :exception,
[ line: 103 ],
nil } ] },
{ ExDoc.FunctionNode,
:print_stacktrace,
1,
"print_stacktrace/1",
"Prints the current stacktrace to standard output.\n\nA stacktrace must be given as argument. If not, this function\ncalculates the current stacktrace and formats it. As consequence,\nthe value of `System.stacktrace` is changed.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/exception.ex#L212",
:def,
212,
[ { ://,
[ line: 212 ],
[ { :trace,
[ line: 212 ],
nil },
nil ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/exception.ex#L92",
[],
nil,
"Exception",
92,
nil },
{ ExDoc.ModuleNode,
File,
"File",
"This module contains function to manipulate files.\nMany of the functions that interact with the filesystem\nhave their naming based on its UNIX variants. For\nexample, deleting a file is done with `File.rm`.\nGetting its stats with `File.stat`.\n\nIn order to write and read files, one must use the\nfunctions in the IO module. By default, a file is\nopened in binary mode which requires the functions\n`IO.binread`, `IO.binwrite` and `IO.binreadline` to\ninteract with the file. A developer may pass `:utf8`\nas an option when opening the file and then all other\nfunctions from IO are available, since they work directly\nwith Unicode data.\n\nMost of the functions in this module return `:ok`\nor `{ :ok, result }` in case of success, `{ :error, reason }`\notherwise. Those function are also followed by\na variant that ends with `!` which returns the\nresult (without the `{ :ok, result }` tuple) in\ncase of success or raises an exception in case it\nfails. For example:\n\n File.read(\"hello.txt\")\n #=> { :ok, \"World\" }\n\n File.read(\"invalid.txt\")\n #=> { :error, :enoent }\n\n File.read!(\"hello.txt\")\n #=> \"World\"\n\n File.read!(\"invalid.txt\")\n #=> raises File.Error\n\nIn general, a developer should use the former in case\nhe wants to react in the fie does not exist. The latter\nshould be used when the developer expects his software\nto fail in case the file cannot be read (i.e. it is\nliterally an exception).\n\nFinally, the functions in this module accept either\na char lists or a binary. When manipulating paths, a char\nlist is returned if one is given as argument. However,\nwhen reading files, binaries are always returned.\n",
[ { ExDoc.FunctionNode,
:biniterator,
1,
"biniterator/1",
"Converts the file device into an iterator that can\nbe passed into `Enum` to iterate line by line as a\nbinary. Check `iterator/1` for more information.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L1016",
:def,
1016,
[ { :device,
[ line: 1016 ],
nil } ] },
{ ExDoc.FunctionNode,
:biniterator,
2,
"biniterator/2",
"Opens the given `file` with the given `mode` and\nreturns its biniterator. Fails for the same reasons\nas `File.open`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L1047",
:def,
1047,
[ { :file,
[ line: 1047 ],
nil },
{ :mode,
[ line: 1047 ],
nil } ] },
{ ExDoc.FunctionNode,
:biniterator!,
2,
"biniterator!/2",
"Same as `biniterator/2` but raises if the file\ncannot be opened.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L1058",
:def,
1058,
[ { :file,
[ line: 1058 ],
nil },
{ ://,
[ line: 1058 ],
[ { :mode,
[ line: 1058 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:cd,
1,
"cd/1",
"Sets the current working directory. Returns `:ok` if successful,\n`{ :error, reason }` otherwise.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L867",
:def,
867,
[ { :path,
[ line: 867 ],
nil } ] },
{ ExDoc.FunctionNode,
:cd!,
1,
"cd!/1",
"The same as `cd/0`, but raises an exception if it fails.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L874",
:def,
874,
[ { :path,
[ line: 874 ],
nil } ] },
{ ExDoc.FunctionNode,
:cd!,
2,
"cd!/2",
"Changes the current directory to the given `path`,\nexecutes the given function and then revert back\nto the previous path regardless if there is an exception.\n\nRaises an error if retrieving or changing the current\ndirectory fails.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L890",
:def,
890,
[ { :path,
[ line: 890 ],
nil },
{ :function,
[ line: 890 ],
nil } ] },
{ ExDoc.FunctionNode,
:close,
1,
"close/1",
"Closes the file referenced by `io_device`. It mostly returns `:ok`, except\nfor some severe errors such as out of memory.\n\nNote that if the option `:delayed_write` was used when opening the file,\n`close/1` might return an old write error and not even try to close the file.\nSee `open/2`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L933",
:def,
933,
[ { :io_device,
[ line: 933 ],
nil } ] },
{ ExDoc.FunctionNode,
:copy,
3,
"copy/3",
"Copies the contents of `source` to `destination`. Both\nparameters can be a filename or an io device opened with `File.open`.\n`bytes_count` specifies the number of bytes to count, the default\nbeing `:infinity`.\n\nIf file `destination` already exists, it is overriden\nby the contents in `source`.\n\nReturns `{ :ok, bytes_copied }` if successful,\n`{ :error, reason }` otherwise.\n\nTypical error reasons are the same as in `open/2`,\n`read/1` and `write/2`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L327",
:def,
327,
[ { :source,
[ line: 327 ],
nil },
{ :destination,
[ line: 327 ],
nil },
{ ://,
[ line: 327 ],
[ { :bytes_count,
[ line: 327 ],
nil },
:infinity ] } ] },
{ ExDoc.FunctionNode,
:copy!,
3,
"copy!/3",
"The same as `copy/3` but raises an File.CopyError if it fails.\nReturns the `bytes_copied` otherwise.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L335",
:def,
335,
[ { :source,
[ line: 335 ],
nil },
{ :destination,
[ line: 335 ],
nil },
{ ://,
[ line: 335 ],
[ { :bytes_count,
[ line: 335 ],
nil },
:infinity ] } ] },
{ ExDoc.FunctionNode,
:cp,
3,
"cp/3",
"Copies the contents in `source` to `destination`.\nSimilar to the command `cp -r` in Unix systems,\nthis function behaves differently depending\nif `source` and `destination` are a file or a directory.\n\nIf both are files, it simply copies `source` to\n`destination`. However, if `destination` is a directory,\nit copies the contents of `source` to `destination/source`\nrecursively.\n\nIf a file already exists in the destination,\nit invokes a callback which should return\ntrue if the existing file should be overriden,\nfalse otherwise. It defaults to return true.\n\nIt returns `:ok` in case of success, returns\n`{ :error, reason }` otherwise.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L363",
:def,
363,
[ { :source,
[ line: 363 ],
nil },
{ :destination,
[ line: 363 ],
nil },
{ ://,
[ line: 363 ],
[ { :callback,
[ line: 363 ],
nil },
{ :fn,
[ line: 363 ],
[ [ do: { :"->",
[ line: 363 ],
[ { [ { :_,
[ line: 363 ],
nil },
{ :_,
[ line: 363 ],
nil } ],
true } ] } ] ] } ] } ] },
{ ExDoc.FunctionNode,
:cp!,
3,
"cp!/3",
"The same as `cp/3`, but raises File.CopyError if it fails.\nReturns the list of copied files otherwise.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L386",
:def,
386,
[ { :source,
[ line: 386 ],
nil },
{ :destination,
[ line: 386 ],
nil },
{ ://,
[ line: 386 ],
[ { :callback,
[ line: 386 ],
nil },
{ :fn,
[ line: 386 ],
[ [ do: { :"->",
[ line: 386 ],
[ { [ { :_,
[ line: 386 ],
nil },
{ :_,
[ line: 386 ],
nil } ],
true } ] } ] ] } ] } ] },
{ ExDoc.FunctionNode,
:cp_r,
3,
"cp_r/3",
"Copies the contents in source to destination.\nSimilar to the command `cp -r` in Unix systems,\nthis function behaves differently depending\nif `source` and `destination` are a file or a directory.\n\nIf both are files, it simply copies `source` to\n`destination`. However, if `destination` is a directory,\nit copies the contents of `source` to `destination/source`\nrecursively.\n\nIf a file already exists in the destination,\nit invokes a callback which should return\ntrue if the existing file should be overriden,\nfalse otherwise. It defaults to return true.\n\nIf a directory already exists in the destination\nwhere a file is meant to be (or otherwise), this\nfunction will fail.\n\nThis function may fail while copying files,\nin such cases, it will leave the destination\ndirectory in a dirty state, where already\ncopied files won't be removed.\n\nIt returns `{ :ok, files_and_directories }` in case of\nsuccess with all files and directories copied in no\nspecific order, `{ :error, reason }` otherwise.\n\n## Examples\n\n # Copies \"a.txt\" to \"tmp/a.txt\"\n File.cp_r \"a.txt\", \"tmp\"\n\n # Copies all files in \"samples\" to \"tmp/samples\"\n File.cp_r \"samples\", \"tmp\"\n\n # Copies all files in \"samples\" to \"tmp\"\n File.cp_r \"samples/.\", \"tmp\"\n\n # Same as before, but asks the user how to proceed in case of conflicts\n File.cp_r \"samples/.\", \"tmp\", fn(source, destination) ->\n IO.gets(\"Overriding \#{destination} by \#{source}. Type y to confirm.\") == \"y\"\n end\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L441",
:def,
441,
[ { :source,
[ line: 441 ],
nil },
{ :destination,
[ line: 441 ],
nil },
{ ://,
[ line: 441 ],
[ { :callback,
[ line: 441 ],
nil },
{ :fn,
[ line: 441 ],
[ [ do: { :"->",
[ line: 441 ],
[ { [ { :_,
[ line: 441 ],
nil },
{ :_,
[ line: 441 ],
nil } ],
true } ] } ] ] } ] } ] },
{ ExDoc.FunctionNode,
:cp_r!,
3,
"cp_r!/3",
"The same as `cp_r/3`, but raises File.CopyError if it fails.\nReturns the list of copied files otherwise.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L460",
:def,
460,
[ { :source,
[ line: 460 ],
nil },
{ :destination,
[ line: 460 ],
nil },
{ ://,
[ line: 460 ],
[ { :callback,
[ line: 460 ],
nil },
{ :fn,
[ line: 460 ],
[ [ do: { :"->",
[ line: 460 ],
[ { [ { :_,
[ line: 460 ],
nil },
{ :_,
[ line: 460 ],
nil } ],
true } ] } ] ] } ] } ] },
{ ExDoc.FunctionNode,
:cwd,
0,
"cwd/0",
"Gets the current working directory. In rare circumstances, this function can\nfail on Unix. It may happen if read permission does not exist for the parent\ndirectories of the current directory. For this reason, returns `{ :ok, cwd }`\nin case of success, `{ :error, reason }` otherwise.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L845",
:def,
845,
[] },
{ ExDoc.FunctionNode,
:cwd!,
0,
"cwd!/0",
"The same as `cwd/0`, but raises an exception if it fails.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L855",
:def,
855,
[] },
{ ExDoc.FunctionNode,
:dir?,
1,
"dir?/1",
"Returns true if the path is a directory.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L123",
:def,
123,
[ { :path,
[ line: 123 ],
nil } ] },
{ ExDoc.FunctionNode,
:exists?,
1,
"exists?/1",
"Returns true if the given argument exists.\nIt can be regular file, directory, socket,\nsymbolic link, named pipe or device file.\n\n## Examples\n\n File.exists?(\"test/\")\n #=> true\n\n File.exists?(\"missing.txt\")\n #=> false\n\n File.exists?(\"/dev/null\")\n #=> true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L144",
:def,
144,
[ { :path,
[ line: 144 ],
nil } ] },
{ ExDoc.FunctionNode,
:iterator,
1,
"iterator/1",
"Converts the file device into an iterator that can be\npassed into `Enum`. The device is iterated line\nby line, at the end of iteration the file is closed.\n\nThis reads the file as utf-8. CHeck out `File.biniterator`\nto handle the file as a raw binary.\n\n## Examples\n\nAn example that lazily iterates a file replacing all double\nquotes per single quotes and write each line to a target file\nis shown below:\n\n { :ok, device } = File.open(\"README.md\")\n source = File.iterator(device)\n File.open \"NEWREADME.md\", [:write], fn(target) ->\n Enum.each source, fn(line) ->\n IO.write target, Regex.replace(%r/\"/, line, \"'\")\n end\n end\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L965",
:def,
965,
[ { :device,
[ line: 965 ],
nil } ] },
{ ExDoc.FunctionNode,
:iterator,
2,
"iterator/2",
"Opens the given `file` with the given `mode` and\nreturns its iterator. Fails for the same reasons\nas `File.open`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L996",
:def,
996,
[ { :file,
[ line: 996 ],
nil },
{ :mode,
[ line: 996 ],
nil } ] },
{ ExDoc.FunctionNode,
:iterator!,
2,
"iterator!/2",
"Same as `iterator/2` but raises if the file\ncannot be opened.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L1007",
:def,
1007,
[ { :file,
[ line: 1007 ],
nil },
{ ://,
[ line: 1007 ],
[ { :mode,
[ line: 1007 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:ls,
1,
"ls/1",
"Returns list of files in the given directory.\n\nIt returns `{ :ok, [files] }` in case of success,\n`{ :error, reason }` otherwise.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L906",
:def,
906,
[ { ://,
[ line: 906 ],
[ { :path,
[ line: 906 ],
nil },
"." ] } ] },
{ ExDoc.FunctionNode,
:ls!,
1,
"ls!/1",
"The same as `ls/1` but raises `File.Error`\nin case of an error.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L917",
:def,
917,
[ { ://,
[ line: 917 ],
[ { :dir,
[ line: 917 ],
nil },
"." ] } ] },
{ ExDoc.FunctionNode,
:mkdir,
1,
"mkdir/1",
"Tries to create the directory `path`. Missing parent directories are not created.\nReturns `:ok` if successful, or `{:error, reason}` if an error occurs.\n\nTypical error reasons are:\n\n* :eacces - Missing search or write permissions for the parent directories of `path`.\n* :eexist - There is already a file or directory named `path`.\n* :enoent - A component of `path` does not exist.\n* :enospc - There is a no space left on the device.\n* :enotdir - A component of `path` is not a directory\n On some platforms, `:enoent` is returned instead.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L161",
:def,
161,
[ { :path,
[ line: 161 ],
nil } ] },
{ ExDoc.FunctionNode,
:mkdir!,
1,
"mkdir!/1",
"Same as `mkdir`, but raises an exception in case of failure. Otherwise `:ok`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L168",
:def,
168,
[ { :path,
[ line: 168 ],
nil } ] },
{ ExDoc.FunctionNode,
:mkdir_p,
1,
"mkdir_p/1",
"Tries to create the directory `path`. Missing parent directories are created.\nReturns `:ok` if successful, or `{:error, reason}` if an error occurs.\n\nTypical error reasons are:\n\n* :eacces - Missing search or write permissions for the parent directories of `path`.\n* :enospc - There is a no space left on the device.\n* :enotdir - A component of `path` is not a directory.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L186",
:def,
186,
[ { :path,
[ line: 186 ],
nil } ] },
{ ExDoc.FunctionNode,
:mkdir_p!,
1,
"mkdir_p!/1",
"Same as `mkdir_p`, but raises an exception in case of failure. Otherwise `:ok`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L193",
:def,
193,
[ { :path,
[ line: 193 ],
nil } ] },
{ ExDoc.FunctionNode,
:open,
2,
"open/2",
"Opens the given `path` according to the given list of modes.\n\nIn order to write and read files, one must use the functions\nin the IO module. By default, a file is opened in binary mode\nwhich requires the functions `IO.binread`, `IO.binwrite` and\n`IO.binreadline` to interact with the file. A developer may pass\n`:utf8` as an option when opening the file and then all other\nfunctions from IO are available, since they work directly with\nUnicode data.\n\nThe allowed modes:\n\n* `:read` - The file, which must exist, is opened for reading.\n\n* `:write` - The file is opened for writing. It is created if it does not exist.\n If the file exists, and if write is not combined with read, the file will be truncated.\n\n* `:append` - The file will be opened for writing, and it will be created if it does not exist.\n Every write operation to a file opened with append will take place at the end of the file.\n\n* `:exclusive` - The file, when opened for writing, is created if it does not exist.\n If the file exists, open will return { :error, :eexist }.\n\n* `:charlist` - When this term is given, read operations on the file will return char lists rather than binaries;\n\n* `:compressed` - Makes it possible to read or write gzip compressed files.\n The compressed option must be combined with either read or write, but not both.\n Note that the file size obtained with `stat/1` will most probably not\n match the number of bytes that can be read from a compressed file.\n\n* `:utf8` - This option denotes how data is actually stored in the disk file and\n makes the file perform automatic translation of characters to and from utf-8.\n If data is sent to a file in a format that cannot be converted to the utf-8\n or if data is read by a function that returns data in a format that cannot cope\n with the character range of the data, an error occurs and the file will be closed.\n\nIf a function is given to modes (instead of a list), it dispatches to `open/3`.\n\nCheck `http://www.erlang.org/doc/man/file.html#open-2` for more information about\nother options as `read_ahead` and `delayed_write`.\n\nThis function returns:\n\n* { :ok, io_device } - The file has been opened in the requested mode.\n `io_device` is actually the pid of the process which handles the file.\n This process is linked to the process which originally opened the file.\n If any process to which the io_device is linked terminates, the file will\n be closed and the process itself will be terminated. An io_device returned\n from this call can be used as an argument to the `IO` module functions.\n\n* { :error, reason } - The file could not be opened.\n\n## Examples\n\n { :ok, file } = File.open(\"foo.tar.gz\", [:read, :compressed])\n IO.readline(file)\n File.close(file)\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L772",
:def,
772,
[ { :path,
[ line: 772 ],
nil },
{ ://,
[ line: 772 ],
[ { :modes,
[ line: 772 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:open,
3,
"open/3",
"Similar to `open/2` but expects a function as last argument.\n\nThe file is opened, given to the function as argument and\nautomatically closed after the function returns, regardless\nif there was an error or not.\n\nIt returns `{ :ok, function_result }` in case of success,\n`{ :error, reason }` otherwise.\n\nDo not use this function with :delayed_write option\nsince automatically closing the file may fail\n(as writes are delayed).\n\n## Examples\n\n File.open(\"file.txt\", [:read, :write], fn(file) ->\n IO.readline(file)\n end)\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L803",
:def,
803,
[ { :path,
[ line: 803 ],
nil },
{ :modes,
[ line: 803 ],
nil },
{ :function,
[ line: 803 ],
nil } ] },
{ ExDoc.FunctionNode,
:open!,
2,
"open!/2",
"Same as `open/2` but raises an error if file could not be opened.\nReturns the `io_device` otherwise.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L819",
:def,
819,
[ { :path,
[ line: 819 ],
nil },
{ ://,
[ line: 819 ],
[ { :modes,
[ line: 819 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:open!,
3,
"open!/3",
"Same as `open/3` but raises an error if file could not be opened.\nReturns the function result otherwise.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L831",
:def,
831,
[ { :path,
[ line: 831 ],
nil },
{ :modes,
[ line: 831 ],
nil },
{ :function,
[ line: 831 ],
nil } ] },
{ ExDoc.FunctionNode,
:read,
1,
"read/1",
"Returns `{:ok, binary}`, where `binary` is a binary data object that contains the contents\nof `path`, or `{:error, reason}` if an error occurs.\n\nTypical error reasons:\n\n* :enoent - The file does not exist.\n* :eacces - Missing permission for reading the file,\n or for searching one of the parent directories.\n* :eisdir - The named file is a directory.\n* :enotdir - A component of the file name is not a directory.\n On some platforms, `:enoent` is returned instead.\n* :enomem - There is not enough memory for the contents of the file.\n\nYou can use `:file.format_error(reason)` to get a descriptive string of the error.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L217",
:def,
217,
[ { :path,
[ line: 217 ],
nil } ] },
{ ExDoc.FunctionNode,
:read!,
1,
"read!/1",
"Returns binary with the contents of the given filename or raises\nFile.Error if an error occurs.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L225",
:def,
225,
[ { :path,
[ line: 225 ],
nil } ] },
{ ExDoc.FunctionNode,
:regular?,
1,
"regular?/1",
"Returns true if the path is a regular file.\n\n## Examples\n\n File.regular? __FILE__ #=> true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L116",
:def,
116,
[ { :path,
[ line: 116 ],
nil } ] },
{ ExDoc.FunctionNode,
:rm,
1,
"rm/1",
"Tries to delete the file `path`.\nReturns `:ok` if successful, or `{:error, reason}` if an error occurs.\n\nTypical error reasons are:\n\n* :enoent - The file does not exist.\n* :eacces - Missing permission for the file or one of its parents.\n* :eperm - The file is a directory and user is not super-user.\n* :enotdir - A component of the file name is not a directory.\n On some platforms, enoent is returned instead.\n* :einval - Filename had an improper type, such as tuple.\n\n## Examples\n\n File.rm('file.txt')\n #=> :ok\n\n File.rm('tmp_dir/')\n #=> {:error, :eperm}\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L596",
:def,
596,
[ { :path,
[ line: 596 ],
nil } ] },
{ ExDoc.FunctionNode,
:rm!,
1,
"rm!/1",
"Same as `rm`, but raises an exception in case of failure. Otherwise `:ok`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L603",
:def,
603,
[ { :path,
[ line: 603 ],
nil } ] },
{ ExDoc.FunctionNode,
:rm_rf,
1,
"rm_rf/1",
"Remove files and directories recursively at the given `path`.\nSymlinks are not followed but simply removed, non existing\nfiles are simply ignored (i.e. doesn't make this function fail).\n\nReturns `{ :ok, files_and_directories }` with all files and\ndirectories removed in no specific order, `{ :error, reason }`\notherwise.\n\n## Examples\n\n File.rm_rf \"samples\"\n #=> { :ok, [\"samples\", \"samples/1.txt\"] }\n\n File.rm_rf \"unknown\"\n #=> { :ok, [] }\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L657",
:def,
657,
[ { :path,
[ line: 657 ],
nil } ] },
{ ExDoc.FunctionNode,
:rm_rf!,
1,
"rm_rf!/1",
"Same as `rm_rf/1` but raises `File.Error` in case of failures,\notherwise the list of files or directories removed.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L704",
:def,
704,
[ { :path,
[ line: 704 ],
nil } ] },
{ ExDoc.FunctionNode,
:rmdir,
1,
"rmdir/1",
"Tries to delete the dir at `path`.\nReturns `:ok` if successful, or `{:error, reason}` if an error occurs.\n\n## Examples\n\n File.rddir('tmp_dir')\n #=> :ok\n\n File.rmdir('file.txt')\n #=> {:error, :enotdir}\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L624",
:def,
624,
[ { :path,
[ line: 624 ],
nil } ] },
{ ExDoc.FunctionNode,
:rmdir!,
1,
"rmdir!/1",
"Same as `rmdir/1`, but raises an exception in case of failure. Otherwise `:ok`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L631",
:def,
631,
[ { :path,
[ line: 631 ],
nil } ] },
{ ExDoc.FunctionNode,
:stat,
2,
"stat/2",
"Returns information about the `path`. If it exists, it\nreturns a `{ :ok, info }` tuple, where info is as a\n`File.Info` record. Retuns `{ :error, reason }` with\nthe same reasons as `File.read` if a failure occurs.\n\n## Options\n\nThe accepted options are:\n\n* `:time` if the time should be local, universal or posix.\n Default is local.\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L248",
:def,
248,
[ { :path,
[ line: 248 ],
nil },
{ ://,
[ line: 248 ],
[ { :opts,
[ line: 248 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:stat!,
2,
"stat!/2",
"Same as `stat` but returns the `File.Stat` directly and\nthrows `File.Error` if an error is returned.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L261",
:def,
261,
[ { :path,
[ line: 261 ],
nil },
{ ://,
[ line: 261 ],
[ { :opts,
[ line: 261 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:touch,
2,
"touch/2",
"Updates modification time (mtime) and access time (atime) of\nthe given file. File is created if it doesn’t exist.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L293",
:def,
293,
[ { :path,
[ line: 293 ],
nil },
{ ://,
[ line: 293 ],
[ { :time,
[ line: 293 ],
nil },
{ { :.,
[ line: 293 ],
[ :calendar,
:local_time ] },
[ line: 293 ],
[] } ] } ] },
{ ExDoc.FunctionNode,
:touch!,
2,
"touch!/2",
"Same as `touch/1` but raises an exception if it fails.\nReturns `:ok` otherwise.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L304",
:def,
304,
[ { :path,
[ line: 304 ],
nil },
{ ://,
[ line: 304 ],
[ { :time,
[ line: 304 ],
nil },
{ { :.,
[ line: 304 ],
[ :calendar,
:local_time ] },
[ line: 304 ],
[] } ] } ] },
{ ExDoc.FunctionNode,
:write,
3,
"write/3",
"Writes `content` to the file `path`. The file is created if it\ndoes not exist. If it exists, the previous contents are overwritten.\nReturns `:ok` if successful, or `{:error, reason}` if an error occurs.\n\nTypical error reasons are:\n\n* :enoent - A component of the file name does not exist.\n* :enotdir - A component of the file name is not a directory.\n On some platforms, enoent is returned instead.\n* :enospc - There is a no space left on the device.\n* :eacces - Missing permission for writing the file or searching one of the parent directories.\n* :eisdir - The named file is a directory.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L559",
:def,
559,
[ { :path,
[ line: 559 ],
nil },
{ :content,
[ line: 559 ],
nil },
{ ://,
[ line: 559 ],
[ { :modes,
[ line: 559 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:write!,
3,
"write!/3",
"Same as `write/3` but raises an exception if it fails, returns `:ok` otherwise.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L566",
:def,
566,
[ { :path,
[ line: 566 ],
nil },
{ :content,
[ line: 566 ],
nil },
{ ://,
[ line: 566 ],
[ { :modes,
[ line: 566 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:write_stat,
3,
"write_stat/3",
"Writes the given `File.Stat` back to the filesystem at the given\npath. Returns `:ok` or `{ :error, reason }`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L273",
:def,
273,
[ { :path,
[ line: 273 ],
nil },
{ :stat,
[ line: 273 ],
nil },
{ ://,
[ line: 273 ],
[ { :opts,
[ line: 273 ],
nil },
[] ] } ] },
{ ExDoc.FunctionNode,
:write_stat!,
3,
"write_stat!/3",
"Same as `write_stat/3` but raises an exception if it fails.\nReturns `:ok` otherwise.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L281",
:def,
281,
[ { :path,
[ line: 281 ],
nil },
{ :stat,
[ line: 281 ],
nil },
{ ://,
[ line: 281 ],
[ { :opts,
[ line: 281 ],
nil },
[] ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/file.ex#L55",
[],
nil,
"File",
55,
nil },
{ ExDoc.ModuleNode,
GenEvent.Behaviour,
"GenEvent.Behaviour",
"This module is a convenience to define GenEvent callbacks in Elixir.\n\nGenEvent is an OTP behaviour that encapsulates event handling functionality.\n\n## Example\n\nBellow follows an example of a GenEvent that stores notifications\nuntil they are fetched:\n\n defmodule MyEventHandler do\n use GenEvent.Behaviour\n\n # Callbacks\n\n def init(_) do\n { :ok, [] }\n end\n\n def handle_event({:notification, x}, notifications) do\n { :ok, [x|notifications] }\n end\n\n def handle_call(:notifications, notifications) do\n {:ok, Enum.reverse(notifications), []}\n end\n\n end\n\n { :ok, pid } = :gen_event.start_link\n\n :gen_event.add_handler(pid, MyEventHandler, [])\n\n :gen_event.notify(pid, {:notification, 1})\n :gen_event.notify(pid, {:notification, 2})\n \n :gen_event.call(pid, MyEventHandler, :notifications)\n #=> [1, 2]\n\n :gen_event.call(pid, MyEventHandler, :notifications)\n #=> []\n\nNotice we never call the server callbacks directly, they are called\nby OTP whenever we interact with the server. \n\nStarting and sending messages to gen_event is done\nvia Erlang's `:gen_event` module. For more information,\nplease refer to the following:\n\nhttp://www.erlang.org/doc/man/gen_event.html\nhttp://learnyousomeerlang.com/event-handlers\n",
[],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/gen_event/behaviour.ex#L1",
[],
nil,
"GenEvent.Behaviour",
1,
nil },
{ ExDoc.ModuleNode,
GenServer.Behaviour,
"GenServer.Behaviour",
"This module is a convenience to define GenServer callbacks in Elixir.\n\nA server is responsible to react to messages received from client\nand a GenServer is an OTP behaviour that encapsulates common server\nfunctionalities.\n\n## Example\n\nBellow follows an example of a GenServer that push and pop items\ninto a stack:\n\n defmodule MyServer do\n use GenServer.Behaviour\n\n # Callbacks\n\n def handle_call(:pop, _from, [h|t]) do\n { :reply, h, t }\n end\n\n def handle_call(_request, _from, _config) do\n # Call the default implementation from GenServer.Behaviour\n super\n end\n\n def handle_cast({ :push, item }, config) do\n { :noreply, [item|config] }\n end\n\n def handle_cast(_request, _config) do\n super\n end\n end\n\n { :ok, pid } = :gen_server.start_link(MyServer, [:hello], [])\n\n :gen_server.call(pid, :pop)\n #=> :hello\n\n :gen_server.cast(pid, { :push, :world })\n #=> :ok\n\n :gen_server.call(pid, :pop)\n #=> :world\n\nNotice we never call the server callbacks directly, they are called\nby OTP whenever we interact with the server. **cast** messages are\nasynchronous while **call** ones are synchronous. In the case of\nGenServer's, there are 8 different values a callback such as\n`handle_call` or `handle_cast` can return:\n\n { :reply, reply, new_state }\n { :reply, reply, new_state, timeout }\n { :reply, reply, new_state, :hibernate }\n { :noreply, new_state }\n { :noreply, new_state, timeout }\n { :noreply, new_state, :hibernate }\n { :stop, reason, new_state }\n { :stop, reason, reply, new_state }\n\nThere are 6 callbacks required to be implemented in a GenServer. The\n`GenServer.Behaviour` module defines all of them automatically, but\nallows us to customize the ones we need. The list of callbacks are:\n\n* `init(args)` - invoked when the server is started;\n* `handle_call(msg, from, state)` - invoked to handle call messages;\n* `handle_cast(msg, state)` - invoked to handle cast messages;\n* `handle_info(msg, state)` - handle all other messages which are\n normally received by processes;\n* `terminate(reason, state)` - called when the server is about to\n terminate, useful for cleaning up;\n* `code_change(old_vsn, state, extra)` - called when the application\n code is being upgraded live (hot code swap);\n\nStarting and sending messages to the gen_server is done\nvia Erlang's `:gen_server` module. For more information,\nplease refer to the following:\n\nhttp://www.erlang.org/doc/man/gen_server.html\nhttp://www.erlang.org/doc/design_principles/gen_server_concepts.html\nhttp://learnyousomeerlang.com/clients-and-servers\n",
[],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/gen_server/behaviour.ex#L1",
[],
nil,
"GenServer.Behaviour",
1,
nil },
{ ExDoc.ModuleNode,
HashDict,
"HashDict",
"A key-value store.\n\nThe `HashDict` is meant to work well with both small and\nlarge set of keys and it is an implementation of the `Dict`\nbehaviour. For more information about the functions and\ntheir APIs, please consult the `Dict` module.\n",
[ { ExDoc.FunctionNode,
:delete,
2,
"delete/2",
"Deletes a value from the dict.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L186",
:def,
186,
[ { :dict,
[ line: 186 ],
nil },
{ :key,
[ line: 186 ],
nil } ] },
{ ExDoc.FunctionNode,
:empty,
1,
"empty/1",
"Returns an empty dict.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L225",
:def,
225,
[ { :_,
[ line: 225 ],
:guess } ] },
{ ExDoc.FunctionNode,
:equal?,
2,
"equal?/2",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L229",
:def,
229,
[ { :a,
[ line: 233 ],
nil },
{ :b,
[ line: 233 ],
nil } ] },
{ ExDoc.FunctionNode,
:fetch,
2,
"fetch/2",
"Fetches the value under key from the dict\nand return it in a tagged tuple.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L169",
:def,
169,
[ { :dict,
[ line: 169 ],
nil },
{ :key,
[ line: 169 ],
nil } ] },
{ ExDoc.FunctionNode,
:get,
3,
"get/3",
"Gets the value under key from the dict.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L147",
:def,
147,
[ { :dict,
[ line: 147 ],
nil },
{ :key,
[ line: 147 ],
nil },
{ ://,
[ line: 147 ],
[ { :default,
[ line: 147 ],
nil },
nil ] } ] },
{ ExDoc.FunctionNode,
:get!,
2,
"get!/2",
"Gets the value under key from the dict,\nraises KeyError if such key does not exist.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L158",
:def,
158,
[ { :dict,
[ line: 158 ],
nil },
{ :key,
[ line: 158 ],
nil } ] },
{ ExDoc.FunctionNode,
:has_key?,
2,
"has_key?/2",
"Checks if the dict has the given key.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L179",
:def,
179,
[ { :dict,
[ line: 179 ],
nil },
{ :key,
[ line: 179 ],
nil } ] },
{ ExDoc.FunctionNode,
:keys,
1,
"keys/1",
"Get all keys in the dict.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L263",
:def,
263,
[ { :dict,
[ line: 263 ],
nil } ] },
{ ExDoc.FunctionNode,
:merge,
3,
"merge/3",
"Merges two dictionaries.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L277",
:def,
277,
[ { :dict,
[ line: 277 ],
nil },
{ :enum,
[ line: 277 ],
nil },
{ ://,
[ line: 277 ],
[ { :callback,
[ line: 277 ],
nil },
{ :fn,
[ line: 277 ],
[ [ do: { :"->",
[ line: 277 ],
[ { [ { :_k,
[ line: 277 ],
nil },
{ :_v1,
[ line: 277 ],
nil },
{ :v2,
[ line: 277 ],
nil } ],
{ :v2,
[ line: 277 ],
nil } } ] } ] ] } ] } ] },
{ ExDoc.FunctionNode,
:new,
0,
"new/0",
"Creates a new empty dict.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L66",
:def,
66,
[] },
{ ExDoc.FunctionNode,
:new,
1,
"new/1",
"Creates a new dict from the given enumerable.\n\n## Examples\n\n HashDict.new [{:b,1},{:a,2}]\n #=> #HashDict<[a: 2, b: 1]>\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L80",
:def,
80,
[ { :pairs,
[ line: 80 ],
nil } ] },
{ ExDoc.FunctionNode,
:new,
2,
"new/2",
"Creates a new dict from the enumerable with the\nhelp of the transformation function.\n\n## Examples\n\n HashDict.new [\"a\", \"b\"], fn x -> {x, x} end\n #=> #HashDict<[{\"a\",\"a\"},{\"b\",\"b\"}]>\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L97",
:def,
97,
[ { :list,
[ line: 97 ],
nil },
{ :transform,
[ line: 97 ],
nil } ] },
{ ExDoc.FunctionNode,
:put,
3,
"put/3",
"Puts the given key and value in the dict.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L107",
:def,
107,
[ { :dict,
[ line: 107 ],
nil },
{ :key,
[ line: 107 ],
nil },
{ :value,
[ line: 107 ],
nil } ] },
{ ExDoc.FunctionNode,
:put_new,
3,
"put_new/3",
"Puts the given value under key in the dictionary\nonly if one does not exist yet.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L116",
:def,
116,
[ { :dict,
[ line: 116 ],
nil },
{ :key,
[ line: 116 ],
nil },
{ :value,
[ line: 116 ],
nil } ] },
{ ExDoc.FunctionNode,
:size,
1,
"size/1",
"Returns the dict size.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L218",
:def,
218,
[ { :dict,
[ line: 218 ],
nil } ] },
{ ExDoc.FunctionNode,
:to_list,
1,
"to_list/1",
"Converts the dict to a list.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L252",
:def,
252,
[ { :dict,
[ line: 256 ],
nil } ] },
{ ExDoc.FunctionNode,
:update,
3,
"update/3",
"Updates the key in the dictionary according\nto the given function. Raises if the key does\nnot exist in the dictionary.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L125",
:def,
125,
[ { :dict,
[ line: 125 ],
nil },
{ :key,
[ line: 125 ],
nil },
{ :fun,
[ line: 125 ],
nil } ] },
{ ExDoc.FunctionNode,
:update,
4,
"update/4",
"Updates the key in the dictionary according\nto the given function. Adds initial value if\nthe key does not exist in the dicionary.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L139",
:def,
139,
[ { :dict,
[ line: 139 ],
nil },
{ :key,
[ line: 139 ],
nil },
{ :initial,
[ line: 139 ],
nil },
{ :fun,
[ line: 139 ],
nil } ] },
{ ExDoc.FunctionNode,
:values,
1,
"values/1",
"Get all values in the dict.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L270",
:def,
270,
[ { :dict,
[ line: 270 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/hash_dict.ex#L1",
[],
nil,
"HashDict",
1,
nil },
{ ExDoc.ModuleNode,
IEx,
"IEx",
"This module implements Interactive Elixir.\n\nThe interactive elixir needs to be set as the\nproper `-user` when starting the Erlang VM and\nso can be done with the help of IEx.CLI.\n\nIf possible, Elixir will start a tty (smart terminal)\nwhich makes all control commands available in tty\navailable to the developer.\n\nIn case `tty` is not available (for example, Windows),\na dumb terminal version is started instead.\n",
[ { ExDoc.FunctionNode,
:after_spawn,
0,
"after_spawn/0",
"Returns registered after spawn callbacks.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L29",
:def,
29,
[] },
{ ExDoc.FunctionNode,
:after_spawn,
1,
"after_spawn/1",
"Registers a function to be invoked after IEx process is spawned.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L22",
:def,
22,
[ { :fun,
[ line: 22 ],
nil } ] },
{ ExDoc.FunctionNode,
:inspect_opts,
0,
"inspect_opts/0",
"Returns currently registered inspect options.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L51",
:def,
51,
[] },
{ ExDoc.FunctionNode,
:inspect_opts,
1,
"inspect_opts/1",
"Registers options used on inspect.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L44",
:def,
44,
[ { :opts,
[ line: 44 ],
nil } ] },
{ ExDoc.FunctionNode,
:started?,
0,
"started?/0",
"Returns true if IEx was properly started.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L37",
:def,
37,
[] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L3",
[ { ExDoc.ModuleNode,
IEx.Autocomplete,
"Autocomplete",
"Autocompletion for the Elixir shell.\n",
[ { ExDoc.FunctionNode,
:expand,
1,
"expand/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/autocomplete.ex#L48",
:def,
48,
[ { :expr,
[ line: 54 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/autocomplete.ex#L1",
[],
nil,
"IEx.Autocomplete",
1,
{ ExDoc.ModuleNode,
IEx,
"IEx",
"This module implements Interactive Elixir.\n\nThe interactive elixir needs to be set as the\nproper `-user` when starting the Erlang VM and\nso can be done with the help of IEx.CLI.\n\nIf possible, Elixir will start a tty (smart terminal)\nwhich makes all control commands available in tty\navailable to the developer.\n\nIn case `tty` is not available (for example, Windows),\na dumb terminal version is started instead.\n",
[ { ExDoc.FunctionNode,
:after_spawn,
0,
"after_spawn/0",
"Returns registered after spawn callbacks.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L29",
:def,
29,
[] },
{ ExDoc.FunctionNode,
:after_spawn,
1,
"after_spawn/1",
"Registers a function to be invoked after IEx process is spawned.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L22",
:def,
22,
[ { :fun,
[ line: 22 ],
nil } ] },
{ ExDoc.FunctionNode,
:inspect_opts,
0,
"inspect_opts/0",
"Returns currently registered inspect options.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L51",
:def,
51,
[] },
{ ExDoc.FunctionNode,
:inspect_opts,
1,
"inspect_opts/1",
"Registers options used on inspect.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L44",
:def,
44,
[ { :opts,
[ line: 44 ],
nil } ] },
{ ExDoc.FunctionNode,
:started?,
0,
"started?/0",
"Returns true if IEx was properly started.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L37",
:def,
37,
[] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L3",
[],
nil,
"IEx",
3,
nil } },
{ ExDoc.ModuleNode,
IEx.Helpers,
"Helpers",
"Welcome to Interactive Elixir. You are currently\nseeing the documentation for the module IEx.Helpers\nwhich provides many helpers to make Elixir's shell\nmore joyful to work with.\n\nThis message was triggered by invoking the helper\n`h()`, usually referred as `h/0` (since it expects 0\narguments).\n\nThere are many other helpers available:\n\n* `c/2` - compiles a file in the given path\n* `ls/0` - list the contents of the current directory\n* `ls/1` - list the contents of the specified directory\n* `cd/1` - changes the current directory\n* `flush/0` — flush all messages sent to the shell\n* `h/0`, `h/1` - prints help/documentation\n* `l/1` - loads given module beam code by purging the current version\n* `m/0` - prints loaded modules\n* `pwd/0` - prints the current working directory\n* `r/0`, `r/1` - recompiles and reloads the given module's source file\n* `s/1` — prints spec information\n* `t/1` — prints type information\n* `v/0` - prints all commands and values\n* `v/1` - retrieves nth value from console\n\nHelp for functions in this module can be consulted\ndirectly from the command line, as an example, try:\n\n h(c/2)\n\nYou can also retrieve the documentation for any module\nor function. Try these:\n\n h(Enum)\n h(Enum.reverse/1)\n\n",
[ { ExDoc.FunctionNode,
:c,
2,
"c/2",
"Expects a list of files to compile and a path\nto write their object code to. It returns the name\nof the compiled modules.\n\n## Examples\n\n c [\"foo.ex\"], \"ebin\"\n #=> [Foo]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L53",
:def,
53,
[ { :files,
[ line: 53 ],
nil },
{ ://,
[ line: 53 ],
[ { :path,
[ line: 53 ],
nil },
"." ] } ] },
{ ExDoc.FunctionNode,
:cd,
1,
"cd/1",
"Changes the shell directory to the given path.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L302",
:def,
302,
[ { :directory,
[ line: 302 ],
nil } ] },
{ ExDoc.FunctionNode,
:flush,
0,
"flush/0",
"Flushes all messages sent to the shell and prints them out\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L258",
:def,
258,
[] },
{ ExDoc.FunctionNode,
:h,
0,
"h/0",
"Shows the documentation for IEx.Helpers.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L87",
:def,
87,
[] },
{ ExDoc.FunctionNode,
:h,
1,
"h/1",
"Shows the documentation for the given module\nor for the given function/arity pair.\n\n## Examples\n\n h(Enum)\n #=> Prints documentation for Enum\n\nIt also accepts functions in the format `fun/arity`\nand `module.fun/arity`, for example:\n\n h receive/1\n h Enum.all?/2\n h Enum.all?\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L108",
:defmacro,
108,
[ { :other,
[ line: 132 ],
nil } ] },
{ ExDoc.FunctionNode,
:l,
1,
"l/1",
"Purges and reloads specified module\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L250",
:def,
250,
[ { :module,
[ line: 250 ],
nil } ] },
{ ExDoc.FunctionNode,
:ls,
1,
"ls/1",
"Produces a simple list of a directory's contents.\nIf `path` points to a file, prints its full path.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L314",
:def,
314,
[ { ://,
[ line: 314 ],
[ { :path,
[ line: 314 ],
nil },
"." ] } ] },
{ ExDoc.FunctionNode,
:m,
0,
"m/0",
"Returns the name and module of all modules loaded.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L61",
:def,
61,
[] },
{ ExDoc.FunctionNode,
:pwd,
0,
"pwd/0",
"Prints the current working directory.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L295",
:def,
295,
[] },
{ ExDoc.FunctionNode,
:r,
0,
"r/0",
"Reloads all modules that were already reloaded\nat some point with `r/1`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L228",
:def,
228,
[] },
{ ExDoc.FunctionNode,
:r,
1,
"r/1",
"Recompiles and reloads the specified module's source file.\n\nPlease note that all the modules defined in the specified\nfiles are recompiled and reloaded.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L238",
:def,
238,
[ { :module,
[ line: 238 ],
nil } ] },
{ ExDoc.FunctionNode,
:s,
1,
"s/1",
"Prints all specs from a given module.\n\n## Examples\n\n s(Enum)\n s(Enum.all?)\n s(Enum.all?/2)\n s(list_to_atom)\n s(list_to_atom/1)\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L179",
:defmacro,
179,
[ { :module,
[ line: 203 ],
nil } ] },
{ ExDoc.FunctionNode,
:t,
1,
"t/1",
"Prints all types for the given module or prints out a specified type's\nspecification\n\n## Examples\n\n t(Enum)\n t(Enum.t/0)\n t(Enum.t)\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L149",
:defmacro,
149,
[ { :module,
[ line: 161 ],
nil } ] },
{ ExDoc.FunctionNode,
:v,
0,
"v/0",
"Prints commands history and their result.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L75",
:def,
75,
[] },
{ ExDoc.FunctionNode,
:v,
1,
"v/1",
"Retrieves nth query's value from the history. Use negative\nvalues to lookup query's value from latest to earliest.\nFor instance, v(-1) returns the latest result.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L214",
:def,
214,
[ { :n,
[ line: 214 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/helpers.ex#L1",
[],
nil,
"IEx.Helpers",
1,
{ ExDoc.ModuleNode,
IEx,
"IEx",
"This module implements Interactive Elixir.\n\nThe interactive elixir needs to be set as the\nproper `-user` when starting the Erlang VM and\nso can be done with the help of IEx.CLI.\n\nIf possible, Elixir will start a tty (smart terminal)\nwhich makes all control commands available in tty\navailable to the developer.\n\nIn case `tty` is not available (for example, Windows),\na dumb terminal version is started instead.\n",
[ { ExDoc.FunctionNode,
:after_spawn,
0,
"after_spawn/0",
"Returns registered after spawn callbacks.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L29",
:def,
29,
[] },
{ ExDoc.FunctionNode,
:after_spawn,
1,
"after_spawn/1",
"Registers a function to be invoked after IEx process is spawned.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L22",
:def,
22,
[ { :fun,
[ line: 22 ],
nil } ] },
{ ExDoc.FunctionNode,
:inspect_opts,
0,
"inspect_opts/0",
"Returns currently registered inspect options.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L51",
:def,
51,
[] },
{ ExDoc.FunctionNode,
:inspect_opts,
1,
"inspect_opts/1",
"Registers options used on inspect.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L44",
:def,
44,
[ { :opts,
[ line: 44 ],
nil } ] },
{ ExDoc.FunctionNode,
:started?,
0,
"started?/0",
"Returns true if IEx was properly started.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L37",
:def,
37,
[] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L3",
[],
nil,
"IEx",
3,
nil } },
{ ExDoc.ModuleNode,
IEx.Remsh,
"Remsh",
"Helper function injected into connecting remote nodes\nto properly handle autocompletion. Elixir supports:\n\n* remsh from an elixir node to an elixir node\n* remsh from a plain erlang node to an elixir node (through the ^G menu)\n* remsh from an elixir node to a plain erlang node (and get an erl shell there)\n\nIn order to get an Elixir shell from the ^G menu,\nyou need to use 'Elixir-IEx' as the shell name.\n\nConnecting an Elixir shell to a remote node without\nElixir is **not** supported.\n",
[ { ExDoc.FunctionNode,
:expand,
1,
"expand/1",
nil,
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/remsh.ex#L16",
:def,
16,
[ { :node,
[ line: 16 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex/remsh.ex#L1",
[],
nil,
"IEx.Remsh",
1,
{ ExDoc.ModuleNode,
IEx,
"IEx",
"This module implements Interactive Elixir.\n\nThe interactive elixir needs to be set as the\nproper `-user` when starting the Erlang VM and\nso can be done with the help of IEx.CLI.\n\nIf possible, Elixir will start a tty (smart terminal)\nwhich makes all control commands available in tty\navailable to the developer.\n\nIn case `tty` is not available (for example, Windows),\na dumb terminal version is started instead.\n",
[ { ExDoc.FunctionNode,
:after_spawn,
0,
"after_spawn/0",
"Returns registered after spawn callbacks.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L29",
:def,
29,
[] },
{ ExDoc.FunctionNode,
:after_spawn,
1,
"after_spawn/1",
"Registers a function to be invoked after IEx process is spawned.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L22",
:def,
22,
[ { :fun,
[ line: 22 ],
nil } ] },
{ ExDoc.FunctionNode,
:inspect_opts,
0,
"inspect_opts/0",
"Returns currently registered inspect options.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L51",
:def,
51,
[] },
{ ExDoc.FunctionNode,
:inspect_opts,
1,
"inspect_opts/1",
"Registers options used on inspect.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L44",
:def,
44,
[ { :opts,
[ line: 44 ],
nil } ] },
{ ExDoc.FunctionNode,
:started?,
0,
"started?/0",
"Returns true if IEx was properly started.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L37",
:def,
37,
[] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/iex/lib/iex.ex#L3",
[],
nil,
"IEx",
3,
nil } } ],
nil,
"IEx",
3,
nil },
{ ExDoc.ModuleNode,
IO,
"IO",
"Module responsible for doing IO. Many functions in this\nmodule expects an IO device and an io data encoded in UTF-8.\n\nAn IO device must be a pid or an atom representing a process.\nFor convenience, Elixir provides `:stdio` and `:stderr` as\nshortcut to Erlang's `:standard_io` and `:standard_error`.\n\nAn io data can be:\n\n* A list of integers representing a string. Any unicode\n character must be represented with one entry in the list,\n this entry being an integer with the codepoint value;\n\n* A binary in which unicode characters are represented\n with many bytes (Elixir's default representation);\n\n* A list of binaries or a list of char lists (as described above);\n\n* If none of the above, `to_binary` is invoked in the\n given argument;\n\n",
[ { ExDoc.FunctionNode,
:binread,
2,
"binread/2",
"Reads `count` bytes from the IO device as binary,\nno unicode conversion happens.\n\nCheck `read/2` for more information.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L49",
:def,
49,
[ { ://,
[ line: 49 ],
[ { :device,
[ line: 49 ],
nil },
{ :group_leader,
[ line: 49 ],
[] } ] },
{ :count,
[ line: 49 ],
nil } ] },
{ ExDoc.FunctionNode,
:binreadline,
1,
"binreadline/1",
"Reads a line from the IO device as binary,\nno unicode conversion happens.\n\nCheck `readline/1` for more information.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L80",
:def,
80,
[ { ://,
[ line: 80 ],
[ { :device,
[ line: 80 ],
nil },
{ :group_leader,
[ line: 80 ],
[] } ] } ] },
{ ExDoc.FunctionNode,
:binwrite,
2,
"binwrite/2",
"Writes the given argument to the given device\nas a binary, no unicode conversion happens.\n\nCheck `write/2` for more information.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L114",
:def,
114,
[ { ://,
[ line: 114 ],
[ { :device,
[ line: 114 ],
nil },
{ :group_leader,
[ line: 114 ],
[] } ] },
{ :item,
[ line: 114 ],
nil } ] },
{ ExDoc.FunctionNode,
:getb,
2,
"getb/2",
"Gets `count` bytes from the IO device. It returns:\n\n* `data` - The input characters.\n\n* :eof - End of file was encountered.\n\n* {:error, reason} - Other (rare) error condition,\n for instance {:error, :estale} if reading from an\n NFS file system.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L160",
:def,
160,
[ { :prompt,
[ line: 160 ],
nil },
{ ://,
[ line: 160 ],
[ { :count,
[ line: 160 ],
nil },
1 ] } ] },
{ ExDoc.FunctionNode,
:getb,
3,
"getb/3",
"Gets `count` bytes from the chosen IO device.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L173",
:def,
173,
[ { :device,
[ line: 173 ],
nil },
{ :prompt,
[ line: 173 ],
nil },
{ :count,
[ line: 173 ],
nil } ] },
{ ExDoc.FunctionNode,
:gets,
2,
"gets/2",
"Reads a line from the IO device. It returns:\n\n* `data` - The characters in the line terminated\n by a LF (or end of file).\n\n* :eof - End of file was encountered.\n\n* {:error, reason} - Other (rare) error condition,\n for instance {:error, :estale} if reading from an\n NFS file system.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L189",
:def,
189,
[ { ://,
[ line: 189 ],
[ { :device,
[ line: 189 ],
nil },
{ :group_leader,
[ line: 189 ],
[] } ] },
{ :prompt,
[ line: 189 ],
nil } ] },
{ ExDoc.FunctionNode,
:inspect,
2,
"inspect/2",
"Inspects and writes the given argument to the device\nfollowed by a new line. A set of options can be given.\n\n## Examples\n\n IO.inspect Process.list\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L137",
:def,
137,
[ { :item,
[ line: 137 ],
nil },
{ ://,
[ line: 137 ],
[ { :opts,
[ line: 137 ],
nil },
[ pretty: true ] ] } ] },
{ ExDoc.FunctionNode,
:inspect,
3,
"inspect/3",
"Inspects the item with options using the given device.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L144",
:def,
144,
[ { :device,
[ line: 144 ],
nil },
{ :item,
[ line: 144 ],
nil },
{ :opts,
[ line: 144 ],
nil } ] },
{ ExDoc.FunctionNode,
:puts,
2,
"puts/2",
"Writes the argument to the device, similarly to write\nbut adds a new line at the end. The argument is expected\nto be a chardata.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L123",
:def,
123,
[ { ://,
[ line: 123 ],
[ { :device,
[ line: 123 ],
nil },
{ :group_leader,
[ line: 123 ],
[] } ] },
{ :item,
[ line: 123 ],
nil } ] },
{ ExDoc.FunctionNode,
:read,
2,
"read/2",
"Reads `count` bytes from the IO device. It returns:\n\n* `data` - The input characters.\n\n* :eof - End of file was encountered.\n\n* {:error, reason} - Other (rare) error condition,\n for instance {:error, :estale} if reading from an\n NFS file system.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L39",
:def,
39,
[ { ://,
[ line: 39 ],
[ { :device,
[ line: 39 ],
nil },
{ :group_leader,
[ line: 39 ],
[] } ] },
{ :count,
[ line: 39 ],
nil } ] },
{ ExDoc.FunctionNode,
:readline,
1,
"readline/1",
"Reads a line from the IO device. It returns:\n\n* `data` - The input characters.\n\n* :eof - End of file was encountered.\n\n* {:error, reason} - Other (rare) error condition,\n for instance {:error, :estale} if reading from an\n NFS file system.\n\nThis function does the same as `gets/2`,\nexcept the prompt is not required as argument.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L70",
:def,
70,
[ { ://,
[ line: 70 ],
[ { :device,
[ line: 70 ],
nil },
{ :group_leader,
[ line: 70 ],
[] } ] } ] },
{ ExDoc.FunctionNode,
:write,
2,
"write/2",
"Writes the given argument to the given device.\nBy default the device is the standard output.\nThe argument is expected to be a chardata (i.e.\na char list or an unicode binary).\n\nIt returns `:ok` if it succeeds.\n\n## Examples\n\n IO.write \"sample\"\n #=> \"sample\"\n\n IO.write :stderr, \"error\"\n #=> \"error\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L104",
:def,
104,
[ { ://,
[ line: 104 ],
[ { :device,
[ line: 104 ],
nil },
{ :group_leader,
[ line: 104 ],
[] } ] },
{ :item,
[ line: 104 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L1",
[ { ExDoc.ModuleNode,
IO.ANSI,
"ANSI",
"This module provides functionality to render ANSI escape sequences\n(http://en.wikipedia.org/wiki/ANSI_escape_code) — characters embedded\nin the text used to control formatting, color, and other output options\non video text terminals.\n\nPlease be aware that in Erlang/OTP versions prior to R16, you will not\nbe able to render ANSI escape sequences in iex or erlang shell\n",
[ { ExDoc.FunctionNode,
:black,
0,
"black/0",
"Sets foreground color to black",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L116",
:def,
116,
[] },
{ ExDoc.FunctionNode,
:black_background,
0,
"black_background/0",
"Sets background color to black",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L119",
:def,
119,
[] },
{ ExDoc.FunctionNode,
:blink_off,
0,
"blink_off/0",
"Blink: off",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L109",
:def,
109,
[] },
{ ExDoc.FunctionNode,
:blink_rapid,
0,
"blink_rapid/0",
"Blink: Rapid. MS-DOS ANSI.SYS; 150 per minute or more; not widely supported",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L77",
:def,
77,
[] },
{ ExDoc.FunctionNode,
:blink_slow,
0,
"blink_slow/0",
"Blink: Slow. Less than 150 per minute",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L74",
:def,
74,
[] },
{ ExDoc.FunctionNode,
:blue,
0,
"blue/0",
"Sets foreground color to blue",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L116",
:def,
116,
[] },
{ ExDoc.FunctionNode,
:blue_background,
0,
"blue_background/0",
"Sets background color to blue",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L119",
:def,
119,
[] },
{ ExDoc.FunctionNode,
:bright,
0,
"bright/0",
"Bright (increased intensity) or Bold",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L62",
:def,
62,
[] },
{ ExDoc.FunctionNode,
:conceal,
0,
"conceal/0",
"Conceal. Not widely supported",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L86",
:def,
86,
[] },
{ ExDoc.FunctionNode,
:crossed_out,
0,
"crossed_out/0",
"Crossed-out. Characters legible, but marked for deletion. Not widely supported.",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L89",
:def,
89,
[] },
{ ExDoc.FunctionNode,
:cyan,
0,
"cyan/0",
"Sets foreground color to cyan",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L116",
:def,
116,
[] },
{ ExDoc.FunctionNode,
:cyan_background,
0,
"cyan_background/0",
"Sets background color to cyan",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L119",
:def,
119,
[] },
{ ExDoc.FunctionNode,
:default_background,
0,
"default_background/0",
"Default background color",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L126",
:def,
126,
[] },
{ ExDoc.FunctionNode,
:default_color,
0,
"default_color/0",
"Default text color",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L123",
:def,
123,
[] },
{ ExDoc.FunctionNode,
:encircled,
0,
"encircled/0",
"Encircled",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L132",
:def,
132,
[] },
{ ExDoc.FunctionNode,
:escape,
2,
"escape/2",
"Escapes a string coverting named ANSI sequences into actual ANSI codes.\n\nThe format for referring sequences is `` and `` (for\nmultiple sequences)\n\nIt will also force a to get appended to every string. If you don't\nwant this behaviour, use `escape_fragment/1` and `escape_fragment/2`.\n\nAn optional boolean parameter can be passed to enable or disable\nemitting actual ANSI codes. When false, no ANSI codes will emitted.\nBy default, standard output will be checked if it is a terminal capable\nof handling these sequences (using `terminal?/0` function)\n\n## Example\n\n iex> IO.ANSI.escape(\"Hello yes\")\n \"Hello \\e[31m\\e[1m\\e[32myes\\e[0m\"\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L173",
:def,
173,
[ { :string,
[ line: 173 ],
nil },
{ ://,
[ line: 173 ],
[ { :emit,
[ line: 173 ],
nil },
{ :terminal?,
[ line: 173 ],
[] } ] } ] },
{ ExDoc.FunctionNode,
:escape_fragment,
2,
"escape_fragment/2",
"Escapes a string coverting named ANSI sequences into actual ANSI codes.\n\nThe format for referring sequences is `` and `` (for\nmultiple sequences)\n\nAn optional boolean parameter can be passed to enable or disable\nemitting actual ANSI codes. When false, no ANSI codes will emitted.\nBy default, standard output will be checked if it is a terminal capable\nof handling these sequences (using `terminal?/0` function)\n\n## Example\n\n iex> IO.ANSI.escape(\"Hello yes\")\n \"Hello \\e[31m\\e[1m\\e[32myes\\e[0m\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L200",
:def,
200,
[ { :string,
[ line: 200 ],
nil },
{ ://,
[ line: 200 ],
[ { :emit,
[ line: 200 ],
nil },
{ :terminal?,
[ line: 200 ],
[] } ] } ] },
{ ExDoc.FunctionNode,
:faint,
0,
"faint/0",
"Faint (decreased intensity), not widely supported",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L65",
:def,
65,
[] },
{ ExDoc.FunctionNode,
:font_1,
0,
"font_1/0",
"Sets alternative font 1",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L96",
:def,
96,
[] },
{ ExDoc.FunctionNode,
:font_2,
0,
"font_2/0",
"Sets alternative font 2",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L96",
:def,
96,
[] },
{ ExDoc.FunctionNode,
:font_3,
0,
"font_3/0",
"Sets alternative font 3",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L96",
:def,
96,
[] },
{ ExDoc.FunctionNode,
:font_4,
0,
"font_4/0",
"Sets alternative font 4",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L96",
:def,
96,
[] },
{ ExDoc.FunctionNode,
:font_5,
0,
"font_5/0",
"Sets alternative font 5",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L96",
:def,
96,
[] },
{ ExDoc.FunctionNode,
:font_6,
0,
"font_6/0",
"Sets alternative font 6",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L96",
:def,
96,
[] },
{ ExDoc.FunctionNode,
:font_7,
0,
"font_7/0",
"Sets alternative font 7",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L96",
:def,
96,
[] },
{ ExDoc.FunctionNode,
:font_8,
0,
"font_8/0",
"Sets alternative font 8",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L96",
:def,
96,
[] },
{ ExDoc.FunctionNode,
:font_9,
0,
"font_9/0",
"Sets alternative font 9",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L96",
:def,
96,
[] },
{ ExDoc.FunctionNode,
:framed,
0,
"framed/0",
"Framed",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L129",
:def,
129,
[] },
{ ExDoc.FunctionNode,
:green,
0,
"green/0",
"Sets foreground color to green",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L116",
:def,
116,
[] },
{ ExDoc.FunctionNode,
:green_background,
0,
"green_background/0",
"Sets background color to green",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L119",
:def,
119,
[] },
{ ExDoc.FunctionNode,
:inverse,
0,
"inverse/0",
"Image: Negative. Swap foreground and background",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L80",
:def,
80,
[] },
{ ExDoc.FunctionNode,
:italic,
0,
"italic/0",
"Italic: on. Not widely supported. Sometimes treated as inverse.",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L68",
:def,
68,
[] },
{ ExDoc.FunctionNode,
:magenta,
0,
"magenta/0",
"Sets foreground color to magenta",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L116",
:def,
116,
[] },
{ ExDoc.FunctionNode,
:magenta_background,
0,
"magenta_background/0",
"Sets background color to magenta",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L119",
:def,
119,
[] },
{ ExDoc.FunctionNode,
:no_underline,
0,
"no_underline/0",
"Underline: None",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L106",
:def,
106,
[] },
{ ExDoc.FunctionNode,
:normal,
0,
"normal/0",
"Normal color or intensity",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L100",
:def,
100,
[] },
{ ExDoc.FunctionNode,
:not_framed_encircled,
0,
"not_framed_encircled/0",
"Not framed or encircled",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L138",
:def,
138,
[] },
{ ExDoc.FunctionNode,
:not_italic,
0,
"not_italic/0",
"Not italic",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L103",
:def,
103,
[] },
{ ExDoc.FunctionNode,
:not_overlined,
0,
"not_overlined/0",
"Not overlined",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L141",
:def,
141,
[] },
{ ExDoc.FunctionNode,
:overlined,
0,
"overlined/0",
"Overlined",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L135",
:def,
135,
[] },
{ ExDoc.FunctionNode,
:primary_font,
0,
"primary_font/0",
"Sets primary (default) font",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L92",
:def,
92,
[] },
{ ExDoc.FunctionNode,
:red,
0,
"red/0",
"Sets foreground color to red",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L116",
:def,
116,
[] },
{ ExDoc.FunctionNode,
:red_background,
0,
"red_background/0",
"Sets background color to red",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L119",
:def,
119,
[] },
{ ExDoc.FunctionNode,
:reset,
0,
"reset/0",
"Resets all attributes",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L59",
:def,
59,
[] },
{ ExDoc.FunctionNode,
:reverse,
0,
"reverse/0",
"Image: Negative. Swap foreground and background",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L83",
:def,
83,
[] },
{ ExDoc.FunctionNode,
:terminal?,
1,
"terminal?/1",
"Checks whether the default I/O device is a terminal or a file.\n\nUsed to identify whether printing ANSI escape sequences will likely\nbe printed as intended.\n\nPlease note that invoked while in shell (iex) in Erlang/OTP\nprior to R16, terminal?/0 will always return false because\nErlang shell did not support ANSI escape sequences up until\nR16.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L47",
:def,
47,
[ { ://,
[ line: 47 ],
[ { :device,
[ line: 47 ],
nil },
{ { :.,
[ line: 47 ],
[ :erlang,
:group_leader ] },
[ line: 47 ],
[] } ] } ] },
{ ExDoc.FunctionNode,
:underline,
0,
"underline/0",
"Underline: Single",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L71",
:def,
71,
[] },
{ ExDoc.FunctionNode,
:white,
0,
"white/0",
"Sets foreground color to white",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L116",
:def,
116,
[] },
{ ExDoc.FunctionNode,
:white_background,
0,
"white_background/0",
"Sets background color to white",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L119",
:def,
119,
[] },
{ ExDoc.FunctionNode,
:yellow,
0,
"yellow/0",
"Sets foreground color to yellow",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L116",
:def,
116,
[] },
... ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io/ansi.ex#L21",
[],
nil,
"IO.ANSI",
21,
{ ExDoc.ModuleNode,
IO,
"IO",
"Module responsible for doing IO. Many functions in this\nmodule expects an IO device and an io data encoded in UTF-8.\n\nAn IO device must be a pid or an atom representing a process.\nFor convenience, Elixir provides `:stdio` and `:stderr` as\nshortcut to Erlang's `:standard_io` and `:standard_error`.\n\nAn io data can be:\n\n* A list of integers representing a string. Any unicode\n character must be represented with one entry in the list,\n this entry being an integer with the codepoint value;\n\n* A binary in which unicode characters are represented\n with many bytes (Elixir's default representation);\n\n* A list of binaries or a list of char lists (as described above);\n\n* If none of the above, `to_binary` is invoked in the\n given argument;\n\n",
[ { ExDoc.FunctionNode,
:binread,
2,
"binread/2",
"Reads `count` bytes from the IO device as binary,\nno unicode conversion happens.\n\nCheck `read/2` for more information.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L49",
:def,
49,
[ { ://,
[ line: 49 ],
[ { :device,
[ line: 49 ],
nil },
{ :group_leader,
[ line: 49 ],
[] } ] },
{ :count,
[ line: 49 ],
nil } ] },
{ ExDoc.FunctionNode,
:binreadline,
1,
"binreadline/1",
"Reads a line from the IO device as binary,\nno unicode conversion happens.\n\nCheck `readline/1` for more information.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L80",
:def,
80,
[ { ://,
[ line: 80 ],
[ { :device,
[ line: 80 ],
nil },
{ :group_leader,
[ line: 80 ],
[] } ] } ] },
{ ExDoc.FunctionNode,
:binwrite,
2,
"binwrite/2",
"Writes the given argument to the given device\nas a binary, no unicode conversion happens.\n\nCheck `write/2` for more information.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L114",
:def,
114,
[ { ://,
[ line: 114 ],
[ { :device,
[ line: 114 ],
nil },
{ :group_leader,
[ line: 114 ],
[] } ] },
{ :item,
[ line: 114 ],
nil } ] },
{ ExDoc.FunctionNode,
:getb,
2,
"getb/2",
"Gets `count` bytes from the IO device. It returns:\n\n* `data` - The input characters.\n\n* :eof - End of file was encountered.\n\n* {:error, reason} - Other (rare) error condition,\n for instance {:error, :estale} if reading from an\n NFS file system.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L160",
:def,
160,
[ { :prompt,
[ line: 160 ],
nil },
{ ://,
[ line: 160 ],
[ { :count,
[ line: 160 ],
nil },
1 ] } ] },
{ ExDoc.FunctionNode,
:getb,
3,
"getb/3",
"Gets `count` bytes from the chosen IO device.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L173",
:def,
173,
[ { :device,
[ line: 173 ],
nil },
{ :prompt,
[ line: 173 ],
nil },
{ :count,
[ line: 173 ],
nil } ] },
{ ExDoc.FunctionNode,
:gets,
2,
"gets/2",
"Reads a line from the IO device. It returns:\n\n* `data` - The characters in the line terminated\n by a LF (or end of file).\n\n* :eof - End of file was encountered.\n\n* {:error, reason} - Other (rare) error condition,\n for instance {:error, :estale} if reading from an\n NFS file system.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L189",
:def,
189,
[ { ://,
[ line: 189 ],
[ { :device,
[ line: 189 ],
nil },
{ :group_leader,
[ line: 189 ],
[] } ] },
{ :prompt,
[ line: 189 ],
nil } ] },
{ ExDoc.FunctionNode,
:inspect,
2,
"inspect/2",
"Inspects and writes the given argument to the device\nfollowed by a new line. A set of options can be given.\n\n## Examples\n\n IO.inspect Process.list\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L137",
:def,
137,
[ { :item,
[ line: 137 ],
nil },
{ ://,
[ line: 137 ],
[ { :opts,
[ line: 137 ],
nil },
[ pretty: true ] ] } ] },
{ ExDoc.FunctionNode,
:inspect,
3,
"inspect/3",
"Inspects the item with options using the given device.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L144",
:def,
144,
[ { :device,
[ line: 144 ],
nil },
{ :item,
[ line: 144 ],
nil },
{ :opts,
[ line: 144 ],
nil } ] },
{ ExDoc.FunctionNode,
:puts,
2,
"puts/2",
"Writes the argument to the device, similarly to write\nbut adds a new line at the end. The argument is expected\nto be a chardata.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L123",
:def,
123,
[ { ://,
[ line: 123 ],
[ { :device,
[ line: 123 ],
nil },
{ :group_leader,
[ line: 123 ],
[] } ] },
{ :item,
[ line: 123 ],
nil } ] },
{ ExDoc.FunctionNode,
:read,
2,
"read/2",
"Reads `count` bytes from the IO device. It returns:\n\n* `data` - The input characters.\n\n* :eof - End of file was encountered.\n\n* {:error, reason} - Other (rare) error condition,\n for instance {:error, :estale} if reading from an\n NFS file system.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L39",
:def,
39,
[ { ://,
[ line: 39 ],
[ { :device,
[ line: 39 ],
nil },
{ :group_leader,
[ line: 39 ],
[] } ] },
{ :count,
[ line: 39 ],
nil } ] },
{ ExDoc.FunctionNode,
:readline,
1,
"readline/1",
"Reads a line from the IO device. It returns:\n\n* `data` - The input characters.\n\n* :eof - End of file was encountered.\n\n* {:error, reason} - Other (rare) error condition,\n for instance {:error, :estale} if reading from an\n NFS file system.\n\nThis function does the same as `gets/2`,\nexcept the prompt is not required as argument.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L70",
:def,
70,
[ { ://,
[ line: 70 ],
[ { :device,
[ line: 70 ],
nil },
{ :group_leader,
[ line: 70 ],
[] } ] } ] },
{ ExDoc.FunctionNode,
:write,
2,
"write/2",
"Writes the given argument to the given device.\nBy default the device is the standard output.\nThe argument is expected to be a chardata (i.e.\na char list or an unicode binary).\n\nIt returns `:ok` if it succeeds.\n\n## Examples\n\n IO.write \"sample\"\n #=> \"sample\"\n\n IO.write :stderr, \"error\"\n #=> \"error\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L104",
:def,
104,
[ { ://,
[ line: 104 ],
[ { :device,
[ line: 104 ],
nil },
{ :group_leader,
[ line: 104 ],
[] } ] },
{ :item,
[ line: 104 ],
nil } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/io.ex#L1",
[],
nil,
"IO",
1,
nil } } ],
nil,
"IO",
1,
nil },
{ ExDoc.ModuleNode,
Kernel,
"Kernel",
"`Kernel` provides the default macros and functions\nElixir imports into your environment. Those macros and functions\ncan be skipped or cherry-picked via the `import` macro. For\ninstance, if you want to tell Elixir to not import the `case`\nmacro, you can do:\n\n import Kernel, except: [case: 2]\n\nElixir also has special forms that are always imported and\ncannot be skipped. These are described in `Kernel.SpecialForms`.\n\nSome of the functions described in this module are simply\na proxy to its Erlang counterpart. Although they are documented\nhere for convenience, you can access their original documentation\nat http://www.erlang.org/doc/man/erlang.html.\n",
[ { ExDoc.FunctionNode,
:!,
1,
"!/1",
"Receives any argument and returns true if it is false\nor nil. Returns false otherwise. Not allowed in guard\nclauses.\n\n## Examples\n\n iex> !1\n false\n iex> ![1,2,3]\n false\n iex> !false\n true\n iex> !nil\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L180",
:defmacro,
180,
[ { :arg,
[ line: 180 ],
nil } ] },
{ ExDoc.FunctionNode,
:!=,
2,
"!=/2",
"Returns true if the two items are not equal.\n\nThis operator considers 1 and 1.0 to be equal. For strict\ncomparison, use `!==` instead.\n\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 != 2\n true\n iex> 1 != 1.0\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L265",
:defmacro,
265,
[ { :left,
[ line: 265 ],
nil },
{ :right,
[ line: 265 ],
nil } ] },
{ ExDoc.FunctionNode,
:!==,
2,
"!==/2",
"Returns true if the two items are strictly not equal.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 !== 2\n true\n\n iex> 1 !== 1.0\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L295",
:defmacro,
295,
[ { :left,
[ line: 295 ],
nil },
{ :right,
[ line: 295 ],
nil } ] },
{ ExDoc.FunctionNode,
:&&,
2,
"&&/2",
"Provides a short-circuit operator that evaluates and returns\nthe second expression only if the first one evaluates to true\n(i.e. it is not nil nor false). Returns the first expression\notherwise.\n\n## Examples\n\n iex> true && true\n true\n iex> nil && true\n nil\n iex> true && 1\n 1\n iex> false && throw(:bad)\n false\n\nNotice that, differently from Erlang `and` operator,\nthis operator accepts any expression as arguments,\nnot only booleans, however it is not allowed in guards.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2896",
:defmacro,
2896,
[ { :left,
[ line: 2896 ],
nil },
{ :right,
[ line: 2896 ],
nil } ] },
{ ExDoc.FunctionNode,
:*,
2,
"*/2",
"Arithmetic multiplication. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 * 2\n 2\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L53",
:defmacro,
53,
[ { :left,
[ line: 53 ],
nil },
{ :right,
[ line: 53 ],
nil } ] },
{ ExDoc.FunctionNode,
:+,
2,
"+/2",
"Arithmetic plus. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 + 2\n 3\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L31",
:defmacro,
31,
[ { :left,
[ line: 31 ],
nil },
{ :right,
[ line: 31 ],
nil } ] },
{ ExDoc.FunctionNode,
:++,
2,
"++/2",
"Concatenates two lists. Allowed in guard clauses.\n\n## Examples\n\n iex> [1] ++ [2,3]\n [1,2,3]\n\n iex> 'foo' ++ 'bar'\n 'foobar'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L95",
:defmacro,
95,
[ { :left,
[ line: 95 ],
nil },
{ :right,
[ line: 95 ],
nil } ] },
{ ExDoc.FunctionNode,
:-,
2,
"-/2",
"Arithmetic minus. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 - 2\n -1\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L42",
:defmacro,
42,
[ { :left,
[ line: 42 ],
nil },
{ :right,
[ line: 42 ],
nil } ] },
{ ExDoc.FunctionNode,
:--,
2,
"--/2",
"Removes the first occorrence of an item on the left\nfor each item on the right. Allowed in guard clauses.\n\n## Examples\n\n iex> [1,2,3] -- [1,2]\n [3]\n\n iex> [1,2,3,2,1] -- [1,2,2]\n [3,1]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L110",
:defmacro,
110,
[ { :left,
[ line: 110 ],
nil },
{ :right,
[ line: 110 ],
nil } ] },
{ ExDoc.FunctionNode,
:..,
2,
"../2",
"Returns a range with the specified start and end.\nIncludes both ends.\n\n## Examples\n\n iex> 0 in 1..3\n false\n iex> 1 in 1..3\n true\n iex> 2 in 1..3\n true\n iex> 3 in 1..3\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2871",
:defmacro,
2871,
[ { :first,
[ line: 2871 ],
nil },
{ :last,
[ line: 2871 ],
nil } ] },
{ ExDoc.FunctionNode,
:/,
2,
"//2",
"Arithmetic division. Differently from other languages,\nthe result is always a float. Use div and rem if you want\na natural division or the remainder. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 / 2\n 0.5\n iex> 2 / 1\n 2.0\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L68",
:defmacro,
68,
[ { :left,
[ line: 68 ],
nil },
{ :right,
[ line: 68 ],
nil } ] },
{ ExDoc.FunctionNode,
:<,
2,
"</2",
"Returns true if left is less than right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 < 2\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L192",
:defmacro,
192,
[ { :left,
[ line: 192 ],
nil },
{ :right,
[ line: 192 ],
nil } ] },
{ ExDoc.FunctionNode,
:<-,
2,
"<-/2",
"Sends a message to the process identified on the left.\nA process can be identified bu its PID or, if it is registered,\nby an atom.\n\n## Examples\n\n process = Kernel.self\n process <- { :ok, \"Sending myself a message\" }\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L81",
:defmacro,
81,
[ { :pid,
[ line: 81 ],
nil },
{ :msg,
[ line: 81 ],
nil } ] },
{ ExDoc.FunctionNode,
:<=,
2,
"<=/2",
"Returns true if left is less than or equal to right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 <= 2\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L216",
:defmacro,
216,
[ { :left,
[ line: 216 ],
nil },
{ :right,
[ line: 216 ],
nil } ] },
{ ExDoc.FunctionNode,
:<>,
2,
"<>/2",
"Concatenates two binaries.\n\n## Examples\n\n iex> \"foo\" <> \"bar\"\n \"foobar\"\n\nThe `<>` operator can also be used in guard clauses as\nlong as the first part is a literal binary:\n\n iex> \"foo\" <> x = \"foobar\"\n ...> x\n \"bar\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2850",
:defmacro,
2850,
[ { :left,
[ line: 2850 ],
nil },
{ :right,
[ line: 2850 ],
nil } ] },
{ ExDoc.FunctionNode,
:==,
2,
"==/2",
"Returns true if the two items are equal.\n\nThis operator considers 1 and 1.0 to be equal. For strict\ncomparison, use `===` instead.\n\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 == 2\n false\n\n iex> 1 == 1.0\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L247",
:defmacro,
247,
[ { :left,
[ line: 247 ],
nil },
{ :right,
[ line: 247 ],
nil } ] },
{ ExDoc.FunctionNode,
:===,
2,
"===/2",
"Returns true if the two items are strictly equal.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 === 2\n false\n\n iex> 1 === 1.0\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L280",
:defmacro,
280,
[ { :left,
[ line: 280 ],
nil },
{ :right,
[ line: 280 ],
nil } ] },
{ ExDoc.FunctionNode,
:=~,
2,
"=~/2",
"Matches the term on the left against the regular expression\non the right. It returns nil if not match happened or the\nfirst match otherwise.\n\n## Examples\n\n iex> \"abcd\" =~ %r/c(d)/\n 2\n iex> \"abcd\" =~ %r/e/\n nil\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2990",
:defmacro,
2990,
[ { :left,
[ line: 2990 ],
nil },
{ :right,
[ line: 2990 ],
nil } ] },
{ ExDoc.FunctionNode,
:>,
2,
">/2",
"Returns true if left is more than right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 > 2\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L204",
:defmacro,
204,
[ { :left,
[ line: 204 ],
nil },
{ :right,
[ line: 204 ],
nil } ] },
{ ExDoc.FunctionNode,
:>=,
2,
">=/2",
"Returns true if left is more than or equal to right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 >= 2\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L228",
:defmacro,
228,
[ { :left,
[ line: 228 ],
nil },
{ :right,
[ line: 228 ],
nil } ] },
{ ExDoc.FunctionNode,
:@,
1,
"@/1",
"This macro is a shortcut to read and add attributes to the module\nbeing compiled. Elixir module attributes are similar to Erlang's with\nsome differences. The canonical example for attributes is annotating\nthat a module implements the OTP behavior called `gen_server`:\n\n defmodule MyServer do\n @behavior :gen_server\n # ... callbacks ...\n end\n\nElixir supports by default all Erlang module attributes but any developer\ncan also add custom attributes:\n\n defmodule MyServer do\n @my_data 13\n IO.inspect @my_data #=> 13\n end\n\nDifferently from Erlang, such attributes are not stored in the module by\ndefault since it is common in Elixir to use such attributes to store\ntemporary data. A developer can configure an attribute to behave closer\nto Erlang by calling `Module.register_attribute/2`.\n\nFinally notice that attributes can also be read inside functions:\n\n defmodule MyServer do\n @my_data 11\n def first_data, do: @my_data\n @my_data 13\n def second_data, do: @my_data\n end\n\n MyServer.first_data #=> 11\n MyServer.second_data #=> 13\n\nIt is important to note that reading an attribute takes a snapshot of\nits current value. In other words, the value is read at compilation\ntime and not at runtime. Check the module `Module` for other functions\nto manipulate module attributes.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2474",
:defmacro,
2474,
[ { :expr,
[ line: 2474 ],
nil } ] },
{ ExDoc.FunctionNode,
:__B__,
2,
"__B__/2",
"Handles the sigil %B. It simples returns a binary\nwithout escaping characters and without interpolations.\n\n## Examples\n\n iex> %B(foo)\n \"foo\"\n iex> %B(f\#{o}o)\n \"f\\\#{o}o\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3345",
:defmacro,
3345,
[ { :string,
[ line: 3345 ],
nil },
{ :list2,
3345,
:guess } ] },
{ ExDoc.FunctionNode,
:__C__,
2,
"__C__/2",
"Handles the sigil %C. It simply returns a char list\nwithout escaping characters and without interpolations.\n\n## Examples\n\n iex> %C(foo)\n 'foo'\n iex> %C(f\#{o}o)\n 'f\\\#{o}o'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3377",
:defmacro,
3377,
[ { :arg1,
3377,
:guess },
{ :list2,
3377,
:guess } ] },
{ ExDoc.FunctionNode,
:__R__,
2,
"__R__/2",
"Handles the sigil %R. It returns a Regex pattern without escaping\nnor interpreting interpolations.\n\n## Examples\n\n iex> Regex.match?(%R(f\#{1,3}o), \"f#o\")\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3435",
:defmacro,
3435,
[ { :arg1,
3435,
:guess },
{ :options,
[ line: 3435 ],
nil } ] },
{ ExDoc.FunctionNode,
:__W__,
2,
"__W__/2",
"Handles the sigil %W. It returns a list of \"words\" split by whitespace\nwithout escaping nor interpreting interpolations.\n\n## Modifiers\n\n- `b`: binaries (default)\n- `a`: atoms\n- `c`: char lists\n\n## Examples\n\n iex> %W(foo \#{bar} baz)\n [\"foo\", \"\\\#{bar}\", \"baz\"]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3485",
:defmacro,
3485,
[ { :arg1,
3485,
:guess },
{ :modifiers,
[ line: 3485 ],
nil } ] },
{ ExDoc.FunctionNode,
:__b__,
2,
"__b__/2",
"Handles the sigil %b. It returns a binary as if it was double quoted\nstring, unescaping characters and replacing interpolations.\n\n## Examples\n\n iex> %b(foo)\n \"foo\"\n iex> %b(f\#{:o}o)\n \"foo\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3361",
:defmacro,
3361,
[ { :arg1,
3361,
:guess },
{ :list2,
3361,
:guess } ] },
{ ExDoc.FunctionNode,
:__c__,
2,
"__c__/2",
"Handles the sigil %c. It returns a char list as if it was a single\nquoted string, unescaping characters and replacing interpolations.\n\n## Examples\n\n iex> %c(foo)\n 'foo'\n iex> %c(f\#{:o}o)\n 'foo'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3396",
:defmacro,
3396,
[ { :arg1,
3396,
:guess },
{ :list2,
3396,
:guess } ] },
{ ExDoc.FunctionNode,
:__r__,
2,
"__r__/2",
"Handles the sigil %r. It returns a Regex pattern.\n\n## Examples\n\n iex> Regex.match?(%r(foo), \"foo\")\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3414",
:defmacro,
3414,
[ { :arg1,
3414,
:guess },
{ :options,
[ line: 3414 ],
nil } ] },
{ ExDoc.FunctionNode,
:__w__,
2,
"__w__/2",
"Handles the sigil %w. It returns a list of \"words\" split by whitespace.\n\n## Modifiers\n\n- `b`: binaries (default)\n- `a`: atoms\n- `c`: char lists\n\n## Examples\n\n iex> %w(foo \#{:bar} baz)\n [\"foo\", \"bar\", \"baz\"]\n iex> %w(--source test/enum_test.exs)\n [\"--source\", \"test/enum_test.exs\"]\n iex> %w(foo bar baz)a\n [:foo, :bar, :baz]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3460",
:defmacro,
3460,
[ { :arg1,
3460,
:guess },
{ :modifiers,
[ line: 3460 ],
nil } ] },
{ ExDoc.FunctionNode,
:abs,
1,
"abs/1",
"Returns an integer or float which is the arithmetical absolute value of `number`.\n\nAllowed in guard tests.\n\n## Examples\n\n iex> abs(-3.33)\n 3.33\n iex> abs(-3)\n 3\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L332",
:def,
332,
[ { :number,
[ line: 332 ],
nil } ] },
{ ExDoc.FunctionNode,
:access,
2,
"access/2",
"Access the given element using the qualifier according\nto the `Access` protocol. All calls in the form `foo[bar]`\nare translated to `access(foo, bar)`.\n\nThe usage of this protocol is to access a raw value in a\nkeyword list.\n\n sample = [a: 1, b: 2, c: 3]\n sample[:b] #=> 2\n\n## Atoms\n\nWhenever invoked on an atom, the access protocol is expanded\nat compilation time rather than on runtime. This feature is used\nby records to allow a developer to match against an specific part\nof a record:\n\n def increment(State[counter: counter, other: 13] = state) do\n state.counter(counter + 1)\n end\n\nIn the example above, we use the Access protocol to match the\ncounter field in the record `State`. Considering the record\ndefinition is as follows:\n\n defrecord State, counter: 0, other: nil\n\nThe clause above is translated to:\n\n def increment({ State, counter, 13 } = state) do\n state.counter(counter + 1)\n end\n\nThe same pattern can be used to create a new record:\n\n def new_state(counter) do\n State[counter: counter]\n end\n\nThe example above is slightly faster than `State.new(counter: :counter)`\nbecause the record is expanded at compilation time and not at runtime.\nIf a field is not specified on creation, it will have its default value.\n\nFinally, as in Erlang, Elixir also allows the following syntax:\n\n new_uri = State[_: 1]\n\nIn this case **all** fields will be set to `1`. Notice that,\nas in Erlang, in case an expression is given, it will be\nevaluated multiple times:\n\n new_uri = State[_: IO.puts \"Hello\"]\n\nIn this case, `\"Hello\"` will be printed twice (one per each field).\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3221",
:defmacro,
3221,
[ { :element,
[ line: 3221 ],
nil },
{ :args,
[ line: 3221 ],
nil } ] },
{ ExDoc.FunctionNode,
:and,
2,
"and/2",
"Boolean and. Arguments must be booleans.\nAllowed in guard clauses.\n\n## Examples\n\n iex> true and false\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L134",
:defmacro,
134,
[ { :left,
[ line: 134 ],
nil },
{ :right,
[ line: 134 ],
nil } ] },
{ ExDoc.FunctionNode,
:apply,
2,
"apply/2",
"Invokes the given `fun` with the array of arguments `args`.\n\n## Examples\n\n iex> apply(fn x -> x * 2 end, [2])\n 4\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L306",
:defmacro,
306,
[ { :fun,
[ line: 306 ],
nil },
{ :args,
[ line: 306 ],
nil } ] },
{ ExDoc.FunctionNode,
:apply,
3,
"apply/3",
"Invokes the given `fun` from `module` with the array of arguments `args`.\n\n## Examples\n\n iex> apply(Enum, :reverse, [[1,2,3]])\n [3,2,1]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L317",
:defmacro,
317,
[ { :module,
[ line: 317 ],
nil },
{ :fun,
[ line: 317 ],
nil },
{ :args,
[ line: 317 ],
nil } ] },
{ ExDoc.FunctionNode,
:atom_to_binary,
1,
"atom_to_binary/1",
"Returns a binary which corresponds to the text representation\nof `some_atom` in UTF8 encoding.\n\n## Examples\n\n iex> atom_to_binary(:my_atom)\n \"my_atom\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2828",
:defmacro,
2828,
[ { :some_atom,
[ line: 2828 ],
nil } ] },
{ ExDoc.FunctionNode,
:atom_to_binary,
2,
"atom_to_binary/2",
"Returns a binary which corresponds to the text representation of `atom`.\nIf `encoding` is latin1, there will be one byte for each character in the text\nrepresentation. If `encoding` is utf8 or unicode, the characters will be encoded\nusing UTF-8 (meaning that characters from 16#80 up to 0xFF will be encoded in\ntwo bytes).\n\n## Examples\n\n iex> atom_to_binary(:elixir, :utf8)\n \"elixir\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L350",
:def,
350,
[ { :atom,
[ line: 350 ],
nil },
{ :encoding,
[ line: 350 ],
nil } ] },
{ ExDoc.FunctionNode,
:atom_to_list,
1,
"atom_to_list/1",
"Returns a string which corresponds to the text representation of `atom`.\n\n## Examples\n\n iex> atom_to_list(:elixir)\n 'elixir'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L364",
:def,
364,
[ { :atom,
[ line: 364 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_part,
3,
"binary_part/3",
"Extracts the part of the binary starting at `start` with length `length`.\nBinaries are zero-indexed.\n\nIf start or length references in any way outside the binary, an\n`ArgumentError` exception is raised.\n\nAllowed in guard tests.\n\n## Examples\n\n iex> binary_part(\"foo\", 1, 2)\n \"oo\"\n\nA negative length can be used to extract bytes at the end of a binary:\n\n iex> binary_part(\"foo\", 3, -1)\n \"o\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L389",
:def,
389,
[ { :binary,
[ line: 389 ],
nil },
{ :start,
[ line: 389 ],
nil },
{ :length,
[ line: 389 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_atom,
1,
"binary_to_atom/1",
"Returns the atom whose text representation is\n`some_binary` in UTF8 encoding.\n\n## Examples\n\n iex> binary_to_atom(\"my_atom\")\n :my_atom\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2793",
:defmacro,
2793,
[ { :some_binary,
[ line: 2793 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_atom,
2,
"binary_to_atom/2",
"Returns the atom whose text representation is `binary`. If `encoding` is latin1,\nno translation of bytes in the binary is done. If `encoding` is utf8 or unicode,\nthe binary must contain valid UTF-8 sequences; furthermore, only Unicode\ncharacters up to 0xFF are allowed.\n\n## Examples\n\n iex> binary_to_atom(\"elixir\", :utf8)\n :elixir\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L406",
:def,
406,
[ { :binary,
[ line: 406 ],
nil },
{ :encoding,
[ line: 406 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_existing_atom,
1,
"binary_to_existing_atom/1",
"Works like `binary_to_atom` but the atom must exist.\n\n## Examples\n\n iex> :my_atom\n ...> binary_to_existing_atom(\"my_atom\")\n :my_atom\n\n iex> binary_to_existing_atom(\"this_atom_will_never_exist\")\n ** (ArgumentError) argument error\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2812",
:defmacro,
2812,
[ { :some_binary,
[ line: 2812 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_existing_atom,
2,
"binary_to_existing_atom/2",
"Works like `binary_to_atom/2`, but the atom must already exist.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L414",
:def,
414,
[ { :binary,
[ line: 414 ],
nil },
{ :encoding,
[ line: 414 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_float,
1,
"binary_to_float/1",
"Returns a float whose text representation is `some_binary`.\n\n## Examples\n\n iex> binary_to_float(\"2.2017764e+0\")\n 2.2017764\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2675",
:defmacro,
2675,
[ { :some_binary,
[ line: 2675 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_integer,
1,
"binary_to_integer/1",
"Returns a integer whose text representation is `some_binary`.\n\n## Examples\n\n iex> binary_to_integer(\"123\")\n 123\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2636",
:defmacro,
2636,
[ { :some_binary,
[ line: 2636 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_integer,
2,
"binary_to_integer/2",
"Returns an integer whose text representation in base `base`\nis `some_binary`.\n\n## Examples\n\n iex> binary_to_integer(\"3FF\", 16)\n 1023\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2656",
:defmacro,
2656,
[ { :some_binary,
[ line: 2656 ],
nil },
{ :base,
[ line: 2656 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_list,
1,
"binary_to_list/1",
"Returns a list of integers which correspond to the bytes of `binary`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L422",
:def,
422,
[ { :binary,
[ line: 422 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_list,
3,
"binary_to_list/3",
"Like binary_to_list/1, but returns a list of integers corresponding to the bytes\nfrom position `start` to position `stop` in `binary`. Positions in the binary\nare numbered starting from 1.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L432",
:def,
432,
[ { :binary,
[ line: 432 ],
nil },
{ :start,
[ line: 432 ],
nil },
{ :stop,
[ line: 432 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_term,
1,
"binary_to_term/1",
"Returns an Erlang term which is the result of decoding the binary\nobject `binary`, which must be encoded according to the Erlang external\nterm format.\n\n## Examples\n\n iex> binary_to_term(term_to_binary(\"foo\"))\n \"foo\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L448",
:def,
448,
[ { :binary,
[ line: 448 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_term,
2,
"binary_to_term/2",
"As `binary_to_term/1`, but accepts a safe option useful when receiving\nbinaries from an untrusted source.\n\nWhen enabled, it prevents decoding data that may be used to attack the\nErlang system. In the event of receiving unsafe data, decoding fails\nwith a badarg error.\n\nCurrently, this prevents creation of new atoms directly, creation of\nnew atoms indirectly (as they are embedded in certain structures like pids,\nrefs, funs, etc), and creation of new external function references. None\nof those resources are currently garbage collected, so unchecked creation\nof them can exhaust available memory.\n\n## Examples\n\n iex> binary_to_term(term_to_binary(\"foo\"), [:safe])\n \"foo\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L473",
:def,
473,
[ { :binary,
[ line: 473 ],
nil },
{ :options,
[ line: 473 ],
nil } ] },
{ ExDoc.FunctionNode,
:bit_size,
1,
"bit_size/1",
"Returns an integer which is the size in bits of `bitstring`.\n\nAllowed in guard tests.\n\n## Examples\n\n iex> bit_size(<<433::16,3::3>>)\n 19\n iex> bit_size(<<1,2,3>>)\n 24\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L491",
:def,
491,
[ { :bitstring,
[ line: 491 ],
nil } ] },
... ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3",
[ { ExDoc.ModuleNode,
Kernel.CLI,
"CLI",
"Module responsible for controlling Elixir's CLI\n",
[ { ExDoc.FunctionNode,
:run,
2,
"run/2",
"Runs the given function by catching any failure\nand printing them to stdout. `at_exit` hooks are\nalso invoked before exiting.\n\nThis function is used by Elixir's CLI and also\nby escripts generated by Elixir.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel/cli.ex#L37",
:def,
37,
[ { :fun,
[ line: 37 ],
nil },
{ ://,
[ line: 37 ],
[ { :halt,
[ line: 37 ],
nil },
true ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel/cli.ex#L1",
[],
nil,
"Kernel.CLI",
1,
{ ExDoc.ModuleNode,
Kernel,
"Kernel",
"`Kernel` provides the default macros and functions\nElixir imports into your environment. Those macros and functions\ncan be skipped or cherry-picked via the `import` macro. For\ninstance, if you want to tell Elixir to not import the `case`\nmacro, you can do:\n\n import Kernel, except: [case: 2]\n\nElixir also has special forms that are always imported and\ncannot be skipped. These are described in `Kernel.SpecialForms`.\n\nSome of the functions described in this module are simply\na proxy to its Erlang counterpart. Although they are documented\nhere for convenience, you can access their original documentation\nat http://www.erlang.org/doc/man/erlang.html.\n",
[ { ExDoc.FunctionNode,
:!,
1,
"!/1",
"Receives any argument and returns true if it is false\nor nil. Returns false otherwise. Not allowed in guard\nclauses.\n\n## Examples\n\n iex> !1\n false\n iex> ![1,2,3]\n false\n iex> !false\n true\n iex> !nil\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L180",
:defmacro,
180,
[ { :arg,
[ line: 180 ],
nil } ] },
{ ExDoc.FunctionNode,
:!=,
2,
"!=/2",
"Returns true if the two items are not equal.\n\nThis operator considers 1 and 1.0 to be equal. For strict\ncomparison, use `!==` instead.\n\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 != 2\n true\n iex> 1 != 1.0\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L265",
:defmacro,
265,
[ { :left,
[ line: 265 ],
nil },
{ :right,
[ line: 265 ],
nil } ] },
{ ExDoc.FunctionNode,
:!==,
2,
"!==/2",
"Returns true if the two items are strictly not equal.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 !== 2\n true\n\n iex> 1 !== 1.0\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L295",
:defmacro,
295,
[ { :left,
[ line: 295 ],
nil },
{ :right,
[ line: 295 ],
nil } ] },
{ ExDoc.FunctionNode,
:&&,
2,
"&&/2",
"Provides a short-circuit operator that evaluates and returns\nthe second expression only if the first one evaluates to true\n(i.e. it is not nil nor false). Returns the first expression\notherwise.\n\n## Examples\n\n iex> true && true\n true\n iex> nil && true\n nil\n iex> true && 1\n 1\n iex> false && throw(:bad)\n false\n\nNotice that, differently from Erlang `and` operator,\nthis operator accepts any expression as arguments,\nnot only booleans, however it is not allowed in guards.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2896",
:defmacro,
2896,
[ { :left,
[ line: 2896 ],
nil },
{ :right,
[ line: 2896 ],
nil } ] },
{ ExDoc.FunctionNode,
:*,
2,
"*/2",
"Arithmetic multiplication. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 * 2\n 2\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L53",
:defmacro,
53,
[ { :left,
[ line: 53 ],
nil },
{ :right,
[ line: 53 ],
nil } ] },
{ ExDoc.FunctionNode,
:+,
2,
"+/2",
"Arithmetic plus. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 + 2\n 3\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L31",
:defmacro,
31,
[ { :left,
[ line: 31 ],
nil },
{ :right,
[ line: 31 ],
nil } ] },
{ ExDoc.FunctionNode,
:++,
2,
"++/2",
"Concatenates two lists. Allowed in guard clauses.\n\n## Examples\n\n iex> [1] ++ [2,3]\n [1,2,3]\n\n iex> 'foo' ++ 'bar'\n 'foobar'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L95",
:defmacro,
95,
[ { :left,
[ line: 95 ],
nil },
{ :right,
[ line: 95 ],
nil } ] },
{ ExDoc.FunctionNode,
:-,
2,
"-/2",
"Arithmetic minus. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 - 2\n -1\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L42",
:defmacro,
42,
[ { :left,
[ line: 42 ],
nil },
{ :right,
[ line: 42 ],
nil } ] },
{ ExDoc.FunctionNode,
:--,
2,
"--/2",
"Removes the first occorrence of an item on the left\nfor each item on the right. Allowed in guard clauses.\n\n## Examples\n\n iex> [1,2,3] -- [1,2]\n [3]\n\n iex> [1,2,3,2,1] -- [1,2,2]\n [3,1]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L110",
:defmacro,
110,
[ { :left,
[ line: 110 ],
nil },
{ :right,
[ line: 110 ],
nil } ] },
{ ExDoc.FunctionNode,
:..,
2,
"../2",
"Returns a range with the specified start and end.\nIncludes both ends.\n\n## Examples\n\n iex> 0 in 1..3\n false\n iex> 1 in 1..3\n true\n iex> 2 in 1..3\n true\n iex> 3 in 1..3\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2871",
:defmacro,
2871,
[ { :first,
[ line: 2871 ],
nil },
{ :last,
[ line: 2871 ],
nil } ] },
{ ExDoc.FunctionNode,
:/,
2,
"//2",
"Arithmetic division. Differently from other languages,\nthe result is always a float. Use div and rem if you want\na natural division or the remainder. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 / 2\n 0.5\n iex> 2 / 1\n 2.0\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L68",
:defmacro,
68,
[ { :left,
[ line: 68 ],
nil },
{ :right,
[ line: 68 ],
nil } ] },
{ ExDoc.FunctionNode,
:<,
2,
"</2",
"Returns true if left is less than right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 < 2\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L192",
:defmacro,
192,
[ { :left,
[ line: 192 ],
nil },
{ :right,
[ line: 192 ],
nil } ] },
{ ExDoc.FunctionNode,
:<-,
2,
"<-/2",
"Sends a message to the process identified on the left.\nA process can be identified bu its PID or, if it is registered,\nby an atom.\n\n## Examples\n\n process = Kernel.self\n process <- { :ok, \"Sending myself a message\" }\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L81",
:defmacro,
81,
[ { :pid,
[ line: 81 ],
nil },
{ :msg,
[ line: 81 ],
nil } ] },
{ ExDoc.FunctionNode,
:<=,
2,
"<=/2",
"Returns true if left is less than or equal to right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 <= 2\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L216",
:defmacro,
216,
[ { :left,
[ line: 216 ],
nil },
{ :right,
[ line: 216 ],
nil } ] },
{ ExDoc.FunctionNode,
:<>,
2,
"<>/2",
"Concatenates two binaries.\n\n## Examples\n\n iex> \"foo\" <> \"bar\"\n \"foobar\"\n\nThe `<>` operator can also be used in guard clauses as\nlong as the first part is a literal binary:\n\n iex> \"foo\" <> x = \"foobar\"\n ...> x\n \"bar\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2850",
:defmacro,
2850,
[ { :left,
[ line: 2850 ],
nil },
{ :right,
[ line: 2850 ],
nil } ] },
{ ExDoc.FunctionNode,
:==,
2,
"==/2",
"Returns true if the two items are equal.\n\nThis operator considers 1 and 1.0 to be equal. For strict\ncomparison, use `===` instead.\n\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 == 2\n false\n\n iex> 1 == 1.0\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L247",
:defmacro,
247,
[ { :left,
[ line: 247 ],
nil },
{ :right,
[ line: 247 ],
nil } ] },
{ ExDoc.FunctionNode,
:===,
2,
"===/2",
"Returns true if the two items are strictly equal.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 === 2\n false\n\n iex> 1 === 1.0\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L280",
:defmacro,
280,
[ { :left,
[ line: 280 ],
nil },
{ :right,
[ line: 280 ],
nil } ] },
{ ExDoc.FunctionNode,
:=~,
2,
"=~/2",
"Matches the term on the left against the regular expression\non the right. It returns nil if not match happened or the\nfirst match otherwise.\n\n## Examples\n\n iex> \"abcd\" =~ %r/c(d)/\n 2\n iex> \"abcd\" =~ %r/e/\n nil\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2990",
:defmacro,
2990,
[ { :left,
[ line: 2990 ],
nil },
{ :right,
[ line: 2990 ],
nil } ] },
{ ExDoc.FunctionNode,
:>,
2,
">/2",
"Returns true if left is more than right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 > 2\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L204",
:defmacro,
204,
[ { :left,
[ line: 204 ],
nil },
{ :right,
[ line: 204 ],
nil } ] },
{ ExDoc.FunctionNode,
:>=,
2,
">=/2",
"Returns true if left is more than or equal to right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 >= 2\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L228",
:defmacro,
228,
[ { :left,
[ line: 228 ],
nil },
{ :right,
[ line: 228 ],
nil } ] },
{ ExDoc.FunctionNode,
:@,
1,
"@/1",
"This macro is a shortcut to read and add attributes to the module\nbeing compiled. Elixir module attributes are similar to Erlang's with\nsome differences. The canonical example for attributes is annotating\nthat a module implements the OTP behavior called `gen_server`:\n\n defmodule MyServer do\n @behavior :gen_server\n # ... callbacks ...\n end\n\nElixir supports by default all Erlang module attributes but any developer\ncan also add custom attributes:\n\n defmodule MyServer do\n @my_data 13\n IO.inspect @my_data #=> 13\n end\n\nDifferently from Erlang, such attributes are not stored in the module by\ndefault since it is common in Elixir to use such attributes to store\ntemporary data. A developer can configure an attribute to behave closer\nto Erlang by calling `Module.register_attribute/2`.\n\nFinally notice that attributes can also be read inside functions:\n\n defmodule MyServer do\n @my_data 11\n def first_data, do: @my_data\n @my_data 13\n def second_data, do: @my_data\n end\n\n MyServer.first_data #=> 11\n MyServer.second_data #=> 13\n\nIt is important to note that reading an attribute takes a snapshot of\nits current value. In other words, the value is read at compilation\ntime and not at runtime. Check the module `Module` for other functions\nto manipulate module attributes.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2474",
:defmacro,
2474,
[ { :expr,
[ line: 2474 ],
nil } ] },
{ ExDoc.FunctionNode,
:__B__,
2,
"__B__/2",
"Handles the sigil %B. It simples returns a binary\nwithout escaping characters and without interpolations.\n\n## Examples\n\n iex> %B(foo)\n \"foo\"\n iex> %B(f\#{o}o)\n \"f\\\#{o}o\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3345",
:defmacro,
3345,
[ { :string,
[ line: 3345 ],
nil },
{ :list2,
3345,
:guess } ] },
{ ExDoc.FunctionNode,
:__C__,
2,
"__C__/2",
"Handles the sigil %C. It simply returns a char list\nwithout escaping characters and without interpolations.\n\n## Examples\n\n iex> %C(foo)\n 'foo'\n iex> %C(f\#{o}o)\n 'f\\\#{o}o'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3377",
:defmacro,
3377,
[ { :arg1,
3377,
:guess },
{ :list2,
3377,
:guess } ] },
{ ExDoc.FunctionNode,
:__R__,
2,
"__R__/2",
"Handles the sigil %R. It returns a Regex pattern without escaping\nnor interpreting interpolations.\n\n## Examples\n\n iex> Regex.match?(%R(f\#{1,3}o), \"f#o\")\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3435",
:defmacro,
3435,
[ { :arg1,
3435,
:guess },
{ :options,
[ line: 3435 ],
nil } ] },
{ ExDoc.FunctionNode,
:__W__,
2,
"__W__/2",
"Handles the sigil %W. It returns a list of \"words\" split by whitespace\nwithout escaping nor interpreting interpolations.\n\n## Modifiers\n\n- `b`: binaries (default)\n- `a`: atoms\n- `c`: char lists\n\n## Examples\n\n iex> %W(foo \#{bar} baz)\n [\"foo\", \"\\\#{bar}\", \"baz\"]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3485",
:defmacro,
3485,
[ { :arg1,
3485,
:guess },
{ :modifiers,
[ line: 3485 ],
nil } ] },
{ ExDoc.FunctionNode,
:__b__,
2,
"__b__/2",
"Handles the sigil %b. It returns a binary as if it was double quoted\nstring, unescaping characters and replacing interpolations.\n\n## Examples\n\n iex> %b(foo)\n \"foo\"\n iex> %b(f\#{:o}o)\n \"foo\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3361",
:defmacro,
3361,
[ { :arg1,
3361,
:guess },
{ :list2,
3361,
:guess } ] },
{ ExDoc.FunctionNode,
:__c__,
2,
"__c__/2",
"Handles the sigil %c. It returns a char list as if it was a single\nquoted string, unescaping characters and replacing interpolations.\n\n## Examples\n\n iex> %c(foo)\n 'foo'\n iex> %c(f\#{:o}o)\n 'foo'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3396",
:defmacro,
3396,
[ { :arg1,
3396,
:guess },
{ :list2,
3396,
:guess } ] },
{ ExDoc.FunctionNode,
:__r__,
2,
"__r__/2",
"Handles the sigil %r. It returns a Regex pattern.\n\n## Examples\n\n iex> Regex.match?(%r(foo), \"foo\")\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3414",
:defmacro,
3414,
[ { :arg1,
3414,
:guess },
{ :options,
[ line: 3414 ],
nil } ] },
{ ExDoc.FunctionNode,
:__w__,
2,
"__w__/2",
"Handles the sigil %w. It returns a list of \"words\" split by whitespace.\n\n## Modifiers\n\n- `b`: binaries (default)\n- `a`: atoms\n- `c`: char lists\n\n## Examples\n\n iex> %w(foo \#{:bar} baz)\n [\"foo\", \"bar\", \"baz\"]\n iex> %w(--source test/enum_test.exs)\n [\"--source\", \"test/enum_test.exs\"]\n iex> %w(foo bar baz)a\n [:foo, :bar, :baz]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3460",
:defmacro,
3460,
[ { :arg1,
3460,
:guess },
{ :modifiers,
[ line: 3460 ],
nil } ] },
{ ExDoc.FunctionNode,
:abs,
1,
"abs/1",
"Returns an integer or float which is the arithmetical absolute value of `number`.\n\nAllowed in guard tests.\n\n## Examples\n\n iex> abs(-3.33)\n 3.33\n iex> abs(-3)\n 3\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L332",
:def,
332,
[ { :number,
[ line: 332 ],
nil } ] },
{ ExDoc.FunctionNode,
:access,
2,
"access/2",
"Access the given element using the qualifier according\nto the `Access` protocol. All calls in the form `foo[bar]`\nare translated to `access(foo, bar)`.\n\nThe usage of this protocol is to access a raw value in a\nkeyword list.\n\n sample = [a: 1, b: 2, c: 3]\n sample[:b] #=> 2\n\n## Atoms\n\nWhenever invoked on an atom, the access protocol is expanded\nat compilation time rather than on runtime. This feature is used\nby records to allow a developer to match against an specific part\nof a record:\n\n def increment(State[counter: counter, other: 13] = state) do\n state.counter(counter + 1)\n end\n\nIn the example above, we use the Access protocol to match the\ncounter field in the record `State`. Considering the record\ndefinition is as follows:\n\n defrecord State, counter: 0, other: nil\n\nThe clause above is translated to:\n\n def increment({ State, counter, 13 } = state) do\n state.counter(counter + 1)\n end\n\nThe same pattern can be used to create a new record:\n\n def new_state(counter) do\n State[counter: counter]\n end\n\nThe example above is slightly faster than `State.new(counter: :counter)`\nbecause the record is expanded at compilation time and not at runtime.\nIf a field is not specified on creation, it will have its default value.\n\nFinally, as in Erlang, Elixir also allows the following syntax:\n\n new_uri = State[_: 1]\n\nIn this case **all** fields will be set to `1`. Notice that,\nas in Erlang, in case an expression is given, it will be\nevaluated multiple times:\n\n new_uri = State[_: IO.puts \"Hello\"]\n\nIn this case, `\"Hello\"` will be printed twice (one per each field).\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3221",
:defmacro,
3221,
[ { :element,
[ line: 3221 ],
nil },
{ :args,
[ line: 3221 ],
nil } ] },
{ ExDoc.FunctionNode,
:and,
2,
"and/2",
"Boolean and. Arguments must be booleans.\nAllowed in guard clauses.\n\n## Examples\n\n iex> true and false\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L134",
:defmacro,
134,
[ { :left,
[ line: 134 ],
nil },
{ :right,
[ line: 134 ],
nil } ] },
{ ExDoc.FunctionNode,
:apply,
2,
"apply/2",
"Invokes the given `fun` with the array of arguments `args`.\n\n## Examples\n\n iex> apply(fn x -> x * 2 end, [2])\n 4\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L306",
:defmacro,
306,
[ { :fun,
[ line: 306 ],
nil },
{ :args,
[ line: 306 ],
nil } ] },
{ ExDoc.FunctionNode,
:apply,
3,
"apply/3",
"Invokes the given `fun` from `module` with the array of arguments `args`.\n\n## Examples\n\n iex> apply(Enum, :reverse, [[1,2,3]])\n [3,2,1]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L317",
:defmacro,
317,
[ { :module,
[ line: 317 ],
nil },
{ :fun,
[ line: 317 ],
nil },
{ :args,
[ line: 317 ],
nil } ] },
{ ExDoc.FunctionNode,
:atom_to_binary,
1,
"atom_to_binary/1",
"Returns a binary which corresponds to the text representation\nof `some_atom` in UTF8 encoding.\n\n## Examples\n\n iex> atom_to_binary(:my_atom)\n \"my_atom\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2828",
:defmacro,
2828,
[ { :some_atom,
[ line: 2828 ],
nil } ] },
{ ExDoc.FunctionNode,
:atom_to_binary,
2,
"atom_to_binary/2",
"Returns a binary which corresponds to the text representation of `atom`.\nIf `encoding` is latin1, there will be one byte for each character in the text\nrepresentation. If `encoding` is utf8 or unicode, the characters will be encoded\nusing UTF-8 (meaning that characters from 16#80 up to 0xFF will be encoded in\ntwo bytes).\n\n## Examples\n\n iex> atom_to_binary(:elixir, :utf8)\n \"elixir\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L350",
:def,
350,
[ { :atom,
[ line: 350 ],
nil },
{ :encoding,
[ line: 350 ],
nil } ] },
{ ExDoc.FunctionNode,
:atom_to_list,
1,
"atom_to_list/1",
"Returns a string which corresponds to the text representation of `atom`.\n\n## Examples\n\n iex> atom_to_list(:elixir)\n 'elixir'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L364",
:def,
364,
[ { :atom,
[ line: 364 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_part,
3,
"binary_part/3",
"Extracts the part of the binary starting at `start` with length `length`.\nBinaries are zero-indexed.\n\nIf start or length references in any way outside the binary, an\n`ArgumentError` exception is raised.\n\nAllowed in guard tests.\n\n## Examples\n\n iex> binary_part(\"foo\", 1, 2)\n \"oo\"\n\nA negative length can be used to extract bytes at the end of a binary:\n\n iex> binary_part(\"foo\", 3, -1)\n \"o\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L389",
:def,
389,
[ { :binary,
[ line: 389 ],
nil },
{ :start,
[ line: 389 ],
nil },
{ :length,
[ line: 389 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_atom,
1,
"binary_to_atom/1",
"Returns the atom whose text representation is\n`some_binary` in UTF8 encoding.\n\n## Examples\n\n iex> binary_to_atom(\"my_atom\")\n :my_atom\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2793",
:defmacro,
2793,
[ { :some_binary,
[ line: 2793 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_atom,
2,
"binary_to_atom/2",
"Returns the atom whose text representation is `binary`. If `encoding` is latin1,\nno translation of bytes in the binary is done. If `encoding` is utf8 or unicode,\nthe binary must contain valid UTF-8 sequences; furthermore, only Unicode\ncharacters up to 0xFF are allowed.\n\n## Examples\n\n iex> binary_to_atom(\"elixir\", :utf8)\n :elixir\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L406",
:def,
406,
[ { :binary,
[ line: 406 ],
nil },
{ :encoding,
[ line: 406 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_existing_atom,
1,
"binary_to_existing_atom/1",
"Works like `binary_to_atom` but the atom must exist.\n\n## Examples\n\n iex> :my_atom\n ...> binary_to_existing_atom(\"my_atom\")\n :my_atom\n\n iex> binary_to_existing_atom(\"this_atom_will_never_exist\")\n ** (ArgumentError) argument error\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2812",
:defmacro,
2812,
[ { :some_binary,
[ line: 2812 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_existing_atom,
2,
"binary_to_existing_atom/2",
"Works like `binary_to_atom/2`, but the atom must already exist.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L414",
:def,
414,
[ { :binary,
[ line: 414 ],
nil },
{ :encoding,
[ line: 414 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_float,
1,
"binary_to_float/1",
"Returns a float whose text representation is `some_binary`.\n\n## Examples\n\n iex> binary_to_float(\"2.2017764e+0\")\n 2.2017764\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2675",
:defmacro,
2675,
[ { :some_binary,
[ line: 2675 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_integer,
1,
"binary_to_integer/1",
"Returns a integer whose text representation is `some_binary`.\n\n## Examples\n\n iex> binary_to_integer(\"123\")\n 123\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2636",
:defmacro,
2636,
[ { :some_binary,
[ line: 2636 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_integer,
2,
"binary_to_integer/2",
"Returns an integer whose text representation in base `base`\nis `some_binary`.\n\n## Examples\n\n iex> binary_to_integer(\"3FF\", 16)\n 1023\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2656",
:defmacro,
2656,
[ { :some_binary,
[ line: 2656 ],
nil },
{ :base,
[ line: 2656 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_list,
1,
"binary_to_list/1",
"Returns a list of integers which correspond to the bytes of `binary`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L422",
:def,
422,
[ { :binary,
[ line: 422 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_list,
3,
"binary_to_list/3",
"Like binary_to_list/1, but returns a list of integers corresponding to the bytes\nfrom position `start` to position `stop` in `binary`. Positions in the binary\nare numbered starting from 1.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L432",
:def,
432,
[ { :binary,
[ line: 432 ],
nil },
{ :start,
[ line: 432 ],
nil },
{ :stop,
[ line: 432 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_term,
1,
"binary_to_term/1",
"Returns an Erlang term which is the result of decoding the binary\nobject `binary`, which must be encoded according to the Erlang external\nterm format.\n\n## Examples\n\n iex> binary_to_term(term_to_binary(\"foo\"))\n \"foo\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L448",
:def,
448,
[ { :binary,
[ line: 448 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_term,
2,
"binary_to_term/2",
"As `binary_to_term/1`, but accepts a safe option useful when receiving\nbinaries from an untrusted source.\n\nWhen enabled, it prevents decoding data that may be used to attack the\nErlang system. In the event of receiving unsafe data, decoding fails\nwith a badarg error.\n\nCurrently, this prevents creation of new atoms directly, creation of\nnew atoms indirectly (as they are embedded in certain structures like pids,\nrefs, funs, etc), and creation of new external function references. None\nof those resources are currently garbage collected, so unchecked creation\nof them can exhaust available memory.\n\n## Examples\n\n iex> binary_to_term(term_to_binary(\"foo\"), [:safe])\n \"foo\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L473",
:def,
473,
[ { :binary,
[ line: 473 ],
nil },
{ :options,
[ line: 473 ],
nil } ] },
{ ExDoc.FunctionNode,
:bit_size,
1,
"bit_size/1",
"Returns an integer which is the size in bits of `bitstring`.\n\nAllowed in guard tests.\n\n## Examples\n\n iex> bit_size(<<433::16,3::3>>)\n 19\n iex> bit_size(<<1,2,3>>)\n 24\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L491",
:def,
491,
[ { :bitstring,
[ line: 491 ],
nil } ] },
... ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3",
[],
nil,
"Kernel",
3,
nil } },
{ ExDoc.ModuleNode,
Kernel.ParallelCompiler,
"ParallelCompiler",
"A module responsible for compiling files in parallel.\n",
[ { ExDoc.FunctionNode,
:files,
2,
"files/2",
"Compiles the given files.\n\nThose files are compiled in parallel and can automatically\ndetect dependencies between them. Once a dependency is found,\nthe current file stops being compiled until the dependency is\nresolved.\n\nA callback that is invoked every time a file is compiled\nwith its name can be optionally given as argument.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel/parallel_compiler.ex#L21",
:def,
21,
[ { :files,
[ line: 21 ],
nil },
{ ://,
[ line: 21 ],
[ { :callback,
[ line: 21 ],
nil },
{ :default_callback,
[ line: 21 ],
nil } ] } ] },
{ ExDoc.FunctionNode,
:files_to_path,
3,
"files_to_path/3",
"Compiles the given files to the given path.\nRead files/2 for more information.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel/parallel_compiler.ex#L29",
:def,
29,
[ { :files,
[ line: 29 ],
nil },
{ :path,
[ line: 29 ],
nil },
{ ://,
[ line: 29 ],
[ { :callback,
[ line: 29 ],
nil },
{ :default_callback,
[ line: 29 ],
nil } ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel/parallel_compiler.ex#L1",
[],
nil,
"Kernel.ParallelCompiler",
1,
{ ExDoc.ModuleNode,
Kernel,
"Kernel",
"`Kernel` provides the default macros and functions\nElixir imports into your environment. Those macros and functions\ncan be skipped or cherry-picked via the `import` macro. For\ninstance, if you want to tell Elixir to not import the `case`\nmacro, you can do:\n\n import Kernel, except: [case: 2]\n\nElixir also has special forms that are always imported and\ncannot be skipped. These are described in `Kernel.SpecialForms`.\n\nSome of the functions described in this module are simply\na proxy to its Erlang counterpart. Although they are documented\nhere for convenience, you can access their original documentation\nat http://www.erlang.org/doc/man/erlang.html.\n",
[ { ExDoc.FunctionNode,
:!,
1,
"!/1",
"Receives any argument and returns true if it is false\nor nil. Returns false otherwise. Not allowed in guard\nclauses.\n\n## Examples\n\n iex> !1\n false\n iex> ![1,2,3]\n false\n iex> !false\n true\n iex> !nil\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L180",
:defmacro,
180,
[ { :arg,
[ line: 180 ],
nil } ] },
{ ExDoc.FunctionNode,
:!=,
2,
"!=/2",
"Returns true if the two items are not equal.\n\nThis operator considers 1 and 1.0 to be equal. For strict\ncomparison, use `!==` instead.\n\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 != 2\n true\n iex> 1 != 1.0\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L265",
:defmacro,
265,
[ { :left,
[ line: 265 ],
nil },
{ :right,
[ line: 265 ],
nil } ] },
{ ExDoc.FunctionNode,
:!==,
2,
"!==/2",
"Returns true if the two items are strictly not equal.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 !== 2\n true\n\n iex> 1 !== 1.0\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L295",
:defmacro,
295,
[ { :left,
[ line: 295 ],
nil },
{ :right,
[ line: 295 ],
nil } ] },
{ ExDoc.FunctionNode,
:&&,
2,
"&&/2",
"Provides a short-circuit operator that evaluates and returns\nthe second expression only if the first one evaluates to true\n(i.e. it is not nil nor false). Returns the first expression\notherwise.\n\n## Examples\n\n iex> true && true\n true\n iex> nil && true\n nil\n iex> true && 1\n 1\n iex> false && throw(:bad)\n false\n\nNotice that, differently from Erlang `and` operator,\nthis operator accepts any expression as arguments,\nnot only booleans, however it is not allowed in guards.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2896",
:defmacro,
2896,
[ { :left,
[ line: 2896 ],
nil },
{ :right,
[ line: 2896 ],
nil } ] },
{ ExDoc.FunctionNode,
:*,
2,
"*/2",
"Arithmetic multiplication. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 * 2\n 2\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L53",
:defmacro,
53,
[ { :left,
[ line: 53 ],
nil },
{ :right,
[ line: 53 ],
nil } ] },
{ ExDoc.FunctionNode,
:+,
2,
"+/2",
"Arithmetic plus. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 + 2\n 3\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L31",
:defmacro,
31,
[ { :left,
[ line: 31 ],
nil },
{ :right,
[ line: 31 ],
nil } ] },
{ ExDoc.FunctionNode,
:++,
2,
"++/2",
"Concatenates two lists. Allowed in guard clauses.\n\n## Examples\n\n iex> [1] ++ [2,3]\n [1,2,3]\n\n iex> 'foo' ++ 'bar'\n 'foobar'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L95",
:defmacro,
95,
[ { :left,
[ line: 95 ],
nil },
{ :right,
[ line: 95 ],
nil } ] },
{ ExDoc.FunctionNode,
:-,
2,
"-/2",
"Arithmetic minus. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 - 2\n -1\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L42",
:defmacro,
42,
[ { :left,
[ line: 42 ],
nil },
{ :right,
[ line: 42 ],
nil } ] },
{ ExDoc.FunctionNode,
:--,
2,
"--/2",
"Removes the first occorrence of an item on the left\nfor each item on the right. Allowed in guard clauses.\n\n## Examples\n\n iex> [1,2,3] -- [1,2]\n [3]\n\n iex> [1,2,3,2,1] -- [1,2,2]\n [3,1]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L110",
:defmacro,
110,
[ { :left,
[ line: 110 ],
nil },
{ :right,
[ line: 110 ],
nil } ] },
{ ExDoc.FunctionNode,
:..,
2,
"../2",
"Returns a range with the specified start and end.\nIncludes both ends.\n\n## Examples\n\n iex> 0 in 1..3\n false\n iex> 1 in 1..3\n true\n iex> 2 in 1..3\n true\n iex> 3 in 1..3\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2871",
:defmacro,
2871,
[ { :first,
[ line: 2871 ],
nil },
{ :last,
[ line: 2871 ],
nil } ] },
{ ExDoc.FunctionNode,
:/,
2,
"//2",
"Arithmetic division. Differently from other languages,\nthe result is always a float. Use div and rem if you want\na natural division or the remainder. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 / 2\n 0.5\n iex> 2 / 1\n 2.0\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L68",
:defmacro,
68,
[ { :left,
[ line: 68 ],
nil },
{ :right,
[ line: 68 ],
nil } ] },
{ ExDoc.FunctionNode,
:<,
2,
"</2",
"Returns true if left is less than right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 < 2\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L192",
:defmacro,
192,
[ { :left,
[ line: 192 ],
nil },
{ :right,
[ line: 192 ],
nil } ] },
{ ExDoc.FunctionNode,
:<-,
2,
"<-/2",
"Sends a message to the process identified on the left.\nA process can be identified bu its PID or, if it is registered,\nby an atom.\n\n## Examples\n\n process = Kernel.self\n process <- { :ok, \"Sending myself a message\" }\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L81",
:defmacro,
81,
[ { :pid,
[ line: 81 ],
nil },
{ :msg,
[ line: 81 ],
nil } ] },
{ ExDoc.FunctionNode,
:<=,
2,
"<=/2",
"Returns true if left is less than or equal to right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 <= 2\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L216",
:defmacro,
216,
[ { :left,
[ line: 216 ],
nil },
{ :right,
[ line: 216 ],
nil } ] },
{ ExDoc.FunctionNode,
:<>,
2,
"<>/2",
"Concatenates two binaries.\n\n## Examples\n\n iex> \"foo\" <> \"bar\"\n \"foobar\"\n\nThe `<>` operator can also be used in guard clauses as\nlong as the first part is a literal binary:\n\n iex> \"foo\" <> x = \"foobar\"\n ...> x\n \"bar\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2850",
:defmacro,
2850,
[ { :left,
[ line: 2850 ],
nil },
{ :right,
[ line: 2850 ],
nil } ] },
{ ExDoc.FunctionNode,
:==,
2,
"==/2",
"Returns true if the two items are equal.\n\nThis operator considers 1 and 1.0 to be equal. For strict\ncomparison, use `===` instead.\n\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 == 2\n false\n\n iex> 1 == 1.0\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L247",
:defmacro,
247,
[ { :left,
[ line: 247 ],
nil },
{ :right,
[ line: 247 ],
nil } ] },
{ ExDoc.FunctionNode,
:===,
2,
"===/2",
"Returns true if the two items are strictly equal.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 === 2\n false\n\n iex> 1 === 1.0\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L280",
:defmacro,
280,
[ { :left,
[ line: 280 ],
nil },
{ :right,
[ line: 280 ],
nil } ] },
{ ExDoc.FunctionNode,
:=~,
2,
"=~/2",
"Matches the term on the left against the regular expression\non the right. It returns nil if not match happened or the\nfirst match otherwise.\n\n## Examples\n\n iex> \"abcd\" =~ %r/c(d)/\n 2\n iex> \"abcd\" =~ %r/e/\n nil\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2990",
:defmacro,
2990,
[ { :left,
[ line: 2990 ],
nil },
{ :right,
[ line: 2990 ],
nil } ] },
{ ExDoc.FunctionNode,
:>,
2,
">/2",
"Returns true if left is more than right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 > 2\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L204",
:defmacro,
204,
[ { :left,
[ line: 204 ],
nil },
{ :right,
[ line: 204 ],
nil } ] },
{ ExDoc.FunctionNode,
:>=,
2,
">=/2",
"Returns true if left is more than or equal to right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 >= 2\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L228",
:defmacro,
228,
[ { :left,
[ line: 228 ],
nil },
{ :right,
[ line: 228 ],
nil } ] },
{ ExDoc.FunctionNode,
:@,
1,
"@/1",
"This macro is a shortcut to read and add attributes to the module\nbeing compiled. Elixir module attributes are similar to Erlang's with\nsome differences. The canonical example for attributes is annotating\nthat a module implements the OTP behavior called `gen_server`:\n\n defmodule MyServer do\n @behavior :gen_server\n # ... callbacks ...\n end\n\nElixir supports by default all Erlang module attributes but any developer\ncan also add custom attributes:\n\n defmodule MyServer do\n @my_data 13\n IO.inspect @my_data #=> 13\n end\n\nDifferently from Erlang, such attributes are not stored in the module by\ndefault since it is common in Elixir to use such attributes to store\ntemporary data. A developer can configure an attribute to behave closer\nto Erlang by calling `Module.register_attribute/2`.\n\nFinally notice that attributes can also be read inside functions:\n\n defmodule MyServer do\n @my_data 11\n def first_data, do: @my_data\n @my_data 13\n def second_data, do: @my_data\n end\n\n MyServer.first_data #=> 11\n MyServer.second_data #=> 13\n\nIt is important to note that reading an attribute takes a snapshot of\nits current value. In other words, the value is read at compilation\ntime and not at runtime. Check the module `Module` for other functions\nto manipulate module attributes.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2474",
:defmacro,
2474,
[ { :expr,
[ line: 2474 ],
nil } ] },
{ ExDoc.FunctionNode,
:__B__,
2,
"__B__/2",
"Handles the sigil %B. It simples returns a binary\nwithout escaping characters and without interpolations.\n\n## Examples\n\n iex> %B(foo)\n \"foo\"\n iex> %B(f\#{o}o)\n \"f\\\#{o}o\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3345",
:defmacro,
3345,
[ { :string,
[ line: 3345 ],
nil },
{ :list2,
3345,
:guess } ] },
{ ExDoc.FunctionNode,
:__C__,
2,
"__C__/2",
"Handles the sigil %C. It simply returns a char list\nwithout escaping characters and without interpolations.\n\n## Examples\n\n iex> %C(foo)\n 'foo'\n iex> %C(f\#{o}o)\n 'f\\\#{o}o'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3377",
:defmacro,
3377,
[ { :arg1,
3377,
:guess },
{ :list2,
3377,
:guess } ] },
{ ExDoc.FunctionNode,
:__R__,
2,
"__R__/2",
"Handles the sigil %R. It returns a Regex pattern without escaping\nnor interpreting interpolations.\n\n## Examples\n\n iex> Regex.match?(%R(f\#{1,3}o), \"f#o\")\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3435",
:defmacro,
3435,
[ { :arg1,
3435,
:guess },
{ :options,
[ line: 3435 ],
nil } ] },
{ ExDoc.FunctionNode,
:__W__,
2,
"__W__/2",
"Handles the sigil %W. It returns a list of \"words\" split by whitespace\nwithout escaping nor interpreting interpolations.\n\n## Modifiers\n\n- `b`: binaries (default)\n- `a`: atoms\n- `c`: char lists\n\n## Examples\n\n iex> %W(foo \#{bar} baz)\n [\"foo\", \"\\\#{bar}\", \"baz\"]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3485",
:defmacro,
3485,
[ { :arg1,
3485,
:guess },
{ :modifiers,
[ line: 3485 ],
nil } ] },
{ ExDoc.FunctionNode,
:__b__,
2,
"__b__/2",
"Handles the sigil %b. It returns a binary as if it was double quoted\nstring, unescaping characters and replacing interpolations.\n\n## Examples\n\n iex> %b(foo)\n \"foo\"\n iex> %b(f\#{:o}o)\n \"foo\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3361",
:defmacro,
3361,
[ { :arg1,
3361,
:guess },
{ :list2,
3361,
:guess } ] },
{ ExDoc.FunctionNode,
:__c__,
2,
"__c__/2",
"Handles the sigil %c. It returns a char list as if it was a single\nquoted string, unescaping characters and replacing interpolations.\n\n## Examples\n\n iex> %c(foo)\n 'foo'\n iex> %c(f\#{:o}o)\n 'foo'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3396",
:defmacro,
3396,
[ { :arg1,
3396,
:guess },
{ :list2,
3396,
:guess } ] },
{ ExDoc.FunctionNode,
:__r__,
2,
"__r__/2",
"Handles the sigil %r. It returns a Regex pattern.\n\n## Examples\n\n iex> Regex.match?(%r(foo), \"foo\")\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3414",
:defmacro,
3414,
[ { :arg1,
3414,
:guess },
{ :options,
[ line: 3414 ],
nil } ] },
{ ExDoc.FunctionNode,
:__w__,
2,
"__w__/2",
"Handles the sigil %w. It returns a list of \"words\" split by whitespace.\n\n## Modifiers\n\n- `b`: binaries (default)\n- `a`: atoms\n- `c`: char lists\n\n## Examples\n\n iex> %w(foo \#{:bar} baz)\n [\"foo\", \"bar\", \"baz\"]\n iex> %w(--source test/enum_test.exs)\n [\"--source\", \"test/enum_test.exs\"]\n iex> %w(foo bar baz)a\n [:foo, :bar, :baz]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3460",
:defmacro,
3460,
[ { :arg1,
3460,
:guess },
{ :modifiers,
[ line: 3460 ],
nil } ] },
{ ExDoc.FunctionNode,
:abs,
1,
"abs/1",
"Returns an integer or float which is the arithmetical absolute value of `number`.\n\nAllowed in guard tests.\n\n## Examples\n\n iex> abs(-3.33)\n 3.33\n iex> abs(-3)\n 3\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L332",
:def,
332,
[ { :number,
[ line: 332 ],
nil } ] },
{ ExDoc.FunctionNode,
:access,
2,
"access/2",
"Access the given element using the qualifier according\nto the `Access` protocol. All calls in the form `foo[bar]`\nare translated to `access(foo, bar)`.\n\nThe usage of this protocol is to access a raw value in a\nkeyword list.\n\n sample = [a: 1, b: 2, c: 3]\n sample[:b] #=> 2\n\n## Atoms\n\nWhenever invoked on an atom, the access protocol is expanded\nat compilation time rather than on runtime. This feature is used\nby records to allow a developer to match against an specific part\nof a record:\n\n def increment(State[counter: counter, other: 13] = state) do\n state.counter(counter + 1)\n end\n\nIn the example above, we use the Access protocol to match the\ncounter field in the record `State`. Considering the record\ndefinition is as follows:\n\n defrecord State, counter: 0, other: nil\n\nThe clause above is translated to:\n\n def increment({ State, counter, 13 } = state) do\n state.counter(counter + 1)\n end\n\nThe same pattern can be used to create a new record:\n\n def new_state(counter) do\n State[counter: counter]\n end\n\nThe example above is slightly faster than `State.new(counter: :counter)`\nbecause the record is expanded at compilation time and not at runtime.\nIf a field is not specified on creation, it will have its default value.\n\nFinally, as in Erlang, Elixir also allows the following syntax:\n\n new_uri = State[_: 1]\n\nIn this case **all** fields will be set to `1`. Notice that,\nas in Erlang, in case an expression is given, it will be\nevaluated multiple times:\n\n new_uri = State[_: IO.puts \"Hello\"]\n\nIn this case, `\"Hello\"` will be printed twice (one per each field).\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3221",
:defmacro,
3221,
[ { :element,
[ line: 3221 ],
nil },
{ :args,
[ line: 3221 ],
nil } ] },
{ ExDoc.FunctionNode,
:and,
2,
"and/2",
"Boolean and. Arguments must be booleans.\nAllowed in guard clauses.\n\n## Examples\n\n iex> true and false\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L134",
:defmacro,
134,
[ { :left,
[ line: 134 ],
nil },
{ :right,
[ line: 134 ],
nil } ] },
{ ExDoc.FunctionNode,
:apply,
2,
"apply/2",
"Invokes the given `fun` with the array of arguments `args`.\n\n## Examples\n\n iex> apply(fn x -> x * 2 end, [2])\n 4\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L306",
:defmacro,
306,
[ { :fun,
[ line: 306 ],
nil },
{ :args,
[ line: 306 ],
nil } ] },
{ ExDoc.FunctionNode,
:apply,
3,
"apply/3",
"Invokes the given `fun` from `module` with the array of arguments `args`.\n\n## Examples\n\n iex> apply(Enum, :reverse, [[1,2,3]])\n [3,2,1]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L317",
:defmacro,
317,
[ { :module,
[ line: 317 ],
nil },
{ :fun,
[ line: 317 ],
nil },
{ :args,
[ line: 317 ],
nil } ] },
{ ExDoc.FunctionNode,
:atom_to_binary,
1,
"atom_to_binary/1",
"Returns a binary which corresponds to the text representation\nof `some_atom` in UTF8 encoding.\n\n## Examples\n\n iex> atom_to_binary(:my_atom)\n \"my_atom\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2828",
:defmacro,
2828,
[ { :some_atom,
[ line: 2828 ],
nil } ] },
{ ExDoc.FunctionNode,
:atom_to_binary,
2,
"atom_to_binary/2",
"Returns a binary which corresponds to the text representation of `atom`.\nIf `encoding` is latin1, there will be one byte for each character in the text\nrepresentation. If `encoding` is utf8 or unicode, the characters will be encoded\nusing UTF-8 (meaning that characters from 16#80 up to 0xFF will be encoded in\ntwo bytes).\n\n## Examples\n\n iex> atom_to_binary(:elixir, :utf8)\n \"elixir\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L350",
:def,
350,
[ { :atom,
[ line: 350 ],
nil },
{ :encoding,
[ line: 350 ],
nil } ] },
{ ExDoc.FunctionNode,
:atom_to_list,
1,
"atom_to_list/1",
"Returns a string which corresponds to the text representation of `atom`.\n\n## Examples\n\n iex> atom_to_list(:elixir)\n 'elixir'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L364",
:def,
364,
[ { :atom,
[ line: 364 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_part,
3,
"binary_part/3",
"Extracts the part of the binary starting at `start` with length `length`.\nBinaries are zero-indexed.\n\nIf start or length references in any way outside the binary, an\n`ArgumentError` exception is raised.\n\nAllowed in guard tests.\n\n## Examples\n\n iex> binary_part(\"foo\", 1, 2)\n \"oo\"\n\nA negative length can be used to extract bytes at the end of a binary:\n\n iex> binary_part(\"foo\", 3, -1)\n \"o\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L389",
:def,
389,
[ { :binary,
[ line: 389 ],
nil },
{ :start,
[ line: 389 ],
nil },
{ :length,
[ line: 389 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_atom,
1,
"binary_to_atom/1",
"Returns the atom whose text representation is\n`some_binary` in UTF8 encoding.\n\n## Examples\n\n iex> binary_to_atom(\"my_atom\")\n :my_atom\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2793",
:defmacro,
2793,
[ { :some_binary,
[ line: 2793 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_atom,
2,
"binary_to_atom/2",
"Returns the atom whose text representation is `binary`. If `encoding` is latin1,\nno translation of bytes in the binary is done. If `encoding` is utf8 or unicode,\nthe binary must contain valid UTF-8 sequences; furthermore, only Unicode\ncharacters up to 0xFF are allowed.\n\n## Examples\n\n iex> binary_to_atom(\"elixir\", :utf8)\n :elixir\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L406",
:def,
406,
[ { :binary,
[ line: 406 ],
nil },
{ :encoding,
[ line: 406 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_existing_atom,
1,
"binary_to_existing_atom/1",
"Works like `binary_to_atom` but the atom must exist.\n\n## Examples\n\n iex> :my_atom\n ...> binary_to_existing_atom(\"my_atom\")\n :my_atom\n\n iex> binary_to_existing_atom(\"this_atom_will_never_exist\")\n ** (ArgumentError) argument error\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2812",
:defmacro,
2812,
[ { :some_binary,
[ line: 2812 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_existing_atom,
2,
"binary_to_existing_atom/2",
"Works like `binary_to_atom/2`, but the atom must already exist.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L414",
:def,
414,
[ { :binary,
[ line: 414 ],
nil },
{ :encoding,
[ line: 414 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_float,
1,
"binary_to_float/1",
"Returns a float whose text representation is `some_binary`.\n\n## Examples\n\n iex> binary_to_float(\"2.2017764e+0\")\n 2.2017764\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2675",
:defmacro,
2675,
[ { :some_binary,
[ line: 2675 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_integer,
1,
"binary_to_integer/1",
"Returns a integer whose text representation is `some_binary`.\n\n## Examples\n\n iex> binary_to_integer(\"123\")\n 123\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2636",
:defmacro,
2636,
[ { :some_binary,
[ line: 2636 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_integer,
2,
"binary_to_integer/2",
"Returns an integer whose text representation in base `base`\nis `some_binary`.\n\n## Examples\n\n iex> binary_to_integer(\"3FF\", 16)\n 1023\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2656",
:defmacro,
2656,
[ { :some_binary,
[ line: 2656 ],
nil },
{ :base,
[ line: 2656 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_list,
1,
"binary_to_list/1",
"Returns a list of integers which correspond to the bytes of `binary`.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L422",
:def,
422,
[ { :binary,
[ line: 422 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_list,
3,
"binary_to_list/3",
"Like binary_to_list/1, but returns a list of integers corresponding to the bytes\nfrom position `start` to position `stop` in `binary`. Positions in the binary\nare numbered starting from 1.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L432",
:def,
432,
[ { :binary,
[ line: 432 ],
nil },
{ :start,
[ line: 432 ],
nil },
{ :stop,
[ line: 432 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_term,
1,
"binary_to_term/1",
"Returns an Erlang term which is the result of decoding the binary\nobject `binary`, which must be encoded according to the Erlang external\nterm format.\n\n## Examples\n\n iex> binary_to_term(term_to_binary(\"foo\"))\n \"foo\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L448",
:def,
448,
[ { :binary,
[ line: 448 ],
nil } ] },
{ ExDoc.FunctionNode,
:binary_to_term,
2,
"binary_to_term/2",
"As `binary_to_term/1`, but accepts a safe option useful when receiving\nbinaries from an untrusted source.\n\nWhen enabled, it prevents decoding data that may be used to attack the\nErlang system. In the event of receiving unsafe data, decoding fails\nwith a badarg error.\n\nCurrently, this prevents creation of new atoms directly, creation of\nnew atoms indirectly (as they are embedded in certain structures like pids,\nrefs, funs, etc), and creation of new external function references. None\nof those resources are currently garbage collected, so unchecked creation\nof them can exhaust available memory.\n\n## Examples\n\n iex> binary_to_term(term_to_binary(\"foo\"), [:safe])\n \"foo\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L473",
:def,
473,
[ { :binary,
[ line: 473 ],
nil },
{ :options,
[ line: 473 ],
nil } ] },
{ ExDoc.FunctionNode,
:bit_size,
1,
"bit_size/1",
"Returns an integer which is the size in bits of `bitstring`.\n\nAllowed in guard tests.\n\n## Examples\n\n iex> bit_size(<<433::16,3::3>>)\n 19\n iex> bit_size(<<1,2,3>>)\n 24\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L491",
:def,
491,
[ { :bitstring,
[ line: 491 ],
nil } ] },
... ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3",
[],
nil,
"Kernel",
3,
nil } },
{ ExDoc.ModuleNode,
Kernel.ParallelRequire,
"ParallelRequire",
"A module responsible for requiring files in parallel.\n",
[ { ExDoc.FunctionNode,
:files,
2,
"files/2",
"Requires the given files.\n\nA callback that is invoked every time a file is required\ncan be optionally given as argument.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel/parallel_require.ex#L14",
:def,
14,
[ { :files,
[ line: 14 ],
nil },
{ ://,
[ line: 14 ],
[ { :callback,
[ line: 14 ],
nil },
{ :default_callback,
[ line: 14 ],
nil } ] } ] } ],
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel/parallel_require.ex#L1",
[],
nil,
"Kernel.ParallelRequire",
1,
{ ExDoc.ModuleNode,
Kernel,
"Kernel",
"`Kernel` provides the default macros and functions\nElixir imports into your environment. Those macros and functions\ncan be skipped or cherry-picked via the `import` macro. For\ninstance, if you want to tell Elixir to not import the `case`\nmacro, you can do:\n\n import Kernel, except: [case: 2]\n\nElixir also has special forms that are always imported and\ncannot be skipped. These are described in `Kernel.SpecialForms`.\n\nSome of the functions described in this module are simply\na proxy to its Erlang counterpart. Although they are documented\nhere for convenience, you can access their original documentation\nat http://www.erlang.org/doc/man/erlang.html.\n",
[ { ExDoc.FunctionNode,
:!,
1,
"!/1",
"Receives any argument and returns true if it is false\nor nil. Returns false otherwise. Not allowed in guard\nclauses.\n\n## Examples\n\n iex> !1\n false\n iex> ![1,2,3]\n false\n iex> !false\n true\n iex> !nil\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L180",
:defmacro,
180,
[ { :arg,
[ line: 180 ],
nil } ] },
{ ExDoc.FunctionNode,
:!=,
2,
"!=/2",
"Returns true if the two items are not equal.\n\nThis operator considers 1 and 1.0 to be equal. For strict\ncomparison, use `!==` instead.\n\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 != 2\n true\n iex> 1 != 1.0\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L265",
:defmacro,
265,
[ { :left,
[ line: 265 ],
nil },
{ :right,
[ line: 265 ],
nil } ] },
{ ExDoc.FunctionNode,
:!==,
2,
"!==/2",
"Returns true if the two items are strictly not equal.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 !== 2\n true\n\n iex> 1 !== 1.0\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L295",
:defmacro,
295,
[ { :left,
[ line: 295 ],
nil },
{ :right,
[ line: 295 ],
nil } ] },
{ ExDoc.FunctionNode,
:&&,
2,
"&&/2",
"Provides a short-circuit operator that evaluates and returns\nthe second expression only if the first one evaluates to true\n(i.e. it is not nil nor false). Returns the first expression\notherwise.\n\n## Examples\n\n iex> true && true\n true\n iex> nil && true\n nil\n iex> true && 1\n 1\n iex> false && throw(:bad)\n false\n\nNotice that, differently from Erlang `and` operator,\nthis operator accepts any expression as arguments,\nnot only booleans, however it is not allowed in guards.\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2896",
:defmacro,
2896,
[ { :left,
[ line: 2896 ],
nil },
{ :right,
[ line: 2896 ],
nil } ] },
{ ExDoc.FunctionNode,
:*,
2,
"*/2",
"Arithmetic multiplication. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 * 2\n 2\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L53",
:defmacro,
53,
[ { :left,
[ line: 53 ],
nil },
{ :right,
[ line: 53 ],
nil } ] },
{ ExDoc.FunctionNode,
:+,
2,
"+/2",
"Arithmetic plus. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 + 2\n 3\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L31",
:defmacro,
31,
[ { :left,
[ line: 31 ],
nil },
{ :right,
[ line: 31 ],
nil } ] },
{ ExDoc.FunctionNode,
:++,
2,
"++/2",
"Concatenates two lists. Allowed in guard clauses.\n\n## Examples\n\n iex> [1] ++ [2,3]\n [1,2,3]\n\n iex> 'foo' ++ 'bar'\n 'foobar'\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L95",
:defmacro,
95,
[ { :left,
[ line: 95 ],
nil },
{ :right,
[ line: 95 ],
nil } ] },
{ ExDoc.FunctionNode,
:-,
2,
"-/2",
"Arithmetic minus. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 - 2\n -1\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L42",
:defmacro,
42,
[ { :left,
[ line: 42 ],
nil },
{ :right,
[ line: 42 ],
nil } ] },
{ ExDoc.FunctionNode,
:--,
2,
"--/2",
"Removes the first occorrence of an item on the left\nfor each item on the right. Allowed in guard clauses.\n\n## Examples\n\n iex> [1,2,3] -- [1,2]\n [3]\n\n iex> [1,2,3,2,1] -- [1,2,2]\n [3,1]\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L110",
:defmacro,
110,
[ { :left,
[ line: 110 ],
nil },
{ :right,
[ line: 110 ],
nil } ] },
{ ExDoc.FunctionNode,
:..,
2,
"../2",
"Returns a range with the specified start and end.\nIncludes both ends.\n\n## Examples\n\n iex> 0 in 1..3\n false\n iex> 1 in 1..3\n true\n iex> 2 in 1..3\n true\n iex> 3 in 1..3\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2871",
:defmacro,
2871,
[ { :first,
[ line: 2871 ],
nil },
{ :last,
[ line: 2871 ],
nil } ] },
{ ExDoc.FunctionNode,
:/,
2,
"//2",
"Arithmetic division. Differently from other languages,\nthe result is always a float. Use div and rem if you want\na natural division or the remainder. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 / 2\n 0.5\n iex> 2 / 1\n 2.0\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L68",
:defmacro,
68,
[ { :left,
[ line: 68 ],
nil },
{ :right,
[ line: 68 ],
nil } ] },
{ ExDoc.FunctionNode,
:<,
2,
"</2",
"Returns true if left is less than right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 < 2\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L192",
:defmacro,
192,
[ { :left,
[ line: 192 ],
nil },
{ :right,
[ line: 192 ],
nil } ] },
{ ExDoc.FunctionNode,
:<-,
2,
"<-/2",
"Sends a message to the process identified on the left.\nA process can be identified bu its PID or, if it is registered,\nby an atom.\n\n## Examples\n\n process = Kernel.self\n process <- { :ok, \"Sending myself a message\" }\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L81",
:defmacro,
81,
[ { :pid,
[ line: 81 ],
nil },
{ :msg,
[ line: 81 ],
nil } ] },
{ ExDoc.FunctionNode,
:<=,
2,
"<=/2",
"Returns true if left is less than or equal to right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 <= 2\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L216",
:defmacro,
216,
[ { :left,
[ line: 216 ],
nil },
{ :right,
[ line: 216 ],
nil } ] },
{ ExDoc.FunctionNode,
:<>,
2,
"<>/2",
"Concatenates two binaries.\n\n## Examples\n\n iex> \"foo\" <> \"bar\"\n \"foobar\"\n\nThe `<>` operator can also be used in guard clauses as\nlong as the first part is a literal binary:\n\n iex> \"foo\" <> x = \"foobar\"\n ...> x\n \"bar\"\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2850",
:defmacro,
2850,
[ { :left,
[ line: 2850 ],
nil },
{ :right,
[ line: 2850 ],
nil } ] },
{ ExDoc.FunctionNode,
:==,
2,
"==/2",
"Returns true if the two items are equal.\n\nThis operator considers 1 and 1.0 to be equal. For strict\ncomparison, use `===` instead.\n\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 == 2\n false\n\n iex> 1 == 1.0\n true\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L247",
:defmacro,
247,
[ { :left,
[ line: 247 ],
nil },
{ :right,
[ line: 247 ],
nil } ] },
{ ExDoc.FunctionNode,
:===,
2,
"===/2",
"Returns true if the two items are strictly equal.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 === 2\n false\n\n iex> 1 === 1.0\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L280",
:defmacro,
280,
[ { :left,
[ line: 280 ],
nil },
{ :right,
[ line: 280 ],
nil } ] },
{ ExDoc.FunctionNode,
:=~,
2,
"=~/2",
"Matches the term on the left against the regular expression\non the right. It returns nil if not match happened or the\nfirst match otherwise.\n\n## Examples\n\n iex> \"abcd\" =~ %r/c(d)/\n 2\n iex> \"abcd\" =~ %r/e/\n nil\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2990",
:defmacro,
2990,
[ { :left,
[ line: 2990 ],
nil },
{ :right,
[ line: 2990 ],
nil } ] },
{ ExDoc.FunctionNode,
:>,
2,
">/2",
"Returns true if left is more than right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 > 2\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L204",
:defmacro,
204,
[ { :left,
[ line: 204 ],
nil },
{ :right,
[ line: 204 ],
nil } ] },
{ ExDoc.FunctionNode,
:>=,
2,
">=/2",
"Returns true if left is more than or equal to right.\nLike Erlang, Elixir can compare any term. Allowed in guard clauses.\n\n## Examples\n\n iex> 1 >= 2\n false\n\n",
"https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L228",
:defmacro,
228,
[ { :left,
[ line: 228 ],
nil },
{ :right,
[ line: 228 ],
nil } ] },
{ ExDoc.FunctionNode,
:@,
1,
"@/1",
"This macro is a shortcut to read and add attributes to the module\nbeing compiled. Elixir module attributes are similar to Erlang's with\nsome differences. The canonical example for attributes is annotating\nthat a module implements the OTP behavior called `gen_server`:\n\n defmodule MySe
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment