learnelixir.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "learnelixir.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyMHHT4LGNEfq9MPSxBvbZS9",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kalz2q/mycolabnotebooks/blob/master/learnelixir.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RfpoUurcVnZv"
      },
      "source": [
        "# メモ\n",
        "\n",
        "elixir を齧る。かじる。\n",
        "\n",
        "今のイメージ $\\quad$ erlang 上で、erlang は 並行処理のためのシステムで、その erlang 上で理想的な言語を作ろうとしたら、ruby + clojure みたいな言語になった。\n",
        "\n",
        "Dave Thomas と まつもとゆきひろ が勧めているのだからいい言語なのだろう。\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kEf4GSz_Vva4"
      },
      "source": [
        "* https://elixirschool.com/ja/lessons/basics/control-structures/\n",
        "* https://magazine.rubyist.net/articles/0054/0054-ElixirBook.\n",
        "* https://dev.to/gumi/elixir-01--2585\n",
        "* https://elixir-lang.org/getting-started/introduction.html\n",
        "\n",
        "---\n",
        "本を買った。\n",
        "\n",
        "プログラミング elixir\n",
        "\n",
        "dave thomas, 笹田耕一・鳥居雪訳、 ohmsha\n",
        "programming elixir |> 1.6\n",
        "\n",
        "を読む。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "THvpbkjdWs0Q"
      },
      "source": [
        "%%capture\n",
        "!wget https://packages.erlang-solutions.com/erlang-solutions_2.0_all.deb && sudo dpkg -i erlang-solutions_2.0_all.deb\n",
        "!sudo apt update\n",
        "!sudo apt install elixir"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6FkejEE2crA5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "04e2f1d2-bcc5-48d4-9368-9381e04b9bf3"
      },
      "source": [
        "!elixir -v\n",
        "!date"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Erlang/OTP 24 [erts-12.2.1] [source] [64-bit] [smp:2:2] [ds:2:2:10] [async-threads:1] [jit]\n",
            "\n",
            "Elixir 1.13.0 (compiled with Erlang/OTP 24)\n",
            "Wed Mar 16 16:43:56 UTC 2022\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IpYclRqgcttK"
      },
      "source": [
        "---\n",
        "メモ\n",
        "\n",
        "`!elixir -h` (ヘルプ)としたらシェルワンライナー `elixir -e` が使えるらしいことがわかった。\n",
        "\n",
        "`iex` というのがインタラクティブ環境なのだが、colab では使いにくいので `elixir -e` で代用する。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S_s89E37Xroq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "282c10a5-37ca-4746-d9e1-577df7d1211b"
      },
      "source": [
        "!elixir -e 'IO.puts 3 + 3'\n",
        "!elixir -e 'IO.puts \"hello world!\"'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n",
            "hello world!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RYCKapxtdtco",
        "outputId": "da745095-20e3-4c15-a3e3-1cc0c49408af"
      },
      "source": [
        "# 次のようにすればファイルが作れる\n",
        "%%writefile temp.exs\n",
        "IO.puts \"this is a pen.\""
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# cat してみる\n",
        "!cat temp.exs"
      ],
      "metadata": {
        "id": "N3_QSeBGCWS3",
        "outputId": "c70f02ea-2fec-462a-d59a-9ffa201b64aa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "IO.puts \"this is a pen.\""
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "06mP6Jy_d505",
        "outputId": "8fe41fcd-a47e-4129-ccd3-d8c3338e544b"
      },
      "source": [
        "# ファイルを elixir で実行する\n",
        "!elixir temp.exs"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "this is a pen.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7NE03KtbjVDc"
      },
      "source": [
        "---\n",
        "ネットで紹介されていた次のコードセルのコードはどうやって実行するのだろう。 今はわからなくていいと思うがとりあえず転記しておく。\n",
        "\n",
        "説明:\n",
        "\n",
        "このプログラムでは、Parallel というモジュールに pmap という関数を定義しているmap は、与えられたコレクションに対して map（Ruby での Enumerable#map と同じようなものと考えて下さい）を行なうのですが、 各要素の処理を、要素数の分だけプロセスを生成し、各プロセスで並行に実行する、というものです。 ちょっと見ても、よくわからないような気がしますが、大丈夫、本書を読めば、わかるようになりる\n",
        "\n",
        "とのこと。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_OFyxKshdQ2W",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "25482b7a-570b-4c6b-92d2-8eafc793c0c3"
      },
      "source": [
        "%%writefile temp.exs\n",
        "defmodule Parallel do\n",
        "  def pmap(collection, func) do\n",
        "    collection\n",
        "    |> Enum.map(&(Task.async(fn -> func.(&1) end)))\n",
        "    |> Enum.map(&Task.await/1)\n",
        "  end\n",
        "end\n",
        "\n",
        "result = Parallel.pmap 1..1000, &(&1 * &1)\n",
        "\n",
        "IO.inspect result"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B4ysN080Mcaw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e9b750ae-d6dd-4d56-d5e0-28a48d87c072"
      },
      "source": [
        "!elixir temp.exs"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324,\n",
            " 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089,\n",
            " 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116,\n",
            " 2209, 2304, 2401, 2500, ...]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d9aiwzGwe_Kn"
      },
      "source": [
        "上の例で colab 環境で非同期処理が問題なく動くことが確認できたみたい。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jbgpkxtYpARC"
      },
      "source": [
        "---\n",
        "次のもネットで紹介されていた例で、ハローワールド並行処理版\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kg0J7hd8pHXP",
        "outputId": "bee5ac09-3b90-434a-e786-a3b799918cc6"
      },
      "source": [
        "%%writefile temp.exs\n",
        "parent = self()\n",
        " \n",
        "spawn_link(fn ->\n",
        "  send parent, {:msg, \"hello world\"}\n",
        "end)\n",
        " \n",
        "receive do\n",
        "  {:msg, contents} -> IO.puts contents\n",
        "end"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XWmyBYpEpZ4n",
        "outputId": "71865fe1-a34a-4d25-ae28-5285c72cade6"
      },
      "source": [
        "!elixir temp.exs"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello world\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z6EdDr20r5q8"
      },
      "source": [
        "上の例でやっていることはつぎのような流れである。\n",
        "\n",
        "1. spawn_linkという関数に渡された関数が、関数の内容を実行する。\n",
        "2. 新しく作られたプロセス側では、メインプロセス側（parent）に “hello world” というメッセージを送る。\n",
        "3. メインプロセス側は、どこからかメッセージが来ないかを待ち受けて（receive）、メッセージが来たらそれをコンソールに表示する。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gXbF4HnE1jnt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5fe4d217-7fc5-4aa7-e554-57e06c0bb92f"
      },
      "source": [
        "# 実験 とりあえず理解しない。 colab 環境でどうかだけ調べる。\n",
        "%%writefile chain.exs\n",
        "defmodule Chain do\n",
        "  def counter(next_pid) do\n",
        "    receive do\n",
        "      n -> send next_pid, n + 1\n",
        "    end\n",
        "  end\n",
        " \n",
        "  def create_processes(n) do\n",
        "    last = Enum.reduce 1..n, self(),\n",
        "      fn (_, send_to) -> spawn(Chain, :counter, [send_to]) end\n",
        "    send last, 0\n",
        "    receive do\n",
        "      final_answer when is_integer(final_answer) ->\n",
        "        \"Result is #{inspect(final_answer)}\"\n",
        "    end\n",
        "  end\n",
        " \n",
        "  def run(n) do\n",
        "    IO.puts inspect :timer.tc(Chain, :create_processes, [n])\n",
        "  end\n",
        "end"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing chain.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Flqn_Jrmrxy1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "750cf48f-2acb-4969-f837-90f1b91b342b"
      },
      "source": [
        "!elixir --erl \"+P 1000000\" -r chain.exs  -e \"Chain.run(1_000_000)\""
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{4638957, \"Result is 1000000\"}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "scVR0hFA2bO8"
      },
      "source": [
        "記事 https://ubiteku.oinker.me/2015/12/22/elixir試飲-2-カルチャーショックに戸惑う-並行指向プ/ のマシン Macbook Pro – 3 GHz Intel Core i7, 16GB RAM では 7 秒のところ、colab では 5 秒で終わってるね!!!!\n",
        "\n",
        "手元のwindowsマシン intel core i5-9400 8gb ram でやったら次のようになった。  \n",
        "{3492935, \"Result is 1000000\"}\n",
        "\n",
        "あれ、速いじゃん!!!!"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ajr_Z2V6mh7Y"
      },
      "source": [
        "---\n",
        "コメントは `#`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DfMZdyUImlsG",
        "outputId": "94b47d9c-653d-432b-ea11-6e447b7253d2"
      },
      "source": [
        "%%writefile temp.exs\n",
        "# コメント実験\n",
        "str = \"helloworld!!!!\"\n",
        "IO.puts str"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qUtHCWc3mtba",
        "outputId": "bc541e73-d1af-44c5-b783-187eb72ebeb8"
      },
      "source": [
        "!elixir temp.exs"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "helloworld!!!!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JSTaVsDvh8Gl"
      },
      "source": [
        "---\n",
        "n 進数、整数 integer"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iosas2W_nx9E",
        "outputId": "737a734e-981f-41de-b4d3-400dc19e8551"
      },
      "source": [
        "!elixir -e 'IO.puts 0b1111'\n",
        "!elixir -e 'IO.puts 0o7777'\n",
        "!elixir -e 'IO.puts 0xffff'\n",
        "!elixir -e 'IO.puts 1000_000_00_0'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "15\n",
            "4095\n",
            "65535\n",
            "1000000000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nOl9SbJnOqdT"
      },
      "source": [
        "整数型に上限下限 fixed limit はない。 factorial(10000) が計算できる。今はしない。\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gpjl9l3FfQwe"
      },
      "source": [
        "---\n",
        "問題\n",
        "\n",
        "10進数を $n$ 進数にベースを変えるのはどうするか。 python では `int()`, `bin()`, `oct()`, `hex()` があった。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k9DwveLAgc84",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "89c4b22b-3f70-44e0-cb29-dc18e6047ba7"
      },
      "source": [
        "# python\n",
        "print(0b1111)\n",
        "print(0o7777)\n",
        "print(0xffff)\n",
        "print(int('7777',8))\n",
        "print(bin(15))\n",
        "print(oct(4095))\n",
        "print(hex(65535))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "15\n",
            "4095\n",
            "65535\n",
            "4095\n",
            "0b1111\n",
            "0o7777\n",
            "0xffff\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TsFxYNSDsMzN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4d6e5960-820d-4c90-faa6-d3bc72edb0e3"
      },
      "source": [
        "!elixir -e 'IO.puts 0b1111'\n",
        "!elixir -e 'IO.puts 0o7777'\n",
        "!elixir -e 'IO.puts 0xffff'\n",
        "!echo\n",
        "# Integer.to_string() と言う関数を使う\n",
        "# <> はバイナリー連結\n",
        "!elixir -e 'IO.puts \"0b\" <> Integer.to_string(15,2)'\n",
        "!elixir -e 'IO.puts \"0o\" <> Integer.to_string(4095,8)'\n",
        "!elixir -e 'IO.puts \"0x\" <> Integer.to_string(65535,16)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "15\n",
            "4095\n",
            "65535\n",
            "\n",
            "0b1111\n",
            "0o7777\n",
            "0xFFFF\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_y3Y9lKwtpOl"
      },
      "source": [
        "浮動小数点数 floating-point number"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fY5OrrP9ogLF",
        "outputId": "534bdca0-699e-4ca5-e301-e7c89d57ef60"
      },
      "source": [
        "!elixir -e 'IO.puts 1.532e-4'\n",
        "# .0 とか 1. とかはエラーになる\n",
        "!elixir -e 'IO.puts 98099098.0809898888'\n",
        "!elixir -e 'IO.puts 0.00000000000000000000000001' #=> 1.0e-26\n",
        "!elixir -e 'IO.puts 90000000000000000000000000000000000000000000000000000000'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.532e-4\n",
            "98099098.08098988\n",
            "1.0e-26\n",
            "999999999999999999999999999999999999999\n",
            "90000000000000000000000000000000000000000000000000000000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6yA5uGUBPihD"
      },
      "source": [
        "文字列 string\n",
        "\n",
        "string という型はない、みたい。\n",
        "\n",
        "---\n",
        "質問 型を調べる関数はあるか。type() とか。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bjc6aZSso4ma",
        "outputId": "6f8ebaaa-eb74-4530-8c16-2f2b64b501dc"
      },
      "source": [
        "!elixir -e 'IO.puts \"日本語が書けますか\"'\n",
        "!elixir -e 'IO.puts \"日本語が書けます\"'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "日本語が書けますか\n",
            "日本語が書けます\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UhF_wVUSpG0A",
        "outputId": "1dae7128-8974-4c47-fb67-8fb499e448de"
      },
      "source": [
        "# 関数に括弧をつけることができる\n",
        "# \\ で escape できる\n",
        "!elixir -e 'IO.puts (0b1111)'\n",
        "!elixir -e 'IO.puts (\"にほんご\\n日本語\")'\n",
        "!elixir -e \"IO.puts ('にほんご\\n\\\"日本語\\\"')\""
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "15\n",
            "にほんご\n",
            "日本語\n",
            "にほんご\n",
            "\"日本語\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pse7-AAcqCD1",
        "outputId": "0851c255-6fb5-4eb5-ba6c-5ccad4d8b18d"
      },
      "source": [
        "# 文字連結 `+` ではない!!!!\n",
        "!elixir -e 'IO.puts(\"ABCD\"<>\"EFGH\")'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ABCDEFGH\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "`<>` と言う記号はバイナリ連結ということらしい。"
      ],
      "metadata": {
        "id": "Js6Px_xAsOq4"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zeEliw_Esji1"
      },
      "source": [
        "---\n",
        "値の埋め込み\n",
        "\n",
        "`#{変数名}` を記述することで、変数の値を埋め込むことができる。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1mm0BWeds1SQ",
        "outputId": "724e430c-d384-40b2-8435-bbf4bb24e3c3"
      },
      "source": [
        "!elixir -e 'val = 1000; IO.puts \"val = #{val}\"'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "val = 1000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "StBnVUaHtQgL"
      },
      "source": [
        "---\n",
        "真偽値\n",
        "\n",
        "elixir の 真偽値は true と false (小文字) で false と nil が false でそれ以外は true\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D9yH5Dy-tgFj",
        "outputId": "7d3ed7b6-378b-40b9-8945-1ade4c959e32"
      },
      "source": [
        "!elixir -e 'if true do IO.puts \"true\" end'\n",
        "!elixir -e 'if True do IO.puts \"true\" end'\n",
        "!elixir -e 'if False do IO.puts \"true\" end' # False が大文字なので\n",
        "!elixir -e 'if false do IO.puts \"true\" else IO.puts \"false\" end'\n",
        "!elixir -e 'if nil do IO.puts \"true\" else IO.puts \"false\" end'\n",
        "!elixir -e 'if 0 do IO.puts \"true\" else IO.puts \"false\" end'\n",
        "!elixir -e 'if (-1) do IO.puts \"true\" else IO.puts \"false\" end'\n",
        "!elixir -e 'if [] do IO.puts \"true\" else IO.puts \"false\" end'\n",
        "!elixir -e 'if \"\" do IO.puts \"true\" else IO.puts \"false\" end'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "true\n",
            "true\n",
            "true\n",
            "false\n",
            "false\n",
            "true\n",
            "true\n",
            "true\n",
            "true\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "itYbKcCB4ySP"
      },
      "source": [
        "`null` はない。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C9JDfWYm_mDC"
      },
      "source": [
        "---\n",
        "**マッチ演算子 `=`**\n",
        "\n",
        "マッチ演算子 `=` はマッチ演算子である。 マッチ演算子を通して値を代入し、その後、マッチさせることができる。マッチすると、方程式の結果が返され、失敗すると、エラーになる。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DfVC7pluKE0H",
        "outputId": "3fa7c21a-7368-443b-b9ce-2146ccbdf4bc"
      },
      "source": [
        "!elixir -e 'IO.puts a = 1'\n",
        "!elixir -e 'a =1; IO.puts 1 = a'\n",
        "!elixir -e 'a =1; IO.puts 2 = a'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "1\n",
            "** (MatchError) no match of right hand side value: 1\n",
            "    (stdlib 3.17) erl_eval.erl:450: :erl_eval.expr/5\n",
            "    (stdlib 3.17) erl_eval.erl:893: :erl_eval.expr_list/6\n",
            "    (stdlib 3.17) erl_eval.erl:408: :erl_eval.expr/5\n",
            "    (elixir 1.13.0) lib/code.ex:404: Code.validated_eval_string/3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pwxo37byKqR8",
        "outputId": "1c4ade23-749b-4945-fc10-e520d535bd4c"
      },
      "source": [
        "!elixir -e 'IO.inspect a = [1,2,3]' # リストは puts で表示できないので inspect を使う\n",
        "!elixir -e '[a,b,c] = [1,2,3]; IO.puts c; IO.puts b'\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3]\n",
            "3\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y0ASVVRgLcWv"
      },
      "source": [
        "上の例は、elixir は マッチ演算子 `=` があると左右がマッチするように最善を尽くす。 そのため、`[a,b,c] = [1,2,3]` で a,b,c に値が代入される。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0DmXw7wRL56_",
        "outputId": "da139eef-593e-4057-9adf-1a688d6b2b00"
      },
      "source": [
        "!elixir -e 'IO.inspect [1,2,[3,4,5]]'\n",
        "!elixir -e '[a,b,c] = [1,2,[3,4,5]]; IO.inspect c; IO.inspect b'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, [3, 4, 5]]\n",
            "[3, 4, 5]\n",
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CMKwmMRvMUVY",
        "outputId": "202fb09e-ab9c-4a63-d4e3-41c76a3cd15e"
      },
      "source": [
        "# 実験 => エラー\n",
        "!elixir -e 'IO.insepct [a,b] = [1,2,3]'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "** (MatchError) no match of right hand side value: [1, 2, 3]\n",
            "    (stdlib 3.15) erl_eval.erl:450: :erl_eval.expr/5\n",
            "    (stdlib 3.15) erl_eval.erl:893: :erl_eval.expr_list/6\n",
            "    (stdlib 3.15) erl_eval.erl:408: :erl_eval.expr/5\n",
            "    (elixir 1.12.0) lib/code.ex:656: Code.eval_string_with_error_handling/3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PJeH48afMhZF",
        "outputId": "5e1db2ec-a98f-407e-84da-79522fe0db4f"
      },
      "source": [
        "# 実験\n",
        "!elixir -e 'IO.inspect a = [[1,2,3]]'\n",
        "!elixir -e 'IO.inspect [a] = [[1,2,3]]'\n",
        "!elixir -e '[a] = [[1,2,3]]; IO.inspect a'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1, 2, 3]]\n",
            "[[1, 2, 3]]\n",
            "[1, 2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kXTCugTQMzoK",
        "outputId": "d98c75ba-b04b-48b1-b455-5953f6c74e49"
      },
      "source": [
        "# 実験 => エラー\n",
        "!elixir -e 'IO.insepct [a,b] = [a,b]'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[33mwarning: \u001b[0mvariable \"a\" does not exist and is being expanded to \"a()\", please use parentheses to remove the ambiguity or change the variable name\n",
            "  nofile:1\n",
            "\n",
            "** (CompileError) nofile:1: undefined function a/0\n",
            "    (stdlib 3.15) lists.erl:1358: :lists.mapfoldl/3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8clX4wX5M8qW",
        "outputId": "d7099ec0-513d-4a5f-b536-61476a57580a"
      },
      "source": [
        "# 実験 アトムについては後述\n",
        "!elixir -e 'IO.puts a = :a'\n",
        "!elixir -e 'a = :a; IO.inspect a = a'\n",
        "!elixir -e 'a = :a; IO.puts a = a'\n",
        "!elixir -e 'IO.puts :b'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a\n",
            ":a\n",
            "a\n",
            "b\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ux4nZ8goNr1-"
      },
      "source": [
        "アンダースコア `_` で値を無視する。 ワルドカード。\n",
        "\n",
        "なんでも受け付ける。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kv4acj4VN1PL",
        "outputId": "1b9e8d22-db8e-492e-eaf2-399a0402c32e"
      },
      "source": [
        "!elixir -e 'IO.inspect [1,_,_]=[1,2,3]'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XKMEyqD9OHHi",
        "outputId": "b2026df0-8fe8-48e0-ad83-834533a40198"
      },
      "source": [
        "!elixir -e 'IO.inspect [1,_,_]=[1,\"cat\",\"dog\"]'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, \"cat\", \"dog\"]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7J8qxcWUOUbR"
      },
      "source": [
        "変数は、バインド (束縛、紐付け) されると変更できない。\n",
        "\n",
        "かと思ったらできてしまう。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NKezGeRTeIRa",
        "outputId": "38841722-dedd-440a-bf66-9a6a9b83e518"
      },
      "source": [
        "!elixir -e 'a = 1; IO.puts a = 2'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lTmxh0zaeug0"
      },
      "source": [
        "元の変数を指し示すピン演算子 (`^` カレット) がある。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qUZaOkqrerqM",
        "outputId": "730fdcbf-1855-4b32-dc77-91e10c77bdbe"
      },
      "source": [
        "!elixir -e 'a = 1; IO.puts ^a = 2'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "** (MatchError) no match of right hand side value: 2\n",
            "    (stdlib 3.15) erl_eval.erl:450: :erl_eval.expr/5\n",
            "    (stdlib 3.15) erl_eval.erl:893: :erl_eval.expr_list/6\n",
            "    (stdlib 3.15) erl_eval.erl:408: :erl_eval.expr/5\n",
            "    (elixir 1.12.0) lib/code.ex:656: Code.eval_string_with_error_handling/3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dsKGlpUjfOgd"
      },
      "source": [
        "メモ $\\quad$ 普通の関数型言語のように変数は変更できないルールにしてしまった方が簡単ではなかったか、と思わないでもない。 変数を不変にする、const 宣言みたいなのはないのか。\n",
        "\n",
        "リストは不変 immutable なので安心。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sRqOyI0XwcJl",
        "outputId": "5c1a68f5-76bc-4738-e77f-f8769db497e7"
      },
      "source": [
        "# 大文字にする capitalize\n",
        "!elixir -e 'IO.puts name = String.capitalize \"elixir\"'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Elixir\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FoIH56zvxcuB",
        "outputId": "af173fcb-a285-4f86-d8ec-b7999b767364"
      },
      "source": [
        "# 大文字にする upcase\n",
        "!elixir -e 'IO.puts String.upcase \"elixir\"'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "ELIXIR\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ymMoHgZ648UL"
      },
      "source": [
        "# アトム\n",
        "\n",
        "アトムは名前がそのまま値となる定数である。\n",
        "\n",
        "**名前の前にコロン `:` をつけることでアトムになる。**\n",
        "\n",
        "アトムの名前は utf-8 文字列 (記号を含む)、数字、アンダースコア `_` 、`@` で、終端文字としてのみ「!」や「?」が使える。\n",
        "\n",
        ":fred $\\quad$ :is_binary? $\\quad$ ​:var@2 $\\quad$ ​:<> $\\quad$ ​:=== \n",
        "\n",
        "​:\"func/3\"​ $\\quad$ ​​:\"long john silver\" $\\quad$ ​:эликсир\n",
        "\n",
        "​:mötley_crüe\n",
        "\n",
        "メモ"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 実験 アトムは宣言しないで突然使える\n",
        "!elixir -e 'IO.puts :fred'"
      ],
      "metadata": {
        "id": "_VXZlUyTmEOC",
        "outputId": "4b9582df-e2e5-4e13-84da-b8151a0d3b73",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "fred\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I4OyDEuL5NXn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f3a57992-8d33-4e0d-9e72-5a4b9f4670b7"
      },
      "source": [
        "# 実験\n",
        "!elixir -e 'IO.puts true === :true'\n",
        "!elixir -e 'IO.puts :true'\n",
        "!elixir -e 'IO.puts false === :false'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "true\n",
            "true\n",
            "true\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_JgCByovuZDa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2e26bf3d-7bd9-45bb-f41e-0de535e3010f"
      },
      "source": [
        "# 実験 \n",
        "!elixir -e 'IO.puts :fred'\n",
        "!elixir -e 'IO.puts :is_binary?'\n",
        "!elixir -e 'IO.puts :var@2'\n",
        "!elixir -e 'IO.puts :<>'\n",
        "!elixir -e 'IO.puts :==='\n",
        "# セミコロンを含むアトムは iex 上では使えるが、シェルワンライナーでは使えない  \n",
        "# unexpected token: \"​\" と言うエラーになる\n",
        "# colab の環境だけでなく、通常のシェルでも同じ\n",
        "# ファイルにしたプログラムでは使えるので問題ない\n",
        "# !elixir -e 'IO.puts :\"func/3\"​' \n",
        "# !elixir -e 'IO.puts ​​:\"long john silver\"'\n",
        "!elixir -e 'IO.puts :эликсир'\n",
        "!elixir -e 'IO.puts :mötley_crüe'\n",
        "!elixir -e 'IO.puts :日本語はどうか'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "fred\n",
            "is_binary?\n",
            "var@2\n",
            "<>\n",
            "===\n",
            "эликсир\n",
            "mötley_crüe\n",
            "日本語はどうか\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "11Dfjo4Y6LQU"
      },
      "source": [
        "演算子"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ISACU_0p6Nv2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0c26f3bf-ef83-4d36-9386-2f96f3fde532"
      },
      "source": [
        "!elixir -e 'IO.puts 1 + 2'\n",
        "!elixir -e 'x = 10; IO.puts x + 1'\n",
        "!elixir -e 'IO.puts 1 - 2'\n",
        "!elixir -e 'x = 10; IO.puts x - 1'\n",
        "!elixir -e 'IO.puts 5 * 2'\n",
        "!elixir -e 'x = 10; IO.puts x * 4'\n",
        "!echo \n",
        "!elixir -e 'IO.puts 5 / 2'\n",
        "!elixir -e 'x = 10; IO.puts x / 3'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n",
            "11\n",
            "-1\n",
            "9\n",
            "10\n",
            "40\n",
            "\n",
            "2.5\n",
            "3.3333333333333335\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hcGSSQlu7JEQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e814f7b0-75c1-46b4-ad78-941809817307"
      },
      "source": [
        "# 浮動少数ではなく整数としての結果がほしい場合は div 関数を使用\n",
        "!elixir -e 'IO.puts div(10,5)'\n",
        "!elixir -e 'IO.puts div(10,4)'\n",
        "# 割り算の余り、剰余を求める場合は rem関数を使用\n",
        "!elixir -e 'IO.puts rem(10,4)'\n",
        "!elixir -e 'IO.puts rem(10,3)'\n",
        "!elixir -e 'IO.puts rem(10,2)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "2\n",
            "2\n",
            "1\n",
            "0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MD79UYp8WYW5",
        "outputId": "4c1279d8-57d6-42f9-87e4-72a93a972a0b"
      },
      "source": [
        "# 比較演算子\n",
        "!elixir -e 'IO.puts 1 == 1'\n",
        "!elixir -e 'IO.puts 1 != 1'\n",
        "!elixir -e 'IO.puts ! (1 != 1)'\n",
        "!echo\n",
        "!elixir -e 'IO.puts 20.0 == 20'\n",
        "!elixir -e 'IO.puts 20.0 === 20'\n",
        "!elixir -e 'IO.puts 20.0 !== 20'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "true\n",
            "false\n",
            "true\n",
            "\n",
            "true\n",
            "false\n",
            "true\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HpG6ZfOPXSHE",
        "outputId": "57dfd1bb-c8c2-4b77-c815-ab4f0077b8a1"
      },
      "source": [
        "# 論理演算子\n",
        "# 論理和\n",
        "!elixir -e 'IO.puts \"ABC\" == \"ABC\" || 20 == 30'\n",
        "!elixir -e 'IO.puts \"ABC\" == \"abc\" || 20 == 30'\n",
        "!echo\n",
        "# 論理積\n",
        "!elixir -e 'IO.puts \"ABC\" == \"ABC\" && 20 == 20'\n",
        "!elixir -e 'IO.puts \"ABC\" == \"ABC\" && 20 == 30'\n",
        "!elixir -e 'IO.puts \"ABC\" == \"def\" && 10 > 100'\n",
        "!echo\n",
        "# 否定\n",
        "!elixir -e 'IO.puts !(\"ABC\" == \"ABC\")'\n",
        "!elixir -e 'IO.puts !(\"ABC\" == \"DEF\")'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "true\n",
            "false\n",
            "\n",
            "true\n",
            "false\n",
            "false\n",
            "\n",
            "false\n",
            "true\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JC8x22M7ID-Y"
      },
      "source": [
        "range\n",
        "\n",
        "メモ $\\quad$ range は型ではなく、struct である。 構造体?\n",
        "\n",
        "`start..end` で表現される、とあるが、1..10 と書けばそれで range なのか?\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gTcnmspAIk68",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7ebe413a-40dc-4e36-b4c2-616c4ab50bd1"
      },
      "source": [
        "!elixir -e 'IO.inspect Enum.to_list(1..3)'\n",
        "!elixir -e 'IO.inspect Enum.to_list(0..10//3)'\n",
        "!elixir -e 'IO.inspect Enum.to_list(0..10//-3)'\n",
        "!elixir -e 'IO.inspect Enum.to_list(10..0//-3)'\n",
        "!elixir -e 'IO.inspect Enum.to_list(1..1)'\n",
        "!elixir -e 'IO.inspect Enum.to_list(1..-1)'\n",
        "!elixir -e 'IO.inspect Enum.to_list(1..1//2)'\n",
        "!elixir -e 'IO.inspect Enum.to_list(1..-1//2)'\n",
        "!elixir -e 'IO.inspect Enum.to_list(1..-1//-2)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3]\n",
            "[0, 3, 6, 9]\n",
            "[]\n",
            "[10, 7, 4, 1]\n",
            "[1]\n",
            "[1, 0, -1]\n",
            "[1]\n",
            "[]\n",
            "[1, -1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wu-Njp0qJxY0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7ec94c99-0907-4828-a5d0-642e6c361d7a"
      },
      "source": [
        "!elixir -e 'IO.inspect 1..9//2'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1..9//2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TT31OFdF1Skv"
      },
      "source": [
        "正規表現 regular expression\n",
        "\n",
        "正規表現も型ではなく、struct である。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nVehQSED1ZgE",
        "outputId": "e46537ae-26e4-45ad-efa6-53e3e2963853"
      },
      "source": [
        "!elixir -e 'IO.inspect Regex.run ~r{[aiueo]},\"catapillar\"'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[\"a\"]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DjFF5Ocf2hDw",
        "outputId": "f3107c4b-08a4-4afb-9355-aedbf36702b2"
      },
      "source": [
        "!elixir -e 'IO.inspect Regex.scan ~r{[aiueo]},\"catapillar\"'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[\"a\"], [\"a\"], [\"i\"], [\"a\"]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B-9puevy2kFI",
        "outputId": "be12bf18-b9f6-42c4-ba08-db08b13c049c"
      },
      "source": [
        "!elixir -e 'IO.inspect Regex.split ~r{[aiueo]},\"catapillar\"'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[\"c\", \"t\", \"p\", \"ll\", \"r\"]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xbWEbhrJ2n_b",
        "outputId": "4b5c6945-c10c-4b17-8315-f6901d3c9da7"
      },
      "source": [
        "!elixir -e 'IO.inspect Regex.replace ~r{[aiueo]},\"catapillar\", \"*\"'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\"c*t*p*ll*r\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0nHvR2D_3HUu"
      },
      "source": [
        "# コレクション型"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nYc9e2XhX4VL"
      },
      "source": [
        "## タプル\n",
        "\n",
        "タプルは波括弧 brace を用いて定義する。\n",
        "\n",
        "タプルに限らず elixir のコレクションはすべて要素のタイプを限定しない。\n",
        "\n",
        "通常 2 から 4 の要素であり、それ以上の要素数の場合、map や struct の利用を考える。\n",
        "\n",
        "タプルは関数の返り値に便利に利用される。\n",
        "\n",
        "パターンマッチングと組み合わせて使われる。\n",
        "\n",
        "---\n",
        "cf. タプル以外の波括弧 brace の使用\n",
        "* 値の代入`#{変数名}` \n",
        "* 正規表現 Regex `r{}` \n",
        "* マップ `%{}` "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S2QAVIgAYdN1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b6815386-a1a2-41b3-9d19-187ed3a905e4"
      },
      "source": [
        "!elixir -e 'IO.inspect {3.14, :pie, \"Apple\"}'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{3.14, :pie, \"Apple\"}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Pf1feznT4dft",
        "outputId": "9d832b46-44ac-4bb2-b27b-f736acb66b97"
      },
      "source": [
        "!elixir -e '{status, count, action} = {3.14, :pie, \"next\"}; IO.puts action'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "next\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-owoQYO150ic"
      },
      "source": [
        "# 実験\n",
        "# タプルの使い方の例 \n",
        "!echo hello > temp.txt\n",
        "!elixir -e '{status, file} = File.open(\"temp.txt\"); IO.inspect {status, file}'\n",
        "!elixir -e '{status, file} = File.read(\"temp.txt\"); IO.inspect {status, file}'\n",
        "!elixir -e '{status, file} = File.read(\"temp02.txt\"); IO.inspect {status, file}'\n",
        "!elixir -e '{status, file} = File.write(\"temp.txt\", \"goodbye\"); IO.inspect {status, file}'\n",
        "!elixir -e '{status, file} = File.read(\"temp.txt\"); IO.inspect {status, file}'\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XwMhvoxEVJlA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8e44f1ea-60bd-4647-c6c4-0718d32f7ae6"
      },
      "source": [
        "# 実験 タプルに ++ は使えるか。 => 使えない <> も使えない\n",
        "# !elixir -e 'IO.inspect {3.14, :pie, \"Apple\"} ++ {3}'\n",
        "# 実験 タプルに head は使えるか。 => 使えない\n",
        "# !elixir -e 'IO.inspect hd {3.14, :pie, \"Apple\"}'\n",
        "# 実験 タプルにパターンマッチングは使えるか。 => 使える\n",
        "!elixir -e '{a,b,c} =  {3.14, :pie, \"Apple\"}; IO.inspect [c,a,b]'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[\"Apple\", 3.14, :pie]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yA9cADK87DCa",
        "outputId": "462e95c4-542e-45d0-aae4-915087a9791f"
      },
      "source": [
        "# 実験\n",
        "# 項目の入れ替え\n",
        "!elixir -e 'a=1; b=3; {b,a}={a,b}; IO.inspect {a,b}'\n",
        "!elixir -e 'a=1; b=3; c=5; d= 7; {d,c,b,a}={a,b,c,d}; IO.inspect {a,b,c,d}'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{3, 1}\n",
            "{7, 5, 3, 1}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 実験\n",
        "# タプルの要素にタプルはあるか\n",
        "!elixir -e 'IO.inspect {3.14, :pie, \"Apple\", {3}}'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "za1VGkVyqVLQ",
        "outputId": "108f931f-b479-40b3-c96b-9509f161e48a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{3.14, :pie, \"Apple\", {3}}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oG0fOdZZaT4E"
      },
      "source": [
        "## リスト\n",
        "\n",
        "他の言語の配列 array と elixir のリストは違うので注意。 lisp のリストと似たような概念である。\n",
        "\n",
        "カラのリストでなければ、head (hd) と tail (tl) がある。hd は頭の1つで tl はそれ以降全部。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-UTLByQLaeP-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a66efc5a-f35e-4059-d5a6-1fa5b97ec9b8"
      },
      "source": [
        "# リスト\n",
        "!elixir -e 'IO.inspect [3.14, :pie, \"Apple\"]'\n",
        "!elixir -e 'IO.inspect hd [3.14]'\n",
        "!elixir -e 'IO.inspect tl [3.14]'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3.14, :pie, \"Apple\"]\n",
            "3.14\n",
            "[]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2adTcaWdpJLx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f8447c8-0702-4b25-da66-8ee5cf4c8fc5"
      },
      "source": [
        "# リスト先頭への追加(高速)\n",
        "!elixir -e 'IO.inspect [\"π\" | [3.14, :pie, \"Apple\"]]'\n",
        "# リスト末尾への追加(低速)\n",
        "!elixir -e 'IO.inspect [3.14, :pie, \"Apple\"] ++ [\"Cherry\"]'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[\"π\", 3.14, :pie, \"Apple\"]\n",
            "[3.14, :pie, \"Apple\", \"Cherry\"]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_fTO4PU_Ar3o"
      },
      "source": [
        "上と下のコードセルでリストの連結を行っているが、++/2 演算子を用いている。 この `++/2` という表記は `++` が演算子自体で `/2` がアリティ (引数の数) を表す。 \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TAt7A6S6UgYf"
      },
      "source": [
        "---\n",
        "質問 $\\quad$ アリティとはなにか。\n",
        "\n",
        "---\n",
        "質問 $\\quad$ リストの連結に `++` で文字列の連結 `<>` なのはなぜか。 オーバーライディングはあるのか。 文字列 string はリストではないのか。 長さを測る関数も別々なのか。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O8nIlA3jBEIf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cc8f47cb-2f05-47b5-abff-0e5b06eb126f"
      },
      "source": [
        "# リストの連結\n",
        "!elixir -e 'IO.inspect  [1, 2] ++ [3, 4, 1]'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 4, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F6fHksfUVGu0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2b7d4d6b-d6b1-4b44-aab3-0afb2da42f0f"
      },
      "source": [
        "# リストの減算 \n",
        "#  --/2 演算子は存在しない値を引いてしまってもオッケー\n",
        "!elixir -e 'IO.inspect [\"foo\", :bar, 42] -- [42, \"bar\"]'\n",
        "# 重複した値の場合、右辺の要素のそれぞれに対し、左辺の要素のうち初めて登場した同じ値が順次削除\n",
        "!elixir -e 'IO.inspect [1,2,2,3,2,3] -- [1,2,3,2]'\n",
        "# リストの減算の値のマッチには strict comparison が使われている\n",
        "!elixir -e 'IO.inspect  [2] -- [2.0]'\n",
        "!elixir -e 'IO.inspect  [2.0] -- [2.0]'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[\"foo\", :bar]\n",
            "[2, 3]\n",
            "[2]\n",
            "[]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H6BBZhUrWfq6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e0828a87-78e0-480d-a5f7-9676de9443da"
      },
      "source": [
        "# head /tail\n",
        "!elixir -e 'IO.inspect hd [3.14, :pie, \"Apple\"]'\n",
        "!elixir -e 'IO.inspect tl [3.14, :pie, \"Apple\"]'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.14\n",
            "[:pie, \"Apple\"]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T-JhzbsCXITz"
      },
      "source": [
        "---\n",
        "リストを頭部と尾部に分けるのに\n",
        "\n",
        "* パターンマッチング\n",
        "* cons 演算子( `|` )\n",
        "\n",
        "を使うこともできる。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A29_XouHXitI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "de3cea92-cfdb-4096-b031-3f64c79084be"
      },
      "source": [
        "!elixir -e '[head | tail] = [3.14, :pie, \"Apple\"]; IO.inspect head; IO.inspect tail'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.14\n",
            "[:pie, \"Apple\"]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EOXvBvVzY4Ox"
      },
      "source": [
        "## キーワードリスト\n",
        "\n",
        "キーワードリストとマップは elixir の連想配列である。\n",
        "\n",
        "キーワードリストは最初の要素がアトムのタプルからなる特別なリストで、リストと同様の性能になる。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n9K3nXH0Z1pY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aeb7ff7d-5a8d-4674-c6a0-cfc5a956a7f4"
      },
      "source": [
        "# キーワードリスト\n",
        "!elixir -e 'IO.inspect [foo: \"bar\", hello: \"world\"]'\n",
        "# タプルのリストとしても同じ\n",
        "!elixir -e 'IO.inspect [{:foo, \"bar\"}, {:hello, \"world\"}]'\n",
        "!elixir -e 'IO.inspect [foo: \"bar\", hello: \"world\"] == [{:foo, \"bar\"}, {:hello, \"world\"}]'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[foo: \"bar\", hello: \"world\"]\n",
            "[foo: \"bar\", hello: \"world\"]\n",
            "true\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nCLr_RSYkJgp"
      },
      "source": [
        "キーワードリストの 3 つの特徴\n",
        "\n",
        "* キーはアトムである。\n",
        "* キーは順序付けされている。\n",
        "* キーの一意性は保証されない。\n",
        "\n",
        "こうした理由から、キーワードリストは関数にオプションを渡すためによく用いられる。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vEUTICVkBOZu",
        "outputId": "c4a43a26-1467-458b-ffd3-2cd761aac8d7"
      },
      "source": [
        "# 実験 リストの角括弧は省略できる\n",
        "!elixir -e 'IO.inspect foo: \"bar\", hello: \"world\"'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[foo: \"bar\", hello: \"world\"]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5MmigNGEK5Pm",
        "outputId": "95c997e0-1839-40e4-fe0b-07943e7b40cb"
      },
      "source": [
        "# 実験\n",
        "!elixir -e 'IO.inspect [1, fred: 1, dave: 2]'\n",
        "!elixir -e 'IO.inspect {1, fred: 1, dave: 2}'\n",
        "!elixir -e 'IO.inspect {1, [{:fred,1},{:dave, 2}]}'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, {:fred, 1}, {:dave, 2}]\n",
            "{1, [fred: 1, dave: 2]}\n",
            "{1, [fred: 1, dave: 2]}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FTteo69skgsD"
      },
      "source": [
        "## マップ\n",
        "\n",
        "* キーワードリストとは違ってどんな型のキーも使える。\n",
        "* 順序付けされない。\n",
        "* キーの一意性が保証されている。重複したキーが追加された場合は、前の値が置き換えられる。\n",
        "* 変数をマップのキーにできる。\n",
        "* `%{}` 構文で定義する。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GpcBT5UxlNqX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ea14ae19-5e87-4fd9-8eb3-9a66d1b3570b"
      },
      "source": [
        "!elixir -e 'IO.inspect %{:foo => \"bar\", \"hello\" => :world}'\n",
        "!elixir -e 'map = %{:foo => \"bar\", \"hello\" => :world}; IO.inspect map[:foo]'\n",
        "!elixir -e 'map = %{:foo => \"bar\", \"hello\" => :world}; IO.inspect map[\"hello\"]'\n",
        "!echo\n",
        "!elixir -e 'key = \"hello\"; IO.inspect %{key => \"world\"}'\n",
        "!echo\n",
        "!elixir -e 'IO.inspect %{:foo => \"bar\", :foo => \"hello world\"}'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "%{:foo => \"bar\", \"hello\" => :world}\n",
            "\"bar\"\n",
            ":world\n",
            "\n",
            "%{\"hello\" => \"world\"}\n",
            "\n",
            "\u001b[33mwarning: \u001b[0mkey :foo will be overridden in map\n",
            "  nofile:1\n",
            "\n",
            "%{foo: \"hello world\"}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dkcO672-FkQc"
      },
      "source": [
        "アトムのキーだけを含んだマップには特別な構文がある。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nvuza7GRmeZa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1ba6dc41-7686-4518-f243-9faa131c792b"
      },
      "source": [
        "!elixir -e 'IO.inspect %{foo: \"bar\", hello: \"world\"} == %{:foo => \"bar\", :hello => \"world\"}'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "true\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3qIWDH31ZxtW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d00808fc-9981-4cb7-ff67-eb9d77257ff0"
      },
      "source": [
        "# 加えて、アトムのキーにアクセスするための特別な構文がある。\n",
        "!elixir -e 'map = %{foo: \"bar\", hello: \"world\"}; IO.inspect map.hello'\n",
        "!elixir -e 'map = %{foo: \"bar\", hello: \"world\"}; IO.inspect map[:hello]'\n",
        "!elixir -e 'map = %{:foo => \"bar\", :hello =>  \"world\"}; IO.inspect map[:hello]'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\"world\"\n",
            "\"world\"\n",
            "\"world\"\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "質問 map の特別な構文\n",
        "\n",
        "1. `=>` の代わりにコロン `:` を使う\n",
        "2. 要素を取り出すのに `[]` の代わりにピリオド `.` を使う\n",
        "\n",
        "は不要ではないか。不要だが見かけが良くなる、ということか。普通はどっちを使うのか。無駄に構文を複雑にするだけのような気がする。\n",
        "\n",
        "多分まず Python の dict でコロン `:` を使うこと、Ruby は `=>` を使うが糖衣構文としてコロン `:` が使えてその形が主流であることから、見かけ大切ということでこうなったのではないか。キーにアトムを使うことが前提ならば生産性が上がるかもしれない。キーであることを示すコロンが不要になる。fat arrow よりコロンの方が短い。map の定義が同時に行われる。要素の取り出しピリオドを使う点についても同様。ということは基本的にこの構文になる、と言う事だろう。"
      ],
      "metadata": {
        "id": "c_vdluG2lvZF"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q9GkwzvFaPHo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "980a6289-2e87-4d45-bad8-c43271fafcb4"
      },
      "source": [
        "# マップの更新のための構文がある (新しい map が作成される)\n",
        "# この構文は、マップに既に存在するキーを更新する場合にのみ機能する\n",
        "!elixir -e 'map = %{foo: \"bar\", hello: \"world\"}; IO.inspect %{map | foo: \"baz\"}'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "%{foo: \"baz\", hello: \"world\"}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cP3Im0X7qw1v",
        "outputId": "84d640c8-7a16-4262-8578-7f40a9b3aa20"
      },
      "source": [
        "# 新しいキーを作成するには、`Map.put/3` を使用\n",
        "!elixir -e 'map = %{hello: \"world\"}; IO.inspect  Map.put(map, :foo, \"baz\")'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "%{foo: \"baz\", hello: \"world\"}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "質問 binary については良くわからないので別途。"
      ],
      "metadata": {
        "id": "lRz91G1qv-9j"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eu5Wd8V0Smb7"
      },
      "source": [
        "# バイナリ binary"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RTxXe7kkQVdb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "38edaf5a-ff3e-466b-e951-e50810ea06cc"
      },
      "source": [
        "# binaries \n",
        "!elixir -e 'IO.inspect <<1,2>>'\n",
        "!elixir -e 'IO.inspect <<1,10>>'\n",
        "!elixir -e 'bin = <<1,10>>; IO.inspect byte_size bin'\n",
        "!elixir -e 'bin = <<3::size(2),5::size(4),1::size(2)>>; IO.inspect bin'\n",
        "!elixir -e 'IO.puts Integer.to_string(213,2)'\n",
        "!elixir -e 'IO.puts 0b11'\n",
        "!elixir -e 'IO.puts 0b0101'\n",
        "!echo\n",
        "!elixir -e 'bin = <<3::size(2),5::size(4),1::size(2)>>; IO.inspect byte_size bin'\n",
        "!elixir -e 'bin = <<3::size(2),5::size(4),1::size(2)>>; IO.inspect :io.format(\"~-8.2b~n\",:binary.bin_to_list(bin))'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<<1, 2>>\n",
            "<<1, 10>>\n",
            "2\n",
            "<<213>>\n",
            "11010101\n",
            "3\n",
            "5\n",
            "\n",
            "1\n",
            "11010101\n",
            ":ok\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir -e 'IO.inspect <<1,2>> <> <<3>>'"
      ],
      "metadata": {
        "id": "Fl7EmQ22kELy",
        "outputId": "59682999-716d-4593-affc-d0a9a5e8463b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<<1, 2, 3>>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bwvkel2v_0ee"
      },
      "source": [
        "----\n",
        "** Date and Time 日付 **"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "31Hs1nDsABon",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a28c945c-43ed-4c7b-f7c8-2ffd34b69272"
      },
      "source": [
        "# Date and Time\n",
        "!elixir -e 'IO.inspect Date.new(2021,6,2)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{:ok, ~D[2021-06-02]}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BpD56DGELYWy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8f86b634-68ae-4026-86d5-c7b569a36500"
      },
      "source": [
        "!elixir -e '{:ok, d1}=Date.new(2021,6,2); IO.inspect d1'\n",
        "!elixir -e '{:ok, d1}=Date.new(2021,6,2); IO.inspect Date.day_of_week(d1)'\n",
        "!elixir -e '{:ok, d1}=Date.new(2021,6,2); IO.inspect Date.add(d1,7)'\n",
        "!elixir -e '{:ok, d1}=Date.new(2021,6,2); IO.inspect d1, structs: false'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "~D[2021-06-02]\n",
            "3\n",
            "~D[2021-06-09]\n",
            "%{__struct__: Date, calendar: Calendar.ISO, day: 2, month: 6, year: 2021}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Dz-2jFfWj8O"
      },
      "source": [
        "`~D[...]` や `~T[...]` は elixir の シギル sigil である。 文字列とバイナリーのところで説明する。"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g-s-BTlMuwSl"
      },
      "source": [
        "# help について\n",
        "メモ $\\quad$ 関数の調べ方\n",
        "\n",
        "Helper の使い方。 help, type, info, information とか。\n",
        "\n",
        "下のコードセルにあるように、対象のモジュールの関数名を調べ、そのヘルプを見ればけっこうくわしくわかる。\n",
        "\n",
        "コメントアウトしてあるのは出力が大きいので、とりあえずコメントアウトして出力を抑制してある。\n",
        "\n",
        "具体的には、Enum にあたるところにモジュール名を入れて関数のリストを出す。 Ctrl+A Ctrl+C でコピーして vscode などでペーストして読む。 調べたい関数名をヘルプの、Enum.all?/1 のところに入れて出力をコピーして、vscode などでペーストして読む\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RMwZZxhdSuJl"
      },
      "source": [
        "# !elixir -e 'Enum.__info__(:functions) |> Enum.each(fn({function, arity}) -> IO.puts \"#{function}/#{arity}\" end)'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "crcthqHyvaSN"
      },
      "source": [
        "# !elixir -e 'require IEx.Helpers;IEx.Helpers.h Enum.all?/1'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ChuZDdiEigcH"
      },
      "source": [
        "# h 単独のドキュメントを見たい\n",
        "# !elixir -e 'require IEx.Helpers;IEx.Helpers.h'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HbbVD-lVi-Du"
      },
      "source": [
        "# i というのもある\n",
        "# !elixir -e 'x = [3,2]; require IEx.Helpers;IEx.Helpers.i x'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C4tVLXfYpbh_"
      },
      "source": [
        "# !elixir -e 'require IEx.Helpers;IEx.Helpers.h IO'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v2CvxtY_rag8"
      },
      "source": [
        "# Enum モジュール\n",
        "\n",
        "Enum はリストなどコレクションを列挙するための一連のアルゴリズム。\n",
        "\n",
        "* all?、any?\n",
        "* chunk_every、chunk_by、map_every\n",
        "* each\n",
        "* map、filter、reduce\n",
        "* min、max\n",
        "* sort、uniq、uniq_by\n",
        "* キャプチャ演算子 `(&)`\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fRHdnhaDDdzn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cf54b2a5-14c5-4146-d2f4-d4110efd1f9c"
      },
      "source": [
        "# all? 関数を引数で受け取り、リストの全体が true の時、true を返す\n",
        "!elixir -e 'IO.puts Enum.all?([\"foo\", \"bar\", \"hello\"], fn(s) -> String.length(s) == 3 end)'\n",
        "!elixir -e 'IO.puts Enum.all?([\"foo\", \"bar\", \"hello\"], fn(s) -> String.length(s) >1 end)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "false\n",
            "true\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fr1YhaY2ECAE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c5b5983f-2b5d-4098-c53e-90fb7c6a706a"
      },
      "source": [
        "# any? 少なくとも1つの要素が true と評価された場合に true を返す\n",
        "!elixir -e 'IO.puts Enum.any?([\"foo\", \"bar\", \"hello\"], fn(s) -> String.length(s) == 5 end)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "true\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ltdysP5SFOM1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1a00597a-33cd-466e-98a3-a48126c88f28"
      },
      "source": [
        "# chunk_every リストを小さなグループに分割する\n",
        "!elixir -e 'IO.inspect Enum.chunk([1, 2, 3, 4, 5, 6], 2)'\n",
        "!elixir -e 'IO.inspect Enum.chunk([1, 2, 3, 4, 5, 6], 3)'\n",
        "!elixir -e 'IO.inspect Enum.chunk([1, 2, 3, 4, 5, 6], 4)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1, 2], [3, 4], [5, 6]]\n",
            "[[1, 2, 3], [4, 5, 6]]\n",
            "[[1, 2, 3, 4]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "myy_9FgVGpeA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d8b0da14-c9f5-4c75-ff44-7636799ed2d6"
      },
      "source": [
        "# chunk_by 関数の戻り値が変化することによって分割する\n",
        "!elixir -e 'IO.inspect Enum.chunk_by([\"one\", \"two\", \"three\", \"four\", \"five\"], fn(x) -> String.length(x) end)'\n",
        "!elixir -e 'IO.inspect Enum.chunk_by([\"one\", \"two\", \"three\", \"four\", \"five\", \"six\"], fn(x) -> String.length(x) end)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[\"one\", \"two\"], [\"three\"], [\"four\", \"five\"]]\n",
            "[[\"one\", \"two\"], [\"three\"], [\"four\", \"five\"], [\"six\"]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gbEbNAbmUFHE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0e28d3a6-b558-40c3-dc9a-62797161efe3"
      },
      "source": [
        "# map_every nth ごとに map 処理する\n",
        "!elixir -e 'IO.inspect Enum.map_every(1..10, 3, fn x -> x + 1000 end)'\n",
        "!elixir -e 'IO.inspect Enum.map_every(1..10, 1, fn x -> x + 1000 end)'\n",
        "!elixir -e 'IO.inspect Enum.map_every(1..10, 0, fn x -> x + 1000 end)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1001, 2, 3, 1004, 5, 6, 1007, 8, 9, 1010]\n",
            "[1001, 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010]\n",
            "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yn6ucqU9gVW1",
        "outputId": "601d14bf-5043-4889-ce54-6d1a02da2a2c"
      },
      "source": [
        "# each 新しい値を生成することなく反復する。返り値は:ok というアトム。\n",
        "!elixir -e 'IO.inspect Enum.each([\"one\", \"two\", \"three\"], fn(s) -> IO.puts(s) end)'\n",
        "!elixir -e 'IO.puts Enum.each([\"one\", \"two\", \"three\"], fn(s) -> IO.puts(s) end)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "one\n",
            "two\n",
            "three\n",
            ":ok\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wzRwKv_imULW",
        "outputId": "b5a2fd71-b970-459d-b7d8-ebe22c7fa501"
      },
      "source": [
        "# map 関数を各要素に適用して新しいリストを生み出す\n",
        "!elixir -e 'IO.inspect Enum.map([0, 1, 2, 3], fn(x) -> x - 1 end)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[-1, 0, 1, 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "85q0m8_ZmyyQ",
        "outputId": "bdf70f32-c114-462b-f396-951f1549b4fb"
      },
      "source": [
        "# min 最小の値を探す。 リストが空の場合エラーになる\n",
        "# リストが空だったときのために予め最小値を生成する関数を渡すことができる\n",
        "!elixir -e 'IO.inspect Enum.min([5, 3, 0, -1])'\n",
        "!elixir -e 'IO.inspect Enum.min([], fn -> :foo end)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-1\n",
            ":foo\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F2Wx1evnnUWB",
        "outputId": "dd19d081-838f-4077-a7dc-00ef14eec9f3"
      },
      "source": [
        "# max 最大の(max/1)値を返す\n",
        "!elixir -e 'IO.inspect Enum.max([5, 3, 0, -1])'\n",
        "!elixir -e 'IO.inspect Enum.max([], fn -> :bar end)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n",
            ":bar\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LMRdRxOso7pU",
        "outputId": "daac690a-544a-48bc-927b-288fc3804ccb"
      },
      "source": [
        "# filter 与えられた関数によって true と評価された要素だけを得る\n",
        "!elixir -e 'IO.inspect Enum.filter([1, 2, 3, 4], fn(x) -> rem(x, 2) == 0 end)'\n",
        "!elixir -e 'IO.inspect Enum.filter([], fn(x) -> rem(x, 2) == 0 end)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2, 4]\n",
            "[]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XKKtE4wOpvBi",
        "outputId": "4f6abd08-4b82-4ab8-b76b-2fa596d96cc7"
      },
      "source": [
        "# reduce リストを関数に従って単一の値へ抽出する。 accumulator を指定できる。\n",
        "# accumulator が与えられない場合は最初の要素が用いられる。\n",
        "!elixir -e 'IO.inspect Enum.reduce([1, 2, 3], 10, fn(x, acc) -> x + acc end)'\n",
        "!elixir -e 'IO.inspect Enum.reduce([1, 2, 3], fn(x, acc) -> x + acc end)'\n",
        "!elixir -e 'IO.inspect Enum.reduce([\"a\",\"b\",\"c\"], \"1\", fn(x,acc)-> x <> acc end)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "16\n",
            "6\n",
            "\"cba1\"\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KcZHo75X0t94",
        "outputId": "64c51728-1c25-4b30-ca3f-ad62d9915c18"
      },
      "source": [
        "# sort `sort/1` はソートの順序に Erlangの Term 優先順位 を使う\n",
        "!elixir -e 'IO.inspect Enum.sort([5, 6, 1, 3, -1, 4])'\n",
        "!elixir -e 'IO.inspect Enum.sort([:foo, \"bar\", Enum, -1, 4])'\n",
        "\n",
        "# `sort/2` は、順序を決める為の関数を渡すことができる\n",
        "!elixir -e 'IO.inspect Enum.sort([%{:val => 4}, %{:val => 1}], fn(x, y) -> x[:val] > y[:val] end)'\n",
        "\n",
        "# なしの場合\n",
        "!elixir -e 'IO.inspect Enum.sort([%{:count => 4}, %{:count => 1}])'\n",
        "\n",
        "# sort/2 に :asc または :desc をソート関数として渡すことができる\n",
        "!elixir -e 'IO.inspect Enum.sort([2, 3, 1], :desc)'\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[-1, 1, 3, 4, 5, 6]\n",
            "[-1, 4, Enum, :foo, \"bar\"]\n",
            "[%{val: 4}, %{val: 1}]\n",
            "[%{count: 1}, %{count: 4}]\n",
            "[3, 2, 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ajs77q8e14f4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "de33dc6f-b9ac-4d60-be9c-ae4bf93977ed"
      },
      "source": [
        "# uniq 重複した要素を取り除く\n",
        "!elixir -e 'IO.inspect Enum.uniq([1, 2, 3, 2, 1, 1, 1, 1, 1])'\n",
        "[1, 2, 3]\n",
        "\n",
        "# uniq_by 重複した要素を削除するが、ユニークかどうか比較を行う関数を渡せる\n",
        "!elixir -e 'IO.inspect Enum.uniq_by([%{x: 1, y: 1}, %{x: 2, y: 1}, %{x: 3, y: 3}], fn coord -> coord.y end)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3]\n",
            "[%{x: 1, y: 1}, %{x: 3, y: 3}]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e5qxCiaH6Bps"
      },
      "source": [
        "# キャプチャ演算子 `&` を使用した Enum と無名関数 \n",
        "\n",
        "elixir の Enum モジュール内の多くの関数は、引数として無名関数を取る。\n",
        "\n",
        "これらの無名関数は、多くの場合、キャプチャ演算子 `&` を使用して省略形で記述される。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1c-WGlISZ1fo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "61088b3d-f774-45df-efa0-54626dbcb3fa"
      },
      "source": [
        "# 無名関数でのキャプチャ演算子の使用 \n",
        "!elixir -e 'IO.inspect Enum.map([1,2,3], fn number -> number + 3 end)'\n",
        "!elixir -e 'IO.inspect Enum.map([1,2,3], &(&1 + 3))'\n",
        "!elixir -e 'plus_three = &(&1 + 3);IO.inspect Enum.map([1,2,3], plus_three)'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[4, 5, 6]\n",
            "[4, 5, 6]\n",
            "[4, 5, 6]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Enum.all? でもキャプチャ演算子が使えるか\n",
        "# all? 関数を引数で受け取り、リストの全体が true の時、true を返す\n",
        "# !elixir -e 'IO.puts Enum.all?([\"foo\", \"bar\", \"hello\"], fn(s) -> String.length(s) == 3 end)'\n",
        "!elixir -e 'IO.puts Enum.all?([\"foo\", \"bar\", \"hello\"], &(String.length(&1)==3))'\n",
        "# !elixir -e 'IO.puts Enum.all?([\"foo\", \"bar\", \"hello\"], fn(s) -> String.length(s) >1 end)'\n",
        "!elixir -e 'IO.puts Enum.all?([\"foo\", \"bar\", \"hello\"], &(String.length(&1)>1))'"
      ],
      "metadata": {
        "id": "FJOjmrwv6AQW",
        "outputId": "593483f5-4966-483d-ae18-13c288d2f0c0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "false\n",
            "true\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HhMGJ2HzdAPn"
      },
      "source": [
        "---\n",
        "# パターンマッチング\n",
        "\n",
        "パターンマッチングでは、値、データ構造、関数をマッチすることができる。\n",
        "\n",
        "* マッチ演算子\n",
        "* ピン演算子"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6oVfGSzCdX2-",
        "outputId": "ff4ca919-c6ab-4063-9074-79c57f64059e"
      },
      "source": [
        "# マッチ演算子 `=` はマッチ演算子である。 マッチ演算子を通して値を代入し、\n",
        "# その後、マッチさせることができる。マッチすると、方程式の結果が返され、\n",
        "# 失敗すると、エラーになる\n",
        "!elixir -e 'IO.puts x = 1'\n",
        "!elixir -e 'x = 1;IO.puts 1 = x'\n",
        "# !elixir -e 'x = 1;IO.puts 2 = x'\n",
        "#=> (MatchError) no match of right hand side value: 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V_S_BGxmeX-4",
        "outputId": "5c48ee1c-a2d0-4c10-882d-98ed5bfd39bc"
      },
      "source": [
        "# リストでのマッチ演算子\n",
        "!elixir -e 'IO.inspect list = [1, 2, 3]'\n",
        "!elixir -e 'list = [1, 2, 3]; IO.inspect [1, 2, 3] = list'\n",
        "# !elixir -e 'list = [1, 2, 3]; IO.inspect [] = list'\n",
        "#=> (MatchError) no match of right hand side value: [1, 2, 3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3]\n",
            "[1, 2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JGD6GcMsGG7n",
        "outputId": "5e24a243-c726-45bd-a070-835c476619c1"
      },
      "source": [
        "!elixir -e 'list = [1, 2, 3]; IO.inspect [1 | tail] = list'\n",
        "!elixir -e 'list = [1, 2, 3];  [1 | tail] = list; IO.inspect tail'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 2, 3]\n",
            "[2, 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FAI9EHeUGviK",
        "outputId": "464b317d-3674-459d-e725-4c0a20da4793"
      },
      "source": [
        "# タプルとマッチ演算子\n",
        "!elixir -e 'IO.inspect {:ok, value} = {:ok, \"Successful!\"}'\n",
        "!elixir -e '{:ok, value} = {:ok, \"Successful!\"}; IO.inspect  value'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{:ok, \"Successful!\"}\n",
            "\"Successful!\"\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "niw-oNFPHc8u"
      },
      "source": [
        "---\n",
        "**ピン演算子**\n",
        "\n",
        "マッチ演算子は左辺に変数が含まれている時に代入操作を行う。 \n",
        "\n",
        "この変数を再び束縛するという挙動は望ましくない場合がある。 そうした状況のために、ピン演算子 `^` がある。\n",
        "\n",
        "ピン演算子で変数を固定すると、新しく再束縛するのではなく既存の値とマッチする。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LwiOOT1LIEwW",
        "outputId": "c3d1b47a-2c84-4e3b-c65c-311f81d79efc"
      },
      "source": [
        "# ピン演算子\n",
        "!elixir -e 'IO.inspect x = 1'\n",
        "# !elixir -e 'x = 1; IO.inspect ^x = 2'\n",
        "#=> ** (MatchError) no match of right hand side value: 2\n",
        "!elixir -e 'x = 1; IO.inspect {x, ^x} = {2, 1}'\n",
        "!elixir -e 'x = 1;{x, ^x} = {2, 1}; IO.inspect x'\n",
        "!echo\n",
        "!elixir -e 'IO.inspect key = \"hello\"'\n",
        "!elixir -e 'key = \"hello\"; IO.inspect %{^key => value} = %{\"hello\" => \"world\"}'\n",
        "!elixir -e 'key = \"hello\"; %{^key => value} = %{\"hello\" => \"world\"}; IO.inspect value'\n",
        "!elixir -e 'key = \"hello\"; %{^key => value} = %{\"hello\" => \"world\"}; IO.inspect value'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "{2, 1}\n",
            "2\n",
            "\n",
            "\"hello\"\n",
            "%{\"hello\" => \"world\"}\n",
            "\"world\"\n",
            "\"world\"\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GwNu1JTePo1J",
        "outputId": "0f8d0fe6-f415-4351-8f49-8703abee874a"
      },
      "source": [
        "# 関数の clause でのピン演算子\n",
        "!elixir -e 'IO.inspect greeting = \"Hello\"'\n",
        "!elixir -e 'greeting = \"Hello\"; IO.inspect greet = fn (^greeting, name) -> \"Hi #{name}\"; (greeting, name) -> \"#{greeting},#{name}\" end'\n",
        "!elixir -e 'greeting = \"Hello\"; greet = fn (^greeting, name) -> \"Hi #{name}\"; (greeting, name) -> \"#{greeting},#{name}\" end; IO.inspect greet.(\"Hello\",\"Sean\")'\n",
        "!elixir -e 'greeting = \"Hello\"; greet = fn (^greeting, name) -> \"Hi #{name}\"; (greeting, name) -> \"#{greeting},#{name}\" end; IO.inspect greet.(\"Mornin\",\"Sean\")'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\"Hello\"\n",
            "#Function<43.65746770/2 in :erl_eval.expr/5>\n",
            "\"Hi Sean\"\n",
            "\"Mornin,Sean\"\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ApkBxRTzSJuh"
      },
      "source": [
        "# 制御構造 control structure\n",
        "\n",
        "* if と unless\n",
        "* case\n",
        "* cond\n",
        "* with"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uutvm8_BUOTu"
      },
      "source": [
        "if と unless \n",
        "\n",
        "elixir の if と unless は ruby と同じ。\n",
        "\n",
        "elixir は if と unless はマクロとして定義されている。\n",
        "\n",
        "この実装は kernel module で知ることができる。\n",
        "\n",
        "elixir では偽とみなされる値は nil と真理値の false だけだということに留意。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z43eR8Muc03m",
        "outputId": "442fc091-3c4d-4dd1-ff79-f1bad55f75d3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "%%writefile temp.exs\n",
        "IO.puts (\n",
        "    if String.valid?(\"Hello\") do\n",
        "        \"Valid string!\"\n",
        "    else\n",
        "        \"Invalid string.\"\n",
        "    end)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "yBvYo7dOfTRL",
        "outputId": "66ff6113-f938-4496-f97d-ec2651ab3799",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Valid string!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "%%writefile temp.exs\n",
        "if \"a string value\" do\n",
        "  IO.puts \"Truthy\"\n",
        "end"
      ],
      "metadata": {
        "id": "orOuUBAHerSw",
        "outputId": "2396f2b0-bade-44ae-ad43-1761e898278f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "uSiaeBxPgJ8I",
        "outputId": "ce0c7439-10f6-4e37-f24a-0659a0c9132a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Truthy\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# unless/2 は if/2 の逆で、条件が否定される時だけ作用する\n",
        "%%writefile temp.exs\n",
        "unless is_integer(\"hello\") do\n",
        "  IO.puts \"Not an Int\"\n",
        "end"
      ],
      "metadata": {
        "id": "5ir5OTregAuR",
        "outputId": "2fdd4e28-968e-4728-d91f-533ca6bcfd28",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "G5CXvQ_IKfa-",
        "outputId": "aa7ebe44-c510-419d-a9b1-147acdadcce8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Not an Int\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 実験 シェルワンライナー版 do や end の前後にセミコロンは要らない\n",
        "!elixir -e 'unless is_integer(\"hello\") do IO.puts \"Not an Int\" end'"
      ],
      "metadata": {
        "id": "kij-SM3GKofM",
        "outputId": "d76e3a96-a3f3-455b-b748-55dfd14c7479",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Not an Int\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 複数のパターンにマッチする場合、case/2 を使う\n",
        "%%writefile temp.exs\n",
        "IO.puts(\n",
        "    case {:error, \"Hello World\"} do\n",
        "        {:ok, result} -> result\n",
        "        {:error, _} -> \"Uh oh!\"\n",
        "        _ -> \"Catch all\"\n",
        "    end   \n",
        ")"
      ],
      "metadata": {
        "id": "BRwwkAlTKCUi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "p3QNHz3iMTRC",
        "outputId": "9feb815d-e744-4ce2-d296-d46f22e24e38",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Uh oh!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# アンダースコア _ 変数は case/2 命令文の中に含まれる重要な要素\n",
        "# これが無いと、マッチするものが見あたらない場合にエラーが発生する\n",
        "# エラーの例\n",
        "!elixir -e 'case :even do :odd -> IO.puts \"Odd\" end'"
      ],
      "metadata": {
        "id": "ZvrCgzn8MDrG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1153055b-64c1-4894-bc9f-cb11f4841628"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "** (CaseClauseError) no case clause matching: :even\n",
            "    (stdlib 3.17) erl_eval.erl:973: :erl_eval.case_clauses/6\n",
            "    (elixir 1.13.0) lib/code.ex:404: Code.validated_eval_string/3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# アンダースコア _ を\"他の全て\"にマッチする else と考えること\n",
        "!elixir -e 'case :even do :odd -> IO.puts \"Odd\"; _ -> IO.puts \"Not odd\" end'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qmOrY5WcqHmS",
        "outputId": "ae5234a6-8d8e-4bc1-da53-1790069fa0ad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Not Odd\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# case/2 はパターンマッチングに依存しているため、パターンマッチングと同じルールや制限が全て適用される\n",
        "# 既存の変数に対してマッチさせようという場合にはピン ^ 演算子を使う\n",
        "!elixir -e 'pie=3.14; IO.puts(case \"cherry pie\" do ^pie -> \"Not so tasty\"; pie -> \"I bet #{pie} is tasty\" end)'\n",
        "!elixir -e 'pie=3.14; IO.puts(case \"cherry pie\" do pie -> \"Not so tasty\"; pie -> \"I bet #{pie} is tasty\" end)'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VvixstfspdMg",
        "outputId": "358f3325-ebe2-4d0d-d203-8c74e290b47c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I bet cherry pie is tasty\n",
            "\u001b[33mwarning: \u001b[0mvariable \"pie\" is unused (there is a variable with the same name in the context, use the pin operator (^) to match on it or prefix this variable with underscore if it is not meant to be used)\n",
            "  nofile:1\n",
            "\n",
            "Not so tasty\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# case/2 はガード節に対応している\n",
        "# 公式ドキュメントの Expressions allowed in guard clauses を参照\n",
        "!elixir -e 'IO.puts(case {1, 2, 3} do {1, x, 3} when x > 0 ->  \"Will match\"; _ -> \"Wont match\" end)'"
      ],
      "metadata": {
        "id": "vSS7z1OJhVuM",
        "outputId": "1d26524c-91ee-4cd9-a724-3faa8f5fbc08",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Will match\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "ガード節とは何か?\n",
        "\n",
        "公式ドキュメントの Expressions allowed in guard clauses を参照"
      ],
      "metadata": {
        "id": "gvAtkTuJudCW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# cond\n",
        "!elixir -e 'IO.puts (cond do 2+2==5 -> \"This will not be true\"; 2*2==3 -> \"Nor this\"; 1+1 == 2 -> \"But this will\" end)'"
      ],
      "metadata": {
        "id": "Rp0tS5sZiSOc",
        "outputId": "9c01863f-930e-4086-ba71-1e785211a68b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "But this will\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# cond も case と同様マッチしない場合にエラーになるので、true になる条件を定義する\n",
        "!elixir -e 'IO.puts (cond do 7+1==0 -> \"Incorrect\"; true -> \"Catch all\" end)'"
      ],
      "metadata": {
        "id": "UlmVzzxSvScP",
        "outputId": "6bc9f835-f587-45f3-f707-aa379119e788",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Catch all\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# with\n",
        "# 特殊形式の with/1 はネストされた case/2 文やきれいにパイプできない状況に便利\n",
        "# with/1 式はキーワード, ジェネレータ, そして式から成り立っている\n",
        "# ジェネレータについてはリスト内包表記のところで詳しく述べる\n",
        "# `<-` の右側と左側を比べるのにパターンマッチングが使われる\n",
        "!elixir -e 'user=%{first: \"Sean\", last: \"Callan\"}; IO.inspect user'\n",
        "!elixir -e 'user=%{first: \"Sean\", last: \"Callan\"}; with {:ok, first} <- Map.fetch(user, :first), {:ok, last} <- Map.fetch(user, :last), do: IO.puts last <> \", \" <> first'"
      ],
      "metadata": {
        "id": "_vskxd42u1yZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4d887e47-6a0e-4e72-a037-5fa88d75e0c7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "%{first: \"Sean\", last: \"Callan\"}\n",
            "Callan, Sean\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# シェルワンライナーが長いのでファイルにする\n",
        "%%writefile temp.exs\n",
        "user=%{first: \"Sean\", last: \"Callan\"}\n",
        "with {:ok, first} <- Map.fetch(user, :first), \n",
        "     {:ok, last} <- Map.fetch(user, :last), \n",
        "     do: IO.puts last <> \", \" <> first"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8YpF6Kfvmk0l",
        "outputId": "f2b513e5-8bd1-44f0-b0f0-629138d28b28"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "-i3TfnSJ3pRr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 式がマッチに失敗した場合\n",
        "# Map.fetch が失敗して :error を返し、first が設定されずプログラムが止まる\n",
        "%%writefile temp.exs\n",
        "user = %{first: \"doomspork\"}\n",
        "with {:ok, first} <- Map.fetch(user, :first), \n",
        "     {:ok, last} <- Map.fetch(user, :last), \n",
        "     do: IO.puts last <> \", \" <> first"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fOCtVo-SlEP9",
        "outputId": "6fef88e2-cb6d-44df-ec02-b2155215d19f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "fPP4H-n03y7j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# with/1 で else が使える\n",
        "%%writefile temp.exs\n",
        "import Integer\n",
        "m = %{a: 1, c: 3}\n",
        "a =\n",
        "    with {:ok, number} <- Map.fetch(m, :a),\n",
        "        true <- is_even(number) do\n",
        "        IO.puts \"#{number} divided by 2 is #{div(number, 2)}\"\n",
        "        :even\n",
        "    else\n",
        "        :error ->\n",
        "        IO.puts(\"We don't have this item in map\")\n",
        "        :error\n",
        "        _ ->\n",
        "        IO.puts(\"It is odd\")\n",
        "        :odd\n",
        "    end\n",
        "IO.inspect a"
      ],
      "metadata": {
        "id": "P8SHBCjl3xIE",
        "outputId": "d52e6631-24f4-4201-e2d0-45528d75ec37",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "URsOixzc0OB6",
        "outputId": "d601b10c-87c1-4f4c-b863-8d71bc088975",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "We don't have this item in map\n",
            ":error\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 関数 Function"
      ],
      "metadata": {
        "id": "tA-2SV-B3xog"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 関数型言語では、関数は第一級オブジェクト first class object である\n",
        "# ここでは無名関数、名前付き関数、アリティ、パターンマッチング、プライベート関数、ガード、デフォルト引数について学ぶ\n",
        "\n",
        "# 無名関数 anonymous function\n",
        "# fn end のキーワードを用い、 引数 `->` 関数定義 の形で定義する\n",
        "\n",
        "%%writefile temp.exs\n",
        "sum = fn (a, b) -> a + b end\n",
        "IO.puts sum.(2, 3)"
      ],
      "metadata": {
        "id": "apjGj4Bh4Wz0",
        "outputId": "09ca3abe-1987-467e-ca81-277e89a41a4d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "n0TJnbjFIZ4g",
        "outputId": "ccdf9a78-c19c-48fe-dc59-80bc754e4145",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# シェルワンライナーで書いてみる\n",
        "!elixir -e 'sum=fn(a,b)->a+b end;IO.puts sum.(2,3)'"
      ],
      "metadata": {
        "id": "tTLfP24XIw8d",
        "outputId": "8d694c11-786f-496f-bcc4-cd9dea5b542c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# elixir では通常関数定義に省略記号 & を使う (キャプチャ演算子)\n",
        "!elixir -e 'sum =  &(&1 + &2); IO.puts sum.(2, 3)'"
      ],
      "metadata": {
        "id": "lRYRwRcmI6fT",
        "outputId": "9b104dbf-3fba-4d7f-f48d-eaec90bca85a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "質問 無名関数に引数を渡して結果を得るのはどうやるのか\n",
        "\n",
        "&(&1 + &2).(2, 3) として出来なかった。 => 出来た。\n",
        "\n",
        "!elixir -e 'IO.puts ((&(&1 + &2)).(2,3))'"
      ],
      "metadata": {
        "id": "Q_Te_inaI44d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir -e 'IO.puts ((fn (a,b) -> a + b end).(2,3))'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iEos7DcrrCU5",
        "outputId": "a42a7b12-d42f-4f32-8f21-765ce3ab8c17"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir -e 'IO.puts ((&(&1 + &2)).(2,3))'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5r-AuEsyrup-",
        "outputId": "a410a815-f94f-4cc5-cc40-a76f781dd141"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 関数定義にパターンマッチングが使える\n",
        "%%writefile temp.exs\n",
        "handle_result = fn\n",
        "  {:ok, _result} -> IO.puts \"Handling result...\"\n",
        "  {:ok, _} -> IO.puts \"This would be never run as previous will be matched beforehand.\"\n",
        "  {:error} -> IO.puts \"An error has occurred!\"\n",
        "end\n",
        "\n",
        "some_result = 1\n",
        "\n",
        "handle_result.({:ok, some_result}) #=> Handling result...\n",
        "handle_result.({:error}) #=> An error has occured!"
      ],
      "metadata": {
        "id": "z7lXwZVn3wQS",
        "outputId": "67bfe600-f280-4db3-e737-2592f13c0d49",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "465mw6CwJY7y",
        "outputId": "d74377b7-3340-41bd-fc2e-db3df91cca2d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Handling result...\n",
            "An error has occurred!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 名前付き関数\n",
        "# 名前付き関数はモジュール内部で def キーワードを用いて定義する\n",
        "%%writefile temp.exs\n",
        "defmodule Greeter do\n",
        "  def hello(name) do\n",
        "    \"Hello, \" <> name\n",
        "  end\n",
        "end\n",
        "\n",
        "IO.puts Greeter.hello(\"Sean\")"
      ],
      "metadata": {
        "id": "0J2duvt9hxj9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "de33264c-dac0-4b55-e3d8-c78cbb7c4878"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "KOUrqgRstuzd",
        "outputId": "efb80b76-9917-4390-9c9d-0d205f211e8f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Sean\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 次のような書き方もできる do: を使う\n",
        "%%writefile temp.exs\n",
        "defmodule Greeter do\n",
        "  def hello(name), do: \"Hello, \" <> name\n",
        "end\n",
        "IO.puts Greeter.hello(\"Sean\")"
      ],
      "metadata": {
        "id": "40A5ArPCuGQc",
        "outputId": "14149f1a-c222-4fac-f440-6a6da60686a2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "TG3LCiL_uMob",
        "outputId": "02ab69d9-f4dd-4852-a76d-52c2297701cc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Sean\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 実験 シェルワンライナーで出来るか\n",
        "!elixir -e 'defmodule Greeter do def hello(name) do \"Hello, \" <> name end end;IO.puts Greeter.hello(\"Sean\")'"
      ],
      "metadata": {
        "id": "5Jr4ycS4zSFX",
        "outputId": "73acb219-5b76-486d-de5f-193fe459003c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Sean\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 実験 シェルワンライナーで `, do:` 構文が使えるか\n",
        "!elixir -e 'defmodule Greeter do def hello(name),do: \"Hello, \" <> name end;IO.puts Greeter.hello(\"Sean\")'"
      ],
      "metadata": {
        "id": "bssZREBYvMOa",
        "outputId": "981cf887-8dc5-4048-dcfd-0da966f8b070",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Sean\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 再帰\n",
        "%%writefile temp.exs\n",
        "defmodule Length do\n",
        "  def of([]), do: 0\n",
        "  def of([_ | tail]), do: 1 + of(tail)\n",
        "end\n",
        "\n",
        "IO.puts Length.of []\n",
        "IO.puts Length.of [1, 2, 3]"
      ],
      "metadata": {
        "id": "bSP7kU4OtstP",
        "outputId": "dbbdf2d4-253f-4fca-9728-ae93c4e3e03d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rMb-Kv0kJtWI",
        "outputId": "5d01e9e2-9c89-4186-c3b5-725417b00518"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# アリティとは関数の引数の数\n",
        "# 引数の数が違えば別の関数\n",
        "%%writefile temp.exs\n",
        "defmodule Greeter2 do\n",
        "  def hello(), do: \"Hello, anonymous person!\"   # hello/0\n",
        "  def hello(name), do: \"Hello, \" <> name        # hello/1\n",
        "  def hello(name1, name2), do: \"Hello, #{name1} and #{name2}\"  # hello/2\n",
        "end\n",
        "\n",
        "IO.puts Greeter2.hello()\n",
        "IO.puts Greeter2.hello(\"Fred\")\n",
        "IO.puts Greeter2.hello(\"Fred\", \"Jane\")"
      ],
      "metadata": {
        "id": "dkrk2GHlJriH",
        "outputId": "182f7f30-442a-499d-f7da-ed7e15e1cbc8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "outputId": "7c7ef271-8133-4c41-c361-7db344243a11",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fbe9LypEK0jM"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, anonymous person!\n",
            "Hello, Fred\n",
            "Hello, Fred and Jane\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 関数とパターンマッチング\n",
        "%%writefile temp.exs\n",
        "defmodule Greeter1 do\n",
        "  def hello(%{name: person_name}) do\n",
        "    IO.puts \"Hello, \" <> person_name\n",
        "  end\n",
        "end\n",
        "\n",
        "fred = %{\n",
        "name: \"Fred\",\n",
        "age: \"95\",\n",
        "favorite_color: \"Taupe\"\n",
        "}\n",
        "\n",
        "IO.puts Greeter1.hello(fred) #=> Hello, fred になる\n",
        "#IO.puts Greeter1.hello(%{age: \"95\", favorite_color: \"Taupe\"}) #=> (FunctionClauseError) no function clause matching in Greeter1.hello/1    "
      ],
      "metadata": {
        "id": "KnlApZGNKvwz",
        "outputId": "7071fe00-2f75-4f21-aa60-61bb8cb2717d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "h39IL5SzM8JL",
        "outputId": "5f682bea-ceea-4450-b691-580d60b9309a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Fred\n",
            "ok\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Fredの名前を person_name にアサインしたいが、人物マップ全体の値も保持したいという場合\n",
        "# マップを引数にすれば、別々の変数に格納することができる\n",
        "%%writefile temp.exs\n",
        "defmodule Greeter2 do\n",
        "  def hello(%{name: person_name} = person) do\n",
        "    IO.puts \"Hello, \" <> person_name\n",
        "    IO.inspect person\n",
        "  end\n",
        "end\n",
        "\n",
        "fred = %{\n",
        "    name: \"Fred\",\n",
        "    age: \"95\",\n",
        "    favorite_color: \"Taupe\"\n",
        "}\n",
        "\n",
        "Greeter2.hello(fred)\n",
        "IO.puts(\"\")\n",
        "Greeter2.hello(%{name: \"Fred\"})\n",
        "IO.puts(\"\")\n",
        "# Greeter2.hello(%{age: \"95\", favorite_color: \"Taupe\"}) #=> (FunctionClauseError) no function clause matching in Greeter2.hello/1  "
      ],
      "metadata": {
        "id": "6lKynBV9Mf4m",
        "outputId": "f289eeca-f793-4784-c9ec-48efc7b17388",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "Jz2b_a8KPgZi",
        "outputId": "a935ed1f-70fa-41fa-f912-3e46790a03bc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Fred\n",
            "%{age: \"95\", favorite_color: \"Taupe\", name: \"Fred\"}\n",
            "\n",
            "Hello, Fred\n",
            "%{name: \"Fred\"}\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        ""
      ],
      "metadata": {
        "id": "x2gv8nXvScIi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# %{name: person_name} と person の順序を入れ替えても、それぞれがfredとマッチングするので同じ結果となる\n",
        "# 変数とマップを入れ替えてみる\n",
        "# それぞれがパターンマッチしているので結果は同じになる\n",
        "%%writefile temp.exs\n",
        "defmodule Greeter3 do\n",
        "  def hello(person = %{name: person_name}) do\n",
        "    IO.puts \"Hello, \" <> person_name\n",
        "    IO.inspect person\n",
        "  end\n",
        "end\n",
        "\n",
        "fred = %{\n",
        "    name: \"Fred\",\n",
        "    age: \"95\",\n",
        "    favorite_color: \"Taupe\"\n",
        "}\n",
        "\n",
        "Greeter3.hello(fred)\n",
        "IO.puts(\"\")\n",
        "Greeter3.hello(%{name: \"Fred\"})"
      ],
      "metadata": {
        "id": "anHa6vZZPdDd",
        "outputId": "af0155aa-88d9-41ae-efbb-e563aa32d683",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "QDqgjr50czxl",
        "outputId": "91540325-482f-4414-f10e-63a0480497b9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Fred\n",
            "%{age: \"95\", favorite_color: \"Taupe\", name: \"Fred\"}\n",
            "\n",
            "Hello, Fred\n",
            "%{name: \"Fred\"}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# プライベート関数\n",
        "# プライベート関数は defp を用いて定義する\n",
        "# そのモジュール自身の内部からのみ呼び出すことが出来る\n",
        "%%writefile temp.exs\n",
        "defmodule Greeter do\n",
        "  def hello(name), do: phrase() <> name\n",
        "  defp phrase, do: \"Hello, \"\n",
        "end\n",
        "\n",
        "IO.puts Greeter.hello(\"Sean\") #=> \"Hello, Sean\"\n",
        "\n",
        "# IO.puts Greeter.phrase #=> (UndefinedFunctionError) function Greeter.phrase/0 is undefined or private"
      ],
      "metadata": {
        "id": "N33nfBikcyPK",
        "outputId": "ece5e8e0-bd70-4a86-dc42-cdbae7a71ea5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "ktbKD1FQeRKb",
        "outputId": "3018707f-d82a-486b-f5be-daab7c26d842",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Sean\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# ガード\n",
        "%%writefile temp.exs\n",
        "defmodule Greeter do\n",
        "  def hello(names) when is_list(names) do\n",
        "    names\n",
        "    |> Enum.join(\", \")\n",
        "    |> hello\n",
        "  end\n",
        "\n",
        "  def hello(name) when is_binary(name) do\n",
        "    phrase() <> name\n",
        "  end\n",
        "\n",
        "  defp phrase, do: \"Hello, \"\n",
        "end\n",
        "\n",
        "IO.puts Greeter.hello [\"Sean\", \"Steve\"]\n",
        "IO.puts Greeter.hello \"Bill\""
      ],
      "metadata": {
        "id": "TN55IVk5eOIO",
        "outputId": "a4fddd62-fe8d-478a-d4ac-c932b71b2ad8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "6us-vCxGfQ_L",
        "outputId": "d38d8a2e-1f05-4454-ce70-f256f2854722",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Sean, Steve\n",
            "Hello, Bill\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "質問 Elixir のガードは Haskell のガードと同じか?"
      ],
      "metadata": {
        "id": "VHzBc9JTgBbt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# デフォルト引数\n",
        "# デフォルト値が欲しい場合、引数 \\\\ デフォルト値の記法を用いる\n",
        "%%writefile temp.exs\n",
        "defmodule Greeter do\n",
        "  def hello(name, language_code \\\\ \"en\") do\n",
        "    phrase(language_code) <> name\n",
        "  end\n",
        "\n",
        "  defp phrase(\"en\"), do: \"Hello, \"\n",
        "  defp phrase(\"es\"), do: \"Hola, \"\n",
        "end\n",
        "\n",
        "IO.puts Greeter.hello(\"Sean\", \"en\")\n",
        "IO.puts Greeter.hello(\"Sean\")\n",
        "IO.puts Greeter.hello(\"Sean\", \"es\")"
      ],
      "metadata": {
        "id": "m5yEYdVmfPUD",
        "outputId": "fedd0bc7-f453-4d72-e4de-041b0a5fe0e1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "pH1mg6uIg5FW",
        "outputId": "ad369ec3-d4f8-4cd8-af74-2d6b663b7c69",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Sean\n",
            "Hello, Sean\n",
            "Hola, Sean\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# ガードとデフォルト引数を組み合わせる場合\n",
        "# 混乱を避けるためデフォルト引数を処理する定義を先に置く\n",
        "%%writefile temp.exs\n",
        "defmodule Greeter do\n",
        "  def hello(names, language_code \\\\ \"en\")\n",
        "\n",
        "  def hello(names, language_code) when is_list(names) do\n",
        "    names\n",
        "    |> Enum.join(\", \")\n",
        "    |> hello(language_code)\n",
        "  end\n",
        "\n",
        "  def hello(name, language_code) when is_binary(name) do\n",
        "    phrase(language_code) <> name\n",
        "  end\n",
        "\n",
        "  defp phrase(\"en\"), do: \"Hello, \"\n",
        "  defp phrase(\"es\"), do: \"Hola, \"\n",
        "end\n",
        "\n",
        "IO.puts Greeter.hello [\"Sean\", \"Steve\"] #=> \"Hello, Sean, Steve\"\n",
        "\n",
        "IO.puts Greeter.hello [\"Sean\", \"Steve\"], \"es\" #=> \"Hola, Sean, Steve\"\n",
        "\n",
        "IO.puts Greeter.hello \"Bob\", \"es\""
      ],
      "metadata": {
        "id": "tiiCoqBaguFb",
        "outputId": "a6bb94ff-752b-4913-ce1f-4cb9d4386a7b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "oaIH5NT3v-mC",
        "outputId": "657158eb-fcc9-4108-9e33-efe3d31ff29c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, Sean, Steve\n",
            "Hola, Sean, Steve\n",
            "Hola, Bob\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# パイプライン演算子\n",
        "# パイプライン演算子 `|>` はある式の結果を別の式に渡す\n",
        "# 関数のネストを理解しやすくするためのもの\n",
        "\n",
        "# 文字列をトークン化する、単語に分ける\n",
        "!elixir -e 'IO.inspect \"Elixir rocks\" |> String.split()'"
      ],
      "metadata": {
        "id": "drcvbJg2v8xn",
        "outputId": "e664604b-9a60-49cc-a23f-8b3f1f7b8f59",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[\"Elixir\", \"rocks\"]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir -e 'IO.inspect \"Elixir rocks\" |> String.upcase() |> String.split()'"
      ],
      "metadata": {
        "id": "3G5UUcSwCzWj",
        "outputId": "81a275de-b7c1-4c0f-a304-fd2cdfcae6ae",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[\"ELIXIR\", \"ROCKS\"]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# パイプラインを使う場合に関数の括弧は省略せずには入れた方がわかりやすい\n",
        "!elixir -e 'IO.inspect \"elixir\" |> String.ends_with?(\"ixir\")'"
      ],
      "metadata": {
        "id": "cQAmkedpC5xx",
        "outputId": "3152e33b-7a22-48f3-8550-4088fea8b506",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "true\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# モジュール"
      ],
      "metadata": {
        "id": "UGlC7_x6EB0i"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "質問 いままで IO.puts とか一々モジュール名を付けていたが、elixir ではこれが普通なのか?\n",
        "\n",
        "関数を作る際に一々モジュールを作成していたがあれで既存のモジュールに付け加えられているのか?"
      ],
      "metadata": {
        "id": "65UKVe_iEWc7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# モジュールの基本的な例\n",
        "%%writefile temp.exs\n",
        "defmodule Example do\n",
        "  def greeting(name) do\n",
        "    \"Hello #{name}.\"\n",
        "  end\n",
        "end\n",
        "\n",
        "IO.puts Example.greeting \"Sean\""
      ],
      "metadata": {
        "id": "WSh4PoXbDju9",
        "outputId": "13fe110f-267e-4f2f-da96-fc9c879ca5d5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "jbzGvQk8vH7T",
        "outputId": "74ef7cf3-cd81-49eb-9b39-dc7240ef245a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello Sean.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# モジュールはネストする事ができる\n",
        "%%writefile temp.exs\n",
        "defmodule Example.Greetings do\n",
        "  def morning(name) do\n",
        "    \"Good morning #{name}.\"\n",
        "  end\n",
        "\n",
        "  def evening(name) do\n",
        "    \"Good night #{name}.\"\n",
        "  end\n",
        "end\n",
        "\n",
        "IO.puts Example.Greetings.morning \"Sean\""
      ],
      "metadata": {
        "id": "FrpaE8bUvE7R",
        "outputId": "87010fc3-e2b8-4b6c-99b3-aac34ceacf17",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "PIbFXtVbvg01",
        "outputId": "e40f5b99-3505-4227-ecf4-d8cbbb6a44f9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Good morning Sean.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# モジュールの属性\n",
        "# モジュール属性は Elixir では一般に定数として用いられる\n",
        "# Elixirには予約されている属性がある\n",
        "# moduledoc — 現在のモジュールにドキュメントを付ける\n",
        "# doc — 関数やマクロについてのドキュメント管理\n",
        "# behaviour — OTPまたはユーザが定義した振る舞い(ビヘイビア)に用いる\n",
        "%%writefile temp.exs\n",
        "defmodule Example do\n",
        "  @greeting \"Hello\"\n",
        "\n",
        "  def greeting(name) do\n",
        "    ~s(#{@greeting} #{name}.)\n",
        "  end\n",
        "end\n",
        "\n",
        "IO.puts Example.greeting \"tak\""
      ],
      "metadata": {
        "id": "Gr8I-hksvf4j",
        "outputId": "b957c62a-0763-4615-ff78-21980eb4e20f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "taCtOrMRnTfX",
        "outputId": "3725974a-1772-4d43-cb89-564ce916d859",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello tak.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 構造体 struct \n",
        "# 構造体は定義済みのキーの一群とデフォルト値を持つマップである\n",
        "# 定義するには defstruct を用いる\n",
        "%%writefile temp.exs\n",
        "defmodule Example.User do\n",
        "  defstruct name: \"Sean\", roles: []\n",
        "end\n",
        "\n",
        "defmodule Main do\n",
        "  IO.inspect %Example.User{}\n",
        "  IO.inspect %Example.User{name: \"Steve\"}\n",
        "  IO.inspect %Example.User{name: \"Steve\", roles: [:manager]}\n",
        "end"
      ],
      "metadata": {
        "id": "_5D0C1FdnE9-",
        "outputId": "589c3f88-8715-4420-c129-2dc795a9b575",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "4hRQw409eMTP",
        "outputId": "584e57bb-151f-48ee-e8ba-bf3778b88350",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "%Example.User{name: \"Sean\", roles: []}\n",
            "%Example.User{name: \"Steve\", roles: []}\n",
            "%Example.User{name: \"Steve\", roles: [:manager]}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 構造体の更新\n",
        "%%writefile temp.exs\n",
        "defmodule Example.User do\n",
        "  defstruct name: \"Sean\", roles: []\n",
        "end\n",
        "\n",
        "defmodule Main do\n",
        "  steve = %Example.User{name: \"Steve\"}\n",
        "  IO.inspect %{steve | name: \"Sean\"}\n",
        "  IO.inspect steve\n",
        "end"
      ],
      "metadata": {
        "id": "pg8PBjgIeIQw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "NvJWdBfAlnZ0",
        "outputId": "c8734cb7-c832-4909-8ec5-705a3ae6b33d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "%Example.User{name: \"Sean\", roles: []}\n",
            "%Example.User{name: \"Steve\", roles: []}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 構造体の更新とマッチング\n",
        "%%writefile temp.exs\n",
        "defmodule Example.User do\n",
        "  defstruct name: \"Sean\", roles: []\n",
        "end\n",
        "\n",
        "defmodule Main do\n",
        "  steve = %Example.User{name: \"Steve\"}\n",
        "  sean = %{steve | name: \"Sean\"}\n",
        "  IO.inspect %{name: \"Sean\"} = sean\n",
        "end"
      ],
      "metadata": {
        "id": "wv-S1UExnGkX",
        "outputId": "78f75198-c7ac-4c3a-e637-0e6f551e53c8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "Z717YY4-ndTs",
        "outputId": "55eda2b9-c07c-4349-f8f8-efbcdbe577f4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "%Example.User{name: \"Sean\", roles: []}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# inspect の出力を変える\n",
        "%%writefile temp.exs\n",
        "defmodule Example.User do\n",
        "  # @derive {Inspect, only: [:name]}\n",
        "  @derive {Inspect, except: [:roles]}\n",
        "  defstruct name: \"Sean\", roles: []\n",
        "end\n",
        "\n",
        "defmodule Main do\n",
        "  steve = %Example.User{name: \"Steve\"}\n",
        "  sean = %{steve | name: \"Sean\"}\n",
        "  IO.inspect %{name: \"Sean\"} = sean\n",
        "end"
      ],
      "metadata": {
        "id": "zyJz4vZBoWE5",
        "outputId": "925cef85-914e-4db9-e782-472108654d9c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "4ClqLVPqoy0Z",
        "outputId": "83f74ac9-47ba-4c13-f289-d5b34def53de",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "#Example.User<name: \"Sean\", ...>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# コンポジション(Composition)\n",
        "# コンポジションを用いてモジュールや構造体に既存の機能を追加する\n",
        "\n",
        "# alias モジュール名をエイリアスする\n",
        "\n",
        "%%writefile temp.exs\n",
        "\n",
        "defmodule Sayings.Greetings do\n",
        "  def basic(name), do: \"Hi, #{name}\"\n",
        "end\n",
        "\n",
        "defmodule Example do\n",
        "  alias Sayings.Greetings\n",
        "  def greeting(name), do: Greetings.basic(name)\n",
        "end\n",
        "\n",
        "IO.puts Example.greeting \"Bob!!\"\n",
        "\n",
        "# aliasを使わない場合\n",
        "\n",
        "# defmodule Example do\n",
        "#   def greeting(name), do: Sayings.Greetings.basic(name)\n",
        "# end"
      ],
      "metadata": {
        "id": "MCncJEQPnvUf",
        "outputId": "b3414a14-7c73-4311-aeaf-84f2b2895d29",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "--jGGZGWq-0N",
        "outputId": "c3d04d76-2ada-44a9-abe0-1f886d76f8fc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hi, Bob!!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 別名で alias したい時は `:as` を使う\n",
        "%%writefile temp.exs\n",
        "defmodule Sayings.Greetings do\n",
        "  def basic(name), do: \"Hi, #{name}\"\n",
        "end\n",
        "\n",
        "defmodule Example do\n",
        "  alias Sayings.Greetings, as: Hi\n",
        "  def print_message(name), do: Hi.basic(name)\n",
        "end\n",
        "\n",
        "IO.puts Example.print_message \"Chris!!\""
      ],
      "metadata": {
        "id": "BsbG9jcArVGG",
        "outputId": "537aef50-dd57-4a10-b3c2-ec4f38a82e41",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "XH-B-hGVrqHS",
        "outputId": "bc9c40ab-7287-48e5-bcfc-8a9e6fb205f8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hi, Chris!!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 複数のモジュールを一度に alias する\n",
        "\n",
        "# defmodule Example do\n",
        "#   alias Sayings.{Greetings, Farewells}\n",
        "# end"
      ],
      "metadata": {
        "id": "MHviUAtIqb9t"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# import\n",
        "# 関数を取り込みたいという場合には、 import を使う\n",
        "!elixir -e 'import List; IO.inspect last([1,2,3])'"
      ],
      "metadata": {
        "id": "nKBzB0T1r4Fs",
        "outputId": "605087c3-dc87-4dc6-bd05-0e26c35f7a0e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# フィルタリング\n",
        "# import のデフォルトでは全ての関数とマクロが取り込まれるが、 :only や :except でフィルタすることができる\n",
        "# アリティを付ける必要がある\n",
        "%%writefile temp.exs\n",
        "import List, only: [last: 1]\n",
        "IO.inspect last([1,2,3])\n",
        "# IO.inspect first([1,2,3]) #=>  (CompileError) temp.exs:3: undefined function first/1 (there is no such import)"
      ],
      "metadata": {
        "id": "OrvCY4AnsMnf",
        "outputId": "54c52126-29ef-4c42-86cd-689f941b4b86",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "qrPAk7fvtOCt",
        "outputId": "120b6201-d479-4151-9945-c67ac9973699",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# import には :functions と :macros という2つの特別なアトムもありるこれらはそれぞれ関数とマクロのみを取り込む\n",
        "\n",
        "# import List, only: :functions\n",
        "# import List, only: :macros"
      ],
      "metadata": {
        "id": "A-c-MBYdtLwe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# require と import の違いがわからない\n",
        "# まだロードされていないマクロを呼びだそうとすると、Elixirはエラーを発生させる\n",
        "# とのこと\n",
        "\n",
        "# defmodule Example do\n",
        "#   require SuperMacros\n",
        "# \n",
        "#   SuperMacros.do_stuff\n",
        "# end"
      ],
      "metadata": {
        "id": "D_PC4H65uCz_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# use\n",
        "# use マクロを用いることで他のモジュールを利用して現在のモジュールの定義を変更することができる\n",
        "# コード上で use を呼び出すと、実際には提供されたモジュールに定義されている \n",
        "# __using__/1 コールバックを呼び出している \n",
        "%%writefile temp.exs\n",
        "defmodule Hello do\n",
        "  defmacro __using__ _ do\n",
        "    quote do\n",
        "      def hello(name), do: \"Hi, #{name}\"\n",
        "    end\n",
        "  end\n",
        "end\n",
        "\n",
        "defmodule Example do\n",
        "  use Hello\n",
        "end\n",
        "\n",
        "IO.puts Example.hello(\"Sean\")"
      ],
      "metadata": {
        "id": "9f4axWqnXj9u",
        "outputId": "0a471191-25b0-47d5-87e1-781a21681613",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "XHsNwXqfXq8I",
        "outputId": "627f9d9b-f0f3-42a5-e31d-0fc5e2ce6df9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hi, Sean\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# greeting オプションを追加する\n",
        "%%writefile temp.exs\n",
        "defmodule Hello do\n",
        "  defmacro __using__(opts) do\n",
        "    greeting = Keyword.get(opts, :greeting, \"Hi\")\n",
        "\n",
        "    quote do\n",
        "      def hello(name), do: unquote(greeting) <> \", \" <> name\n",
        "    end\n",
        "  end\n",
        "end\n",
        "\n",
        "defmodule Example do\n",
        "  use Hello, greeting: \"Hola\"\n",
        "end\n",
        "\n",
        "IO.puts Example.hello(\"Sean\")"
      ],
      "metadata": {
        "id": "W2QZtjAku7nX",
        "outputId": "c878e8b8-c9b9-4f45-ad5d-88429f0085e1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "HfSAYq0qZG5y",
        "outputId": "9abf411b-0e09-4079-e738-47970b75d5a0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hola, Sean\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Mix"
      ],
      "metadata": {
        "id": "KeRqOiJEw9p1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# mixとは Ruby の Bundler, RubyGems, Rake が組み合わさったようなもの\n",
        "# colab の環境でやってみる\n",
        "!mix new example\n",
        "#=> \n",
        "# * creating README.md\n",
        "# * creating .formatter.exs\n",
        "# * creating .gitignore\n",
        "# * creating mix.exs\n",
        "# * creating lib\n",
        "# * creating lib/example.ex\n",
        "# * creating test\n",
        "# * creating test/test_helper.exs\n",
        "# * creating test/example_test.exs\n",
        "# \n",
        "# Your Mix project was created successfully.\n",
        "# You can use \"mix\" to compile it, test it, and more:\n",
        "# \n",
        "#     cd example\n",
        "#     mix test\n",
        "# \n",
        "# Run \"mix help\" for more commands."
      ],
      "metadata": {
        "id": "IfeH8cFvwdQl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# colab 環境ではシステムコマンドを 1 行の中で書かないとディレクトリ内の処理ができない\n",
        "!cd example; mix test"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hm02EPK3MtYn",
        "outputId": "4f7890cc-71e0-4370-f6eb-226d1d6abb2b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[32m.\u001b[0m\u001b[32m.\u001b[0m\n",
            "\n",
            "Finished in 0.04 seconds (0.00s async, 0.04s sync)\n",
            "\u001b[32m1 doctest, 1 test, 0 failures\u001b[0m\n",
            "\n",
            "Randomized with seed 861553\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!cd example; ls -la"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zCivZ5oQN-lW",
        "outputId": "7bd006b5-69f6-4900-ef87-eb8ed5d63712"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "total 36\n",
            "drwxr-xr-x 5 root root 4096 Mar 17 18:47 .\n",
            "drwxr-xr-x 1 root root 4096 Mar 17 18:42 ..\n",
            "drwxr-xr-x 3 root root 4096 Mar 17 18:47 _build\n",
            "-rw-r--r-- 1 root root   97 Mar 17 18:42 .formatter.exs\n",
            "-rw-r--r-- 1 root root  629 Mar 17 18:42 .gitignore\n",
            "drwxr-xr-x 2 root root 4096 Mar 17 18:42 lib\n",
            "-rw-r--r-- 1 root root  572 Mar 17 18:42 mix.exs\n",
            "-rw-r--r-- 1 root root  469 Mar 17 18:42 README.md\n",
            "drwxr-xr-x 2 root root 4096 Mar 17 18:42 test\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!cd example; cat mix.exs\n",
        "#=> 次のフォーマットのプログラムが出来る\n",
        "# defmodule Example.MixProject do\n",
        "#   use Mix.Project\n",
        "#   def project do  # 名前(app)と依存関係(deps)が書かれている\n",
        "#   def application do\n",
        "#   defp deps do\n",
        "# end"
      ],
      "metadata": {
        "id": "htszqdiaR6Po"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!cd example; iex -S mix"
      ],
      "metadata": {
        "id": "2Fx56rd0TFaL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# iex で対話的に使うことが出来るが colab 環境では出来ない\n",
        "# cd example\n",
        "# iex -S mix"
      ],
      "metadata": {
        "id": "DqnwfypGMEuC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# compile\n",
        "# mix はコードの変更を自動的にコンパイルする\n",
        "# 明示的にコンパイルすることも出来る\n",
        "# !cd example; mix compile \n",
        "# rootディレクトリ以外から実行する場合は、グローバルmix taskのみが実行可能"
      ],
      "metadata": {
        "id": "EAtTK2oqWF6z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!cd example; mix compile "
      ],
      "metadata": {
        "id": "fT-l3tqRlF_M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!cd example; ls -la"
      ],
      "metadata": {
        "id": "NbjDYss6lQ5J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!cd example; ls -laR _build"
      ],
      "metadata": {
        "id": "AWjw8jmSlb3g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 依存関係を管理する \n",
        "# 新しい依存関係を追加するには、 mix.exs の deps 内に追加する\n",
        "# パッケージ名のアトムと、バージョンを表す文字列)と1つの任意的な値(オプション)を持つタプル\n",
        "# 実例として、phoenix_slimのようなプロジェクトの依存関係を見る\n",
        "\n",
        "# def deps do\n",
        "#   [\n",
        "#     {:phoenix, \"~> 1.1 or ~> 1.2\"},\n",
        "#     {:phoenix_html, \"~> 2.3\"},\n",
        "#     {:cowboy, \"~> 1.0\", only: [:dev, :test]},\n",
        "#     {:slime, \"~> 0.14\"}\n",
        "#   ]\n",
        "# end\n",
        "\n",
        "# cowboy の依存は開発時とテスト時にのみ必要\n",
        "\n",
        "# 依存しているパッケージの取り込みは bundle install に似たもの\n",
        "# mix deps.get"
      ],
      "metadata": {
        "id": "rKWaKRddlER1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!cd example/_build/test/lib/example/ebin; ./example.app #=> Permission denied\n",
        "# colab 環境ではアプリは起動できないと言う事か"
      ],
      "metadata": {
        "id": "rr6pkujImNmQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 環境 \n",
        "# Bundler に似て、様々な環境に対応している\n",
        "# mixは最初から 3 つの環境で動作するように構成されている\n",
        "\n",
        "# :dev - 初期状態での環境。\n",
        "# :test - mix testで用いられる環境。次のレッスンでさらに見ていきる\n",
        "# :prod - アプリケーションを製品に出荷するときに用いられる環境。\n",
        "\n",
        "# 現在の環境は Mix.env で取得することができる\n",
        "# この環境は MIX_ENV 環境変数によって変更することが出来る\n",
        "\n",
        "# MIX_ENV=prod mix compile"
      ],
      "metadata": {
        "id": "_ZUTk5Efn_di"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# シギル sigil"
      ],
      "metadata": {
        "id": "UB0cvUgao0AO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# シギル sigil とは elixir で文字列リテラルを取り扱うための特別の構文\n",
        "# チルダ ~ で始まる\n",
        "\n",
        "# シギルのリスト\n",
        "\n",
        "# ~C エスケープや埋め込みを含まない文字のリストを生成する\n",
        "# ~c エスケープや埋め込みを含む文字のリストを生成する\n",
        "# ~R エスケープや埋め込みを含まない正規表現を生成する\n",
        "# ~r エスケープや埋め込みを含む正規表現を生成する\n",
        "# ~S エスケープや埋め込みを含まない文字列を生成する\n",
        "# ~s エスケープや埋め込みを含む文字列を生成する\n",
        "# ~W エスケープや埋め込みを含まない単語のリストを生成する\n",
        "# ~w エスケープや埋め込みを含む単語のリストを生成する\n",
        "# ~N NaiveDateTime 構造体を生成する\n",
        "\n",
        "# デリミタのリスト\n",
        "\n",
        "# <...> カギ括弧のペア angle bracket\n",
        "# {...} 中括弧のペア brace\n",
        "# [...] 大括弧のペア bracket\n",
        "# (...) 小括弧のペア parenthesis\n",
        "# |...| パイプ記号のペア pipe\n",
        "# /.../ スラッシュのペア slash\n",
        "# \"...\" ダブルクォートのペア double quote\n",
        "# '...' シングルクォートのペア single quote"
      ],
      "metadata": {
        "id": "_Fcv8xWYolv9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 文字のリスト #=> tutorial と結果が違う!!!!\n",
        "!elixir -e 'IO.puts ~c/2 + 7 = #{ 2 + 7 }/'\n",
        "!elixir -e 'IO.puts ~C/2 + 7 = #{ 2 + 7 }/'"
      ],
      "metadata": {
        "id": "g6sI-_YVMc47",
        "outputId": "82b7d381-47b7-4821-ee8e-e1a06e467fa1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2 + 7 = #9\n",
            "2 + 7 = #9\n",
            "welcome to elixir school\n",
            "welcome to elixir #{String.downcase \"SCHOOL\"}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 正規表現 \n",
        "!elixir -e 'IO.puts 3 == 3'\n",
        "!elixir -e 'IO.puts \"Elixir\" =~ ~r/elixir/'\n",
        "!elixir -e 'IO.puts \"elixir\" =~ ~r/elixir/'\n",
        "!echo\n",
        "!elixir -e 'IO.puts \"Elixir\" =~ ~r/elixir/i'\n",
        "!elixir -e 'IO.puts \"elixir\" =~ ~r/elixir/i'"
      ],
      "metadata": {
        "id": "rIN9gL6_MtzO",
        "outputId": "208bde9a-c9ae-44e3-b089-703ac4dc23e1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "true\n",
            "false\n",
            "true\n",
            "\n",
            "true\n",
            "true\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Erlang の正規表現ライブラリを元に作られた Regex.split/2 を使う\n",
        "!elixir -e 'string=\"100_000_000\"; IO.inspect Regex.split(~r/_/, string)'"
      ],
      "metadata": {
        "id": "RvhrQqklNrQ4",
        "outputId": "f71e744c-2d51-4938-d7b1-e0f7e1a7a8aa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[\"100\", \"000\", \"000\"]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 文字列\n",
        "!elixir -e 'IO.puts ~s/welcome to elixir #{String.downcase \"SCHOOL\"}/'\n",
        "!elixir -e 'IO.puts ~S/welcome to elixir #{String.downcase \"SCHOOL\"}/'"
      ],
      "metadata": {
        "id": "kdtp52hoOpPM",
        "outputId": "3c4e6246-7e75-4aeb-d7d1-026eee45c13c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "welcome to elixir school\n",
            "welcome to elixir #{String.downcase \"SCHOOL\"}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 単語のリスト\n",
        "!elixir -e 'IO.inspect ~w/i love elixir school/'\n",
        "!elixir -e 'IO.inspect ~w/i love\\telixir school/'\n",
        "!elixir -e 'IO.inspect ~W/i love\\telixir school/'\n",
        "!elixir -e 'name=\"Bob\"; IO.inspect ~w/i love #{name}lixir school/'\n",
        "!elixir -e 'name=\"Bob\"; IO.inspect ~W/i love #{name}lixir school/'"
      ],
      "metadata": {
        "id": "39Nxi9laPspx",
        "outputId": "de217d0f-bf6b-455d-e196-d705ad3ec862",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[\"i\", \"love\", \"elixir\", \"school\"]\n",
            "[\"i\", \"love\", \"elixir\", \"school\"]\n",
            "[\"i\", \"love\\\\telixir\", \"school\"]\n",
            "[\"i\", \"love\", \"Boblixir\", \"school\"]\n",
            "[\"i\", \"love\", \"\\#{name}lixir\", \"school\"]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# NaiveDateTime \n",
        "# NaiveDateTime は タイムゾーンがない DateTime を表現する構造体を手早く作るときに有用\n",
        "# NaiveDateTime 構造体を直接作ることは避けるべき\n",
        "# パターンマッチングには有用\n",
        "!elixir -e 'IO.inspect NaiveDateTime.from_iso8601(\"2015-01-23 23:50:07\") == {:ok, ~N[2015-01-23 23:50:07]}'"
      ],
      "metadata": {
        "id": "3dJqUtCAj1eG",
        "outputId": "135d8f4a-633a-494d-c8aa-815c19b05c41",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "true\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# シギルを作る\n",
        "%%writefile temp.exs\n",
        "defmodule MySigils do\n",
        "  def sigil_u(string, []), do: String.upcase(string)\n",
        "end\n",
        "\n",
        "defmodule Main do\n",
        "    import MySigils\n",
        "    IO.puts (~u/elixir school/)\n",
        "end "
      ],
      "metadata": {
        "id": "uVHNOpX8lZ46",
        "outputId": "5055da28-2a3a-4016-f852-9e3b0ed3caee",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "YOdB1-LMmeO0",
        "outputId": "4fde151b-3c9a-47d7-ceb9-72a00a97ec59",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ELIXIR SCHOOL\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**ドキュメント**"
      ],
      "metadata": {
        "id": "UJnZj016nFYz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**インラインドキュメント用の属性**\n",
        "\n",
        "* @moduledoc - モジュールレベルのドキュメント用\n",
        "* @doc - 関数レベルのドキュメント用\n",
        "\n",
        "省略"
      ],
      "metadata": {
        "id": "3fnEUcgYoK88"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**テスト**\n",
        "\n",
        "ExUnit\n",
        "\n",
        "省略"
      ],
      "metadata": {
        "id": "zjUHotzgplFS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 内包表記"
      ],
      "metadata": {
        "id": "l8u3ccOasgVB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 内包表記 list comprehension\n",
        "# 内包表記は列挙体 enumerable をループするための糖衣構文である\n",
        "\n",
        "!elixir -e 'list=[1,2,3,4,5];IO.inspect for x <- list, do: x*x'"
      ],
      "metadata": {
        "id": "G1G3JlZOsYYq",
        "outputId": "1c430a09-73a2-47ee-c5d0-90ee62f78f93",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 4, 9, 16, 25]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# for とジェネレータの使い方に留意する\n",
        "# ジェネレータとは `x <- list` の部分\n",
        "# Haskell だと [x * x | x <- list] と書き、数学の集合での表記に近いが Elixir ではこのように書く\n",
        "# 内包表記はリストに限定されない\n",
        "\n",
        "# キーワードリスト\n",
        "!elixir -e 'IO.inspect for {_key, val} <- [one: 1, two: 2, three: 3], do: val'"
      ],
      "metadata": {
        "id": "aNpwWNpPaZ7i",
        "outputId": "52287396-1feb-47be-dc5d-b82033436331",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# マップ\n",
        "!elixir -e 'IO.inspect for {k, v} <- %{\"a\" => \"A\", \"b\" => \"B\"}, do: {k, v}'"
      ],
      "metadata": {
        "id": "JdckHtuWf7FL",
        "outputId": "1ac14cc6-e3ec-43c8-a9e7-47f459347f3d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[{\"a\", \"A\"}, {\"b\", \"B\"}]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# バイナリ\n",
        "!elixir -e 'IO.inspect for <<c <- \"hello\">>, do: <<c>>'"
      ],
      "metadata": {
        "id": "BNQPrzT4hgDS",
        "outputId": "f1aff522-7701-42b2-9e7c-eda570ec2f5b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[\"h\", \"e\", \"l\", \"l\", \"o\"]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# ジェネレータは入力値セットと左辺の変数を比較するのにパターンマッチングを利用している\n",
        "# マッチするものが見つからない場合には、値は無視される\n",
        "!elixir -e 'IO.inspect for {:ok, val} <- [ok: \"Hello\", error: \"Unknown\", ok: \"World\"], do: val'"
      ],
      "metadata": {
        "id": "1Dv-hbueul9U",
        "outputId": "8e088aba-bd11-48bd-e70f-65f4ce57ca09",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[\"Hello\", \"World\"]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 入れ子\n",
        "%%writefile temp.exs\n",
        "list = [1, 2, 3, 4]\n",
        "IO.inspect (\n",
        "    for n <- list, times <- 1..n do\n",
        "    String.duplicate(\"*\", times)\n",
        "    end\n",
        ")"
      ],
      "metadata": {
        "id": "86ztII9eEn2q",
        "outputId": "d1dd3af1-1c9a-4d7c-dc4a-61ac00e7caa4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Writing temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "slFDi06SFKc2",
        "outputId": "21810e5f-4424-43d1-e091-aa7cc9aa6f73",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[\"*\", \"*\", \"**\", \"*\", \"**\", \"***\", \"*\", \"**\", \"***\", \"****\"]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# ループの見える化\n",
        "!elixir -e 'list = [1, 2, 3, 4]; for n <- list, times <- 1..n, do: IO.puts  \"#{n} - #{times}\"'"
      ],
      "metadata": {
        "id": "WlYshc5DFHHF",
        "outputId": "bc78ce44-3b1a-47e7-90d9-c380bd80d7a8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 - 1\n",
            "2 - 1\n",
            "2 - 2\n",
            "3 - 1\n",
            "3 - 2\n",
            "3 - 3\n",
            "4 - 1\n",
            "4 - 2\n",
            "4 - 3\n",
            "4 - 4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# フィルタ\n",
        "!elixir -e 'import Integer; IO.inspect for x <- 1..10, is_even(x), do: x'"
      ],
      "metadata": {
        "id": "9XcIEOJAFw2J",
        "outputId": "ab10a3de-2b07-4c39-a35f-f4d0f770bd6b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 4, 6, 8, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 偶数かつ 3 で割り切れる値のみをフィルタ\n",
        "%%writefile temp.exs\n",
        "import Integer\n",
        "IO.inspect (\n",
        "    for x <- 1..100,\n",
        "        is_even(x),\n",
        "        rem(x, 3) == 0, do: x)"
      ],
      "metadata": {
        "id": "Mtu-mOqEG1xo",
        "outputId": "6ea22d45-c74f-4115-dac2-e355122f084b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "Mq1pf9N3Kzl-",
        "outputId": "8b8e65e7-107a-4447-900a-bf8851ceeb42",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# :into の使用\n",
        "# 他のものを生成したい場合\n",
        "# :into は Collectable プロトコルを実装している構造体を指定する\n",
        "\n",
        "# :into を用いて、キーワードリストからマップを作成する\n",
        "\n",
        "!elixir -e 'IO.inspect for {k, v} <- [one: 1, two: 2, three: 3], into: %{}, do: {k, v}'\n",
        "!elixir -e 'IO.inspect %{:one => 1, :three => 2, :two => 2}'\n",
        "!elixir -e 'IO.inspect %{\"one\" => 1, \"three\" => 2, \"two\" => 2}'\n",
        "\n",
        "# なるほど、と言うかわからなくて当然ですね。多分、Erlang の仕様を引き継いでこのようになっているのだろう\n",
        "# map では高速なプログラムができなくて、キーワードリストを作って、キーワードリストはリストでありマップなのだろう"
      ],
      "metadata": {
        "id": "kzeNx8rXKxS0",
        "outputId": "b93ad11f-167c-406e-bdc8-235e0a0ef0f9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "%{one: 1, three: 3, two: 2}\n",
            "%{one: 1, three: 2, two: 2}\n",
            "%{\"one\" => 1, \"three\" => 2, \"two\" => 2}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# ビット文字列 bitstring は列挙可能 enumerable なので、:into を用いて文字列を作成することが出来る\n",
        "!elixir -e \"IO.inspect for c <- [72, 101, 108, 108, 111], into: \\\"\\\", do: <<c>>\""
      ],
      "metadata": {
        "id": "RA0HDHLAqvxw",
        "outputId": "acbee029-f5a0-4096-eb3b-bc209cb49312",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\"Hello\"\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 文字列"
      ],
      "metadata": {
        "id": "4zLDYcN7xCAa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 文字列 string\n",
        "# elixir の文字列はバイトのシーケンスである\n",
        "!elixir -e 'string = <<104,101,108,108,111>>;IO.puts string'\n",
        "!elixir -e 'string = <<104,101,108,108,111>>;IO.inspect string'\n",
        "!elixir -e 'IO.inspect <<104,101,108,108,111>>'\n",
        "!echo\n",
        "# 文字列に 0 バイトを追加するとバイナリとして表示される\n",
        "!elixir -e 'IO.inspect <<104,101,108,108,111,0>>'"
      ],
      "metadata": {
        "id": "18LQnqpzwq5j",
        "outputId": "22551473-fcff-4663-9469-cd1f12610211",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello\n",
            "\"hello\"\n",
            "\"hello\"\n",
            "\n",
            "<<104, 101, 108, 108, 111, 0>>\n",
            "<<104, 101, 108, 108, 111, 0>>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 質問 文字列をバイナリ表示するにはどうするか\n",
        "!elixir -e 'IO.inspect \"hello\"<> <<0>>'"
      ],
      "metadata": {
        "id": "XNtMxkYTxIGV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 実験 日本語\n",
        "!elixir -e 'IO.inspect \"あ\"<> <<0>>' #=> <<227, 129, 130, 0>>\n",
        "!elixir -e 'IO.inspect <<227, 129, 130>>' #=> \"あ\""
      ],
      "metadata": {
        "id": "Gy1ypWovxDeh",
        "outputId": "92b9672e-4131-402e-bdad-1208901a978a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<<227, 129, 130, 0>>\n",
            "\"あ\"\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 文字リスト\n",
        "# elixir は文字列と別に文字リストという型を別に持っている\n",
        "# 文字列はダブルクオートで生成され、文字リストはシングルクオートで生成される\n",
        "# 文字リストは utf-8 で、文字列はバイナリである\n",
        "!elixir -e \"IO.inspect 'hello'\"\n",
        "!elixir -e \"IO.inspect 'hello' ++ [0]\"\n",
        "!elixir -e 'IO.inspect \"hello\"<> <<0>>'\n",
        "!echo\n",
        "!elixir -e \"IO.inspect 'hełło' ++ [0]\"\n",
        "!elixir -e 'IO.inspect \"hełło\"<> <<0>>'\n",
        "!echo\n",
        "!elixir -e \"IO.inspect 'あ' ++ [0]\"\n",
        "!elixir -e 'IO.inspect \"あ\"<> <<0>>'"
      ],
      "metadata": {
        "id": "5VB6NDnLiMYz",
        "outputId": "c820a766-b0e1-41be-b82b-ba9d8aad2ddb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "'hello'\n",
            "[104, 101, 108, 108, 111, 0]\n",
            "<<104, 101, 108, 108, 111, 0>>\n",
            "\n",
            "[104, 101, 322, 322, 111, 0]\n",
            "<<104, 101, 197, 130, 197, 130, 111, 0>>\n",
            "\n",
            "[12354, 0]\n",
            "<<227, 129, 130, 0>>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# クエスチョンマークによるコードポイントの取得\n",
        "# コードポイントは unicode なので 1 バイト以上のバイトである\n",
        "!elixir -e 'IO.inspect ?Z'\n",
        "!elixir -e 'IO.inspect ?あ'\n",
        "!elixir -e 'IO.inspect \"áñèane\" <> <<0>>'\n",
        "!elixir -e \"IO.inspect 'áñèane' ++ [0]\"\n",
        "!elixir -e \"IO.inspect 'あいう' ++ [0]\""
      ],
      "metadata": {
        "id": "9AAGG923x2YD",
        "outputId": "0e77eb57-5f73-438b-dd7e-4b807c707701",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "90\n",
            "12354\n",
            "<<195, 161, 195, 177, 195, 168, 97, 110, 101, 0>>\n",
            "[225, 241, 232, 97, 110, 101, 0]\n",
            "[12354, 12356, 12358, 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# シンボルには ? 表記が使える\n",
        "# elixir でプログラムする時は通常文字リストは使わず文字列を使う\n",
        "# 文字リストが必要なのは erlang のため\n",
        "# String モジュールにコードポイントを取得する関数 graphemes/1 と codepoints/1 がある\n",
        "!elixir -e 'string = \"\\u0061\\u0301\"; IO.puts string' #=> á\n",
        "!elixir -e 'string = \"\\u0061\\u0301\"; IO.inspect String.codepoints string'\n",
        "!elixir -e 'string = \"\\u0061\\u0301\"; IO.inspect String.graphemes string'"
      ],
      "metadata": {
        "id": "Hvg6YQE4ziH0",
        "outputId": "d28bad83-93c8-4de5-9b10-7e0762960068",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "á\n",
            "[\"a\", \"́\"]\n",
            "[\"á\"]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 下記の実験から á と あ は違う\n",
        "# á は graphemes では 1 文字だが codepoints では 2 文字\n",
        "# あ はどちらでも 1 文字\n",
        "!elixir -e 'string = \"あいう\"; IO.puts string' \n",
        "!elixir -e 'string = \"あいう\"; IO.inspect String.codepoints string'\n",
        "!elixir -e 'string = \"あいう\"; IO.inspect String.graphemes string'"
      ],
      "metadata": {
        "id": "UDie3OTA4E9e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dc96c045-5dab-4517-adc0-ed74a2a7e05b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "あいう\n",
            "[\"あ\", \"い\", \"う\"]\n",
            "[\"あ\", \"い\", \"う\"]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 文字列関数\n",
        "# length/1\n",
        "!elixir -e 'IO.puts String.length \"hello\"'\n",
        "!elixir -e 'IO.puts String.length \"あいう\"'\n",
        "# replace/3\n",
        "!elixir -e 'IO.puts String.replace(\"Hello\", \"e\", \"a\")'\n",
        "# duplicate/2\n",
        "!elixir -e 'IO.puts String.duplicate(\"Oh my \", 3)'\n",
        "# split/2\n",
        "!elixir -e 'IO.inspect String.split(\"Oh my \", \" \")'\n",
        "# split/1 # こちらが words 相当か\n",
        "!elixir -e 'IO.inspect String.split(\"Oh my \")'"
      ],
      "metadata": {
        "id": "UaUjeAiw3K3O",
        "outputId": "6668a6bf-88cb-4df3-c4ea-dd9d47af8946",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n",
            "3\n",
            "Hallo\n",
            "Oh my Oh my Oh my \n",
            "[\"Oh\", \"my\", \"\"]\n",
            "[\"Oh\", \"my\"]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 問題 アナグラムチェック\n",
        "# A = super\n",
        "# B = perus\n",
        "# 文字列 A を並び替えれば B に出来るので A は B のアナグラム\n",
        "%%writefile temp.exs\n",
        "defmodule Anagram do\n",
        "  def anagrams?(a, b) when is_binary(a) and is_binary(b) do\n",
        "    sort_string(a) == sort_string(b)\n",
        "  end\n",
        "\n",
        "  def sort_string(string) do\n",
        "    string\n",
        "    |> String.downcase()\n",
        "    |> String.graphemes()\n",
        "    |> Enum.sort()\n",
        "  end\n",
        "end\n",
        "\n",
        "defmodule Main do\n",
        "    IO.puts Anagram.anagrams?(\"Hello\", \"ohell\")\n",
        "    IO.puts Anagram.anagrams?(\"María\", \"íMara\")\n",
        "    IO.puts Anagram.anagrams?(3, 5) #=> エラー\n",
        "end "
      ],
      "metadata": {
        "id": "TBu1n_gF4uqo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1f260080-0bf8-4b3f-85bb-9d3386b1a026"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!elixir temp.exs"
      ],
      "metadata": {
        "id": "nXPds3LQ_dnR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 日付と時間"
      ],
      "metadata": {
        "id": "mR220zMiAMz9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 日付と時間\n",
        "# 現在時刻の取得\n",
        "!elixir -e 'IO.puts Time.utc_now' \n",
        "# シギルで Time 構造体を作る\n",
        "!elixir -e 'IO.puts ~T[21:00:27.472988]'\n",
        "# hour, minute, second\n",
        "!elixir -e 't = ~T[21:00:27.472988];IO.puts t.hour'\n",
        "!elixir -e 't = ~T[21:00:27.472988];IO.puts t.minute'\n",
        "!elixir -e 't = ~T[21:00:27.472988];IO.puts t.second'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zzylB9H4_bLx",
        "outputId": "d9ffd78f-c2a1-4c2b-e58c-39b0d442d676"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "21:10:05.960965\n",
            "21:00:27.472988\n",
            "21\n",
            "0\n",
            "27\n",
            "\n",
            "2022-03-22\n",
            "2022-03-22\n",
            "2020-12-12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Date\n",
        "!elixir -e 'IO.puts Date.utc_today' \n",
        "# シギルで Date 構造体を作る\n",
        "!elixir -e 'IO.puts ~D[2022-03-22]'\n",
        "#\n",
        "!elixir -e '{:ok, date} = Date.new(2020, 12,12); IO.puts date'\n",
        "!elixir -e '{:ok, date} = Date.new(2020, 12,12); IO.puts Date.day_of_week date'\n",
        "!elixir -e '{:ok, date} = Date.new(2020, 12,12); IO.puts Date.leap_year? date'\n",
        "!echo\n",
        "# NaiveDateTime Date と Time の両方を扱えるがタイムゾーンのサポートがない\n",
        "!elixir -e 'IO.puts NaiveDateTime.utc_now'\n",
        "!elixir -e 'IO.puts ~N[2022-03-22 21:14:23.371420]'\n",
        "!elixir -e 'IO.puts NaiveDateTime.add(~N[2022-03-22 21:14:23.371420],30)'\n",
        "!elixir -e 'IO.puts NaiveDateTime.add(~N[2022-03-22 21:14:23],30)'"
      ],
      "metadata": {
        "id": "71n9jtqvd2Qx",
        "outputId": "047863d9-d32f-4817-9eae-253f3f8be30c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2022-03-22\n",
            "2022-03-22\n",
            "2020-12-12\n",
            "6\n",
            "true\n",
            "\n",
            "2022-03-22 21:18:07.169008\n",
            "2022-03-22 21:14:23.371420\n",
            "2022-03-22 21:14:53.371420\n",
            "2022-03-22 21:14:53\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# DateTime\n",
        "# DateTime は Date と Time の両方を扱えタイムゾーンのサポートがある\n",
        "# しかし!!!! Elixir がデフォルトではタイムゾーンデータベースがない\n",
        "# デフォルトでは Calendar.get_time_zone_database/0 によって返されるタイムゾーンデータベースを使う\n",
        "# デフォルトでは Calendar.UTCOnlyTimeZoneDatabase で、Etc/UTC のみを処理し\n",
        "# 他のタイムゾーンでは {:error, :utc_only_time_zone_database} を返す\n",
        "# タイムゾーンを提供することにより NaiveDateTime から DateTimeのインスタンスを作ることができる\n",
        "!elixir -e 'IO.inspect DateTime.from_naive(~N[2016-05-24 13:26:08.003], \"Etc/UTC\")'"
      ],
      "metadata": {
        "id": "5F2APCUSfqL4",
        "outputId": "71def60c-e7bc-4f99-e365-95e5da0f2646",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{:ok, ~U[2016-05-24 13:26:08.003Z]}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# タイムゾーンの利用\n",
        "# elixir でタイムゾーンを利用するには tzdata パッケージをインストールし\n",
        "# Tzdata タイムゾーンデータベースとして使用する\n",
        "# パリのタイムゾーンで時間を作成してそれをニューヨーク時間に変換してみる\n",
        "# パリとニューヨークの時差は 6 時間である\n",
        "# %%writefile temp.exs\n",
        "# config :elixir, :time_zone_database, Tzdata.TimeZoneDatabase\n",
        "# paris_datetime = DateTime.from_naive!(~N[2019-01-01 12:00:00], \"Europe/Paris\")\n",
        "# {:ok, ny_datetime} = DateTime.shift_zone(paris_datetime, \"America/New_York\")\n",
        "# IO.inspect paris_datetime\n",
        "# IO.inspect ny_datetime"
      ],
      "metadata": {
        "id": "y28qnh13bkCj",
        "outputId": "673a8a59-e2dd-452f-c3b8-e0782c72d2a8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Overwriting temp.exs\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# カスタムMixタスク 省略"
      ],
      "metadata": {
        "id": "VXOwQrAjTo4v"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# いまここ"
      ],
      "metadata": {
        "id": "WOp4jHsnK61f"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# IEx Helpers 省略"
      ],
      "metadata": {
        "id": "8fgu3PNuUAG1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "dOw8gc25RjWK"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}