{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# IElixir - Elixir kernel for Jupyter Project\n", "\n", "\n", "\n", "---\n", "\n", "## Google Summer of Code 2015\n", "> Developed by [Piotr Przetacznik](https://twitter.com/pprzetacznik)\n", "\n", "> Mentored by [José Valim](https://twitter.com/josevalim)\n", "\n", "---\n", "## References\n", "\n", "* [Elixir language](http://elixir-lang.org/)\n", "* [Jupyter Project](https://jupyter.org/)\n", "* [IElixir sources](https://github.com/pprzetacznik/IElixir)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Getting Started\n", "\n", "### Basic Types\n", "\n", "
\n",
    "1          # integer\n",
    "0x1F       # integer\n",
    "1.0        # float\n",
    "true       # boolean\n",
    ":atom      # atom / symbol\n",
    "\"elixir\"   # string\n",
    "[1, 2, 3]  # list\n",
    "{1, 2, 3}  # tuple\n",
    "
\n", "\n", "### Basic arithmetic" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1 + 1" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "\u001b[33mwarning: \u001b[0mredefining module Unless (current version defined in memory)\n", " nofile:1\n", "\n" ] }, { "data": { "text/plain": [ "{:module, Unless, <<70, 79, 82, 49, 0, 0, 6, 40, 66, 69, 65, 77, 65, 116, 85, 56, 0, 0, 0, 168, 0, 0, 0, 19, 13, 69, 108, 105, 120, 105, 114, 46, 85, 110, 108, 101, 115, 115, 8, 95, 95, 105, 110, 102, 111, 95, 95, ...>>, {:macro_unless, 2}}" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "defmodule Unless do\n", " def fun_unless(clause, do: expression) do\n", " if(!clause, do: expression)\n", " end\n", "\n", " defmacro macro_unless(clause, do: expression) do\n", " quote do\n", " if(!unquote(clause), do: unquote(expression))\n", " end\n", " end\n", "end" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "this should never be printed\n" ] }, { "data": { "text/plain": [ ":ok" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "require Unless\n", "\n", "Unless.macro_unless false, do: IO.puts \"this should never be printed\"" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{{:., [], [{:__aliases__, [alias: false], [:Unless]}, :macro_unless]}, [], [false, [do: {{:., [], [{:__aliases__, [alias: false], [:IO]}, :puts]}, [], [\"this should never be printed\"]}]]}" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "quote do: Unless.macro_unless false, do: IO.puts \"this should never be printed\"" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{{:., [], [{:__aliases__, [alias: false], [:Unless]}, :fun_unless]}, [], [false, [do: {{:., [], [{:__aliases__, [alias: false], [:IO]}, :puts]}, [], [\"this should never be printed\"]}]]}" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "quote do: Unless.fun_unless false, do: IO.puts \"this should never be printed\"" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{:if, [context: Unless, import: Kernel], [{:!, [context: Unless, import: Kernel], [false]}, [do: {{:., [], [{:__aliases__, [alias: false, counter: -576460752303423480], [:IO]}, :puts]}, [], [\"this should never be printed\"]}]]}" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "expr = quote do: Unless.macro_unless false, do: IO.puts \"this should never be printed\"\n", "res = Macro.expand_once(expr, __ENV__)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "if(!false) do\n", " IO.puts(\"this should never be printed\")\n", "end\n" ] }, { "data": { "text/plain": [ ":ok" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "IO.puts Macro.to_string(res)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{{:., [], [{:__aliases__, [alias: false], [:Unless]}, :fun_unless]}, [], [false, [do: {{:., [], [{:__aliases__, [alias: false], [:IO]}, :puts]}, [], [\"this should never be printed\"]}]]}" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "expr = quote do: Unless.fun_unless false, do: IO.puts \"this should never be printed\"\n", "res = Macro.expand_once(expr, __ENV__)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Unless.fun_unless(false) do\n", " IO.puts(\"this should never be printed\")\n", "end\n" ] }, { "data": { "text/plain": [ ":ok" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "IO.puts Macro.to_string(res)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "defmodule CaptureIO2 do\n", " defmacro test1(do: expression) do\n", " quote do\n", " original_gl = Process.group_leader()\n", " {:ok, capture_gl} = StringIO.open(\"\", capture_prompt: true)\n", " original_err = Process.whereis(:standard_error)\n", " {:ok, capture_err} = StringIO.open(\"\", capture_prompt: true)\n", " \n", " try do\n", " Process.group_leader(self(), capture_gl)\n", " Process.unregister(:standard_error)\n", " Process.register(capture_err, :standard_error)\n", " \n", " result = unquote(expression)\n", " \n", " {:ok, {_, output_string}} = StringIO.close(capture_gl)\n", " {_, error_string} = StringIO.contents(capture_err)\n", " \n", " {result, output_string, error_string}\n", " after\n", " Process.group_leader(self(), original_gl)\n", " \n", " Process.unregister(:standard_error)\n", " StringIO.close(capture_err)\n", " Process.register(original_err, :standard_error)\n", " end\n", " end\n", " end\n", " end" ] }, { "cell_type": "code", "execution_count": 141, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "\u001b[33mwarning: \u001b[0mredefining module CaptureIO2 (current version defined in memory)\n", " nofile:1\n", "\n" ] }, { "data": { "text/plain": [ "{:module, CaptureIO2, <<70, 79, 82, 49, 0, 0, 8, 72, 66, 69, 65, 77, 65, 116, 85, 56, 0, 0, 0, 155, 0, 0, 0, 17, 17, 69, 108, 105, 120, 105, 114, 46, 67, 97, 112, 116, 117, 114, 101, 73, 79, 50, 8, 95, 95, 105, 110, ...>>, {:test1, 1}}" ] }, "execution_count": 141, "metadata": {}, "output_type": "execute_result" } ], "source": [ "defmodule CaptureIO2 do\n", " defmacro test1(do: expression) do\n", " quote do\n", " original_gl = Process.group_leader()\n", " {:ok, capture_gl} = StringIO.open(\"\", capture_prompt: true)\n", " \n", " original_err = Process.whereis(:standard_error)\n", " {:ok, capture_err} = StringIO.open(\"\", capture_prompt: true)\n", " \n", " try do\n", " Process.group_leader(self(), capture_gl)\n", " \n", " Process.unregister(:standard_error)\n", " Process.register(capture_err, :standard_error)\n", " \n", " result = unquote(expression)\n", " \n", "# IO.puts(:stderr, \"teststderrgoestothelog\")\n", " {:ok, {_, output_string}} = StringIO.close(capture_gl)\n", " {_, error_string} = StringIO.contents(capture_err)\n", " \n", " IO.puts(original_gl, \"teststdio\")\n", " IO.puts(original_err, \"teststderr\")\n", " \n", " {result, output_string, error_string}\n", "# rescue\n", "# e in RuntimeError -> \"RTE\"\n", "# e in CompileError -> \"CE\"\n", "# error ->\n", "# raise(error)\n", "# {:error, error}\n", "# # a ->\n", "# # {:a, a}\n", " after\n", " Process.group_leader(self(), original_gl)\n", " \n", " Process.unregister(:standard_error)\n", " StringIO.close(capture_err)\n", " Process.register(original_err, :standard_error)\n", " IO.puts(\"testafter2\")\n", " end\n", " end\n", " end\n", " end" ] }, { "cell_type": "code", "execution_count": 145, "metadata": {}, "outputs": [ { "ename": "MatchError", "evalue": "1", "output_type": "error", "traceback": [ "** %MatchError{term: {:error, {1, \"syntax error before: \", \"\"}}}" ] } ], "source": [] }, { "cell_type": "code", "execution_count": 144, "metadata": {}, "outputs": [ { "ename": "MatchError", "evalue": "1", "output_type": "error", "traceback": [ "** %MatchError{term: {:error, {7, \"syntax error before: \", \"\\\"2\\\"\"}}}" ] } ], "source": [ "require CaptureIO2\n", "\n", "CaptureIO2.test1 do\n", " IO.puts(\"aaa\")\n", "# %{file: file, line: line} = __CALLER__\n", "# File.read! \"unknown\"\n", " :elixir_errors.warn 1 2 \"aaa\"\n", "end" ] }, { "cell_type": "code", "execution_count": 140, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "teststdio\n", "testafter2\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "teststderr\n" ] }, { "data": { "text/plain": [ "{:ok, \"aaa\\n\", \"teststderrgoestothelog\\n\"}" ] }, "execution_count": 140, "metadata": {}, "output_type": "execute_result" } ], "source": [ "require CaptureIO2\n", "\n", "CaptureIO2.test1 do\n", " IO.puts(\"aaa\")\n", "# %{file: file, line: line} = __CALLER__\n", "# File.read! \"unknown\"\n", "# :elixir_errors.warn \"aaa\"\n", "end" ] }, { "cell_type": "code", "execution_count": 133, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{:ok, \"aaa\\n\", \"\"}" ] }, "execution_count": 133, "metadata": {}, "output_type": "execute_result" } ], "source": [ "require IElixir.CaptureIO\n", "\n", "IElixir.CaptureIO.capture(fn ->\n", " IO.puts(\"aaa\")\n", "# :elixir_errors.warn \"aaa\"\n", "# asdf\n", "end)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "ename": "ArgumentError", "evalue": "1", "output_type": "error", "traceback": [ "** (ArgumentError) \"argument error\"" ] } ], "source": [ "require CaptureIO2\n", "\n", "expr = CaptureIO2.capture2 1+1\n", "# res = Macro.expand_once(expr, __ENV__)\n", "# IO.puts Macro.to_string(res)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "ename": "MatchError", "evalue": "1", "output_type": "error", "traceback": [ "** %MatchError{term: {1, 2}}" ] } ], "source": [ "{a} = {1,2}" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "25\n" ] }, { "data": { "text/plain": [ "25" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "IO.inspect 5 * 5" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5.0" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "10 / 2" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "div(10, 2)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "div 10, 2" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rem 10, 3" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "10" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "0b1010" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "511" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "0o777" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "31" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "0x1F" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.0" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1.0" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.0e-10" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1.0e-10" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "round 3.58" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "trunc 3.58" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Booleans" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"true\"" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "true" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "false" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "true == false" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "true" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "is_boolean(true)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "false" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "is_boolean(1)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "true" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "is_integer(5)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "false" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "is_float(5)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "false" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "is_number(\"5.0\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Atoms" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ ":hello" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ ":hello" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "false" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ ":hello == :world" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "true" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "true == :true" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "true" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "is_atom(false)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "true" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "is_boolean(:false)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Strings" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"hellö\"" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"hellö\"" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"hellö world\"" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "\"hellö #{:world}\"" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "hello\n", "world\n" ] }, { "data": { "text/plain": [ ":ok" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "IO.puts \"hello\\nworld\"" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "true" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "is_binary(\"hellö\")" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "byte_size(\"hellö\")" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "String.length(\"hellö\")" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"HELLÖ\"" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "String.upcase(\"hellö\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Anonymous functions" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "#Function<12.99386804/2 in :erl_eval.expr/5>" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "add = fn a, b -> a + b end" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "true" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "is_function(add)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "true" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "is_function(add, 2)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "false" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "is_function(add, 1)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "add.(1, 2)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "#Function<6.99386804/1 in :erl_eval.expr/5>" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "add_two = fn a -> add.(a, 2) end" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "add_two.(2)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "42" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = 42\n", "(fn -> x = 0 end).()\n", "x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### (Linked) Lists" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, true, 3]" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = [1, 2, true, 3]" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "length [1, 2, 3]" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4, 5, 6]" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[1, 2, 3] ++ [4, 5, 6]" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, true]" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[1, true, 2, false, 3, true] -- [true, false]" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "hd(a)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[2, true, 3]" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tl(a)" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "ename": "ArgumentError", "evalue": "1", "output_type": "error", "traceback": [ "** (ArgumentError) \"argument error\"" ] } ], "source": [ "hd []" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'\\v\\f\\r'" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[11, 12, 13]" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'hello'" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[104, 101, 108, 108, 111]" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "false" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "'hello' == \"hello\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Tuples" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{:ok, \"hello\"}" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "{:ok, \"hello\"}" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tuple_size {:ok, \"hello\"}" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{:ok, \"hello\"}" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tuple = {:ok, \"hello\"}" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\"hello\"" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "elem(tuple, 1)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tuple_size(tuple)" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{:ok, \"world\"}" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "put_elem(tuple, 1, \"world\")" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{:ok, \"hello\"}" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "tuple" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Lists or tuples?" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3]" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list = [1|[2|[3|[]]]]" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[0, 1, 2, 3]" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[0] ++ list" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 2, 3, 4]" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "list ++ [4]" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{:ok, \"Copyright 2015 Piotr Przetacznik\\n\\n Licensed under the Apache License, Version 2.0 (the \\\"License\\\");\\n you may not use this file except in compliance with the License.\\n You may obtain a copy of the License at\\n\\n http://www.apache.org/licenses/LICENSE-2.0\\n\\n Unless required by applicable law or agreed to in writing, software\\n distributed under the License is distributed on an \\\"AS IS\\\" BASIS,\\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\\n See the License for the specific language governing permissions and\\n limitations under the License.\\n\"}" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "File.read(\"LICENSE\")" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{:error, :enoent}" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "File.read(\"path/to/unknown/file\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Other examples" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "31" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "0x1F" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "175\n" ] }, { "data": { "text/plain": [ ":ok" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = 25\n", "b = 150\n", "IO.puts(a+b)" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{:module, Math, <<70, 79, 82, 49, 0, 0, 4, 32, 66, 69, 65, 77, 65, 116, 85, 56, 0, 0, 0, 124, 0, 0, 0, 14, 11, 69, 108, 105, 120, 105, 114, 46, 77, 97, 116, 104, 8, 95, 95, 105, 110, 102, 111, 95, 95, 9, 102, ...>>, {:sum, 2}}" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "defmodule Math do\n", " def sum(a, b) do\n", " a + b\n", " end\n", "end" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Math.sum(1, 2)" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "true" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import ExUnit.CaptureIO\n", "capture_io(fn -> IO.write \"john\" end) == \"john\"" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "97" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "?a" ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "true" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "<<98>> == <>" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "true" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "<> == \"go\n", "\"" ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{\"head\", \"body\"}" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "{hlen, blen} = {4, 4}\n", "<
> = \"headbody\"\n", "{header, body}" ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[0m\n", "\u001b[7m\u001b[33m IEx.Helpers \u001b[0m\n", "\u001b[0m\n", "Welcome to Interactive Elixir. You are currently seeing the documentation for\n", "the module \u001b[36mIEx.Helpers\u001b[0m which provides many helpers to make Elixir's shell more\n", "joyful to work with.\n", "\u001b[0m\n", "This message was triggered by invoking the helper \u001b[36mh()\u001b[0m, usually referred to as\n", "\u001b[36mh/0\u001b[0m (since it expects 0 arguments).\n", "\u001b[0m\n", "You can use the \u001b[36mh/1\u001b[0m function to invoke the documentation for any Elixir module\n", "or function:\n", "\u001b[0m\n", "\u001b[36m iex> h(Enum)\n", " iex> h(Enum.map)\n", " iex> h(Enum.reverse/1)\u001b[0m\n", "\u001b[0m\n", "You can also use the \u001b[36mi/1\u001b[0m function to introspect any value you have in the\n", "shell:\n", "\u001b[0m\n", "\u001b[36m iex> i(\"hello\")\u001b[0m\n", "\u001b[0m\n", "There are many other helpers available, here are some examples:\n", "\u001b[0m\n", " • \u001b[36mb/1\u001b[0m - prints callbacks info and docs for a given module\n", " • \u001b[36mc/1\u001b[0m - compiles a file into the current directory\n", " • \u001b[36mc/2\u001b[0m - compiles a file to the given path\n", " • \u001b[36mcd/1\u001b[0m - changes the current directory\n", " • \u001b[36mclear/0\u001b[0m - clears the screen\n", " • \u001b[36mexports/1\u001b[0m - shows all exports (functions + macros) in a module\n", " • \u001b[36mflush/0\u001b[0m - flushes all messages sent to the shell\n", " • \u001b[36mh/0\u001b[0m - prints this help message\n", " • \u001b[36mh/1\u001b[0m - prints help for the given module, function or macro\n", " • \u001b[36mi/0\u001b[0m - prints information about the last value\n", " • \u001b[36mi/1\u001b[0m - prints information about the given term\n", " • \u001b[36mls/0\u001b[0m - lists the contents of the current directory\n", " • \u001b[36mls/1\u001b[0m - lists the contents of the specified directory\n", " • \u001b[36mopen/1\u001b[0m - opens the source for the given module or function in\n", " your editor\n", " • \u001b[36mpid/1\u001b[0m - creates a PID from a string\n", " • \u001b[36mpid/3\u001b[0m - creates a PID with the 3 integer arguments passed\n", " • \u001b[36mref/1\u001b[0m - creates a Reference from a string\n", " • \u001b[36mref/4\u001b[0m - creates a Reference with the 4 integer arguments\n", " passed\n", " • \u001b[36mpwd/0\u001b[0m - prints the current working directory\n", " • \u001b[36mr/1\u001b[0m - recompiles the given module's source file\n", " • \u001b[36mrecompile/0\u001b[0m - recompiles the current project\n", " • \u001b[36mruntime_info/0\u001b[0m - prints runtime info (versions, memory usage, stats)\n", " • \u001b[36mv/0\u001b[0m - retrieves the last value from the history\n", " • \u001b[36mv/1\u001b[0m - retrieves the nth value from the history\n", "\u001b[0m\n", "Help for all of those functions can be consulted directly from the command line\n", "using the \u001b[36mh/1\u001b[0m helper itself. Try:\n", "\u001b[0m\n", "\u001b[36m iex> h(v/0)\u001b[0m\n", "\u001b[0m\n", "To list all IEx helpers available, which is effectively all exports (functions\n", "and macros) in the \u001b[36mIEx.Helpers\u001b[0m module:\n", "\u001b[0m\n", "\u001b[36m iex> exports(IEx.Helpers)\u001b[0m\n", "\u001b[0m\n", "This module also includes helpers for debugging purposes, see \u001b[36mIEx.break!/4\u001b[0m for\n", "more information.\n", "\u001b[0m\n", "To learn more about IEx as a whole, type \u001b[36mh(IEx)\u001b[0m.\n", "\u001b[0m\n" ] }, { "data": { "text/plain": [ "do not show this result in output" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "h()" ] }, { "cell_type": "code", "execution_count": 62, "metadata": { "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "\u001b[33mwarning: \u001b[0mredefining module KV.Registry (current version defined in memory)\n", " nofile:1\n", "\n", "\u001b[33mwarning: \u001b[0mHashDict.new/0 is deprecated, use maps and the Map module instead\n", " nofile:32\n", "\n", "\u001b[33mwarning: \u001b[0mHashDict.fetch/2 is deprecated, use maps and the Map module instead\n", " nofile:36\n", "\n", "\u001b[33mwarning: \u001b[0mHashDict.has_key?/2 is deprecated, use maps and the Map module instead\n", " nofile:40\n", "\n", "\u001b[33mwarning: \u001b[0mHashDict.put/3 is deprecated, use maps and the Map module instead\n", " nofile:44\n", "\n" ] }, { "data": { "text/plain": [ "{:module, KV.Registry, <<70, 79, 82, 49, 0, 0, 15, 52, 66, 69, 65, 77, 65, 116, 85, 56, 0, 0, 1, 166, 0, 0, 0, 44, 18, 69, 108, 105, 120, 105, 114, 46, 75, 86, 46, 82, 101, 103, 105, 115, 116, 114, 121, 8, 95, 95, 105, ...>>, {:handle_cast, 2}}" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "defmodule KV.Registry do\n", " use GenServer\n", "\n", " ## Client API\n", "\n", " @doc \"\"\"\n", " Starts the registry.\n", " \"\"\"\n", " def start_link(opts \\\\ []) do\n", " GenServer.start_link(__MODULE__, :ok, opts)\n", " end\n", "\n", " @doc \"\"\"\n", " Looks up the bucket pid for `name` stored in `server`.\n", "\n", " Returns `{:ok, pid}` if the bucket exists, `:error` otherwise.\n", " \"\"\"\n", " def lookup(server, name) do\n", " GenServer.call(server, {:lookup, name})\n", " end\n", "\n", " @doc \"\"\"\n", " Ensures there is a bucket associated to the given `name` in `server`.\n", " \"\"\"\n", " def create(server, name) do\n", " GenServer.cast(server, {:create, name})\n", " end\n", "\n", " ## Server Callbacks\n", "\n", " def init(:ok) do\n", " {:ok, HashDict.new}\n", " end\n", "\n", " def handle_call({:lookup, name}, _from, names) do\n", " {:reply, HashDict.fetch(names, name), names}\n", " end\n", "\n", " def handle_cast({:create, name}, names) do\n", " if HashDict.has_key?(names, name) do\n", " {:noreply, names}\n", " else\n", " {:ok, bucket} = KV.Bucket.start_link()\n", " {:noreply, HashDict.put(names, name, bucket)}\n", " end\n", " end\n", "end" ] }, { "cell_type": "code", "execution_count": 63, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "[#Function<2.42286359/1 in ExUnit.start/1>]" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "ExUnit.start()" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{:module, KV.RegistryTest, <<70, 79, 82, 49, 0, 0, 15, 132, 66, 69, 65, 77, 65, 116, 85, 56, 0, 0, 1, 232, 0, 0, 0, 47, 22, 69, 108, 105, 120, 105, 114, 46, 75, 86, 46, 82, 101, 103, 105, 115, 116, 114, 121, 84, 101, 115, 116, ...>>, {:\"test spawns buckets\", 1}}" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "defmodule KV.RegistryTest do\n", " use ExUnit.Case, async: true\n", "\n", " setup do\n", " {:ok, registry} = KV.Registry.start_link\n", " {:ok, registry: registry}\n", " end\n", "\n", " test \"spawns buckets\", %{registry: registry} do\n", " assert KV.Registry.lookup(registry, \"shopping\") == :error\n", "\n", " KV.Registry.create(registry, \"shopping\")\n", " assert {:ok, bucket} = KV.Registry.lookup(registry, \"shopping\")\n", "\n", " KV.Bucket.put(bucket, \"milk\", 1)\n", " assert KV.Bucket.get(bucket, \"milk\") == 1\n", " end\n", "end" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Elixir", "language": "Elixir", "name": "ielixir" }, "language_info": { "codemirror_mode": "elixir", "file_extension": "ex", "mimetype": "text/x-elixir", "name": "elixir", "nbconvert_exporter": "", "pygments_lexer": "elixir", "version": "1.6.5" } }, "nbformat": 4, "nbformat_minor": 1 }