SYMBOL INDEX (124 symbols across 16 files)

FILE: lib/algae.ex
  class Algae (line 1) | defmodule Algae

FILE: lib/algae/either.ex
  class Algae.Either (line 1) | defmodule Algae.Either

FILE: lib/algae/free.ex
  class Algae.Free (line 1) | defmodule Algae.Free
    method new (line 57) | def new(value), do: %Pure{pure: value}
    method layer (line 77) | def layer(free, mutual), do: %Roll{roll: of(mutual, free)}
    method wrap (line 93) | def wrap(functor), do: %Roll{roll: functor}
    method free (line 111) | def free(functor) do

FILE: lib/algae/id.ex
  class Algae.Id (line 1) | defmodule Algae.Id
    method new (line 26) | def new(inner), do: %Algae.Id{id: inner}

FILE: lib/algae/internal.ex
  class Algae.Internal (line 1) | defmodule Algae.Internal
    method data_ast (line 46) | def data_ast(modules, {:none, _, _}) do
    method data_ast (line 64) | def data_ast(caller_module, type) do
    method data_ast (line 88) | def data_ast(name, default, type_ctx) do
    method embedded_data_ast (line 112) | def embedded_data_ast do
    method embedded_data_ast (line 123) | def embedded_data_ast(module_ctx, default, type_ctx) do
    method module_elements (line 151) | def module_elements(lines, caller) do
    method normalize_elements (line 168) | def normalize_elements({:::, _, [{field, _, _}, type]}, caller) do
    method normalize_elements (line 173) | def normalize_elements({:\\, _, [{:::, _, [{field, _, _}, type]}, defa...
    method resolve_alias (line 178) | def resolve_alias({{_, _, _} = a, b, c}, caller) do
    method resolve_alias (line 182) | def resolve_alias({:. = a, b, [{:__aliases__, _, _} = the_alias | rest...
    method resolve_alias (line 187) | def resolve_alias(a, _), do: a
    method or_types (line 190) | def or_types({:\\, _, [{:::, _, [_, types]}, _]}, module_ctx) do
    method or_types (line 194) | def or_types([head | tail], module_ctx) do
    method modules (line 201) | def modules(top, module_ctx), do: [top | extract_name(module_ctx)]
    method call_type (line 204) | def call_type(new_module, module_ctx) do
    method submodule_name (line 211) | def submodule_name({:defdata, _, [{:::, _, [body, _]}]}) do
    method submodule_name (line 221) | def submodule_name({:defdata, _, [{:\\, _, [{:::, _, [{:__aliases__, _...
    method submodule_name (line 225) | def submodule_name({:defdata, _, [{:__aliases__, _, module}, _]}) do
    method extract_name (line 230) | def extract_name({_, _, inner_name}), do: List.wrap(inner_name)
    method module_to_field (line 239) | def module_to_field(module) do
    method default_value (line 250) | def default_value({{:., _, [{_, _, [:String]}, :t]}, _, _}), do: ""
    method default_value (line 251) | def default_value({{:., _, [String, :t]}, _, _}), do: ""
    method default_value (line 253) | def default_value({{:., _, [{_, _, adt}, :t]}, _, []}) do
    method default_value (line 257) | def default_value({{:., _, [module, :t]}, _, []}) do
    method default_value (line 261) | def default_value([_]), do: []
    method default_value (line 263) | def default_value({type, _, _}) do

FILE: lib/algae/internal/needs_explicit_default_error.ex
  class Algae.Internal.NeedsExplicitDefaultError (line 1) | defmodule Algae.Internal.NeedsExplicitDefaultError

FILE: lib/algae/maybe.ex
  class Algae.Maybe (line 1) | defmodule Algae.Maybe
    method new (line 71) | def new(nothing_value, [nothing: nothing_value]), do: Nothing.new()
    method new (line 72) | def new(value, _), do: Just.new(value)
    method new (line 75) | def new(value), do: Just.new(value)
    method from_nillable (line 90) | def from_nillable(value), do: new(value, nothing: nil)
    method from_maybe (line 105) | def from_maybe(%Nothing{}, [else: fallback]), do: fallback
    method from_maybe (line 106) | def from_maybe(%Just{just: inner}, _), do: inner

FILE: lib/algae/reader.ex
  class Algae.Reader (line 1) | defmodule Algae.Reader
    method new (line 54) | def new(fun), do: %Reader{reader: fun}
    method run (line 71) | def run(%Reader{reader: fun}, arg), do: fun.(arg)
    method ask (line 98) | def ask, do: Reader.new(fn x -> x end)
    method ask (line 128) | def ask(fun) do
    method local (line 151) | def local(reader, fun) do

FILE: lib/algae/state.ex
  class Algae.State (line 1) | defmodule Algae.State
    method default (line 79) | def default(s), do: {s, s}
    method new (line 92) | def new(runner), do: %State{runner: runner}
    method state (line 104) | def state(runner), do: new(runner)
    method run (line 120) | def run(%State{runner: fun}), do: fun
    method run (line 137) | def run(%State{runner: fun}, arg), do: fun.(arg)
    method put (line 153) | def put(s), do: State.new(fn _ -> {%Unit{}, s} end)
    method modify (line 181) | def modify(fun), do: State.new(fn s -> {%Unit{}, fun.(s)} end)
    method get (line 193) | def get, do: State.new(fn a -> {a, a} end)
    method get (line 208) | def get(fun) do
    method evaluate (line 233) | def evaluate(state, value) do
    method execute (line 262) | def execute(state, value) do

FILE: lib/algae/tree/binary_search.ex
  class Algae.Tree.BinarySearch (line 1) | defmodule Algae.Tree.BinarySearch
    method new (line 68) | def new, do: %Empty{}
    method new (line 84) | def new(value), do: %Node{node: value}
    method insert (line 101) | def insert(%Empty{}, value), do: new(value)
    method insert (line 103) | def insert(tree = %Node{node: node, left: left, right: right}, orderab...
    method insert (line 111) | def insert(%Empty{}, value), do: new(value)
    method insert (line 113) | def insert(tree = %Node{node: node, left: left, right: right}, orderab...
    method delete (line 152) | def delete(%Empty{}, _), do: %Empty{}
    method delete (line 154) | def delete(tree = %Node{node: node, left: left, right: right}, orderab...
    method to_list (line 192) | def to_list(tree), do: Witchcraft.Foldable.to_list(tree)
    method to_ordered_list (line 215) | def to_ordered_list(tree), do: tree |> to_list() |> Enum.sort()
    method from_list (line 241) | def from_list([]), do: %Empty{}
    method from_list (line 242) | def from_list([head | tail]), do: from_list(tail, new(head))
    method from_list (line 272) | def from_list([], seed), do: seed
    method from_list (line 273) | def from_list([head | tail], seed), do: from_list(tail, insert(seed, h...

FILE: lib/algae/tree/rose.ex
  class Algae.Tree.Rose (line 1) | defmodule Algae.Tree.Rose
    method new (line 52) | def new(rose), do: %Rose{rose: rose, forest: []}
    method new (line 70) | def new(rose, forest), do: %Rose{rose: rose, forest: forest}
    method layer (line 103) | def layer(tree, rose), do: %Rose{rose: rose, forest: [tree]}

FILE: lib/algae/writer.ex
  class Algae.Writer (line 1) | defmodule Algae.Writer
    method new (line 98) | def new(value \\ 0, log \\ []), do: %Writer{writer: {value, log}}
    method writer (line 110) | def writer({value, log}), do: new(value, log)
    method run (line 143) | def run(%Writer{writer: writer}), do: writer
    method tell (line 185) | def tell(log), do: new(%Unit{}, log)
    method listen (line 208) | def listen(%Writer{writer: {value, log}}), do: %Writer{writer: {{value...
    method listen (line 222) | def listen(writer, fun) do
    method pass (line 259) | def pass(%Writer{writer: {{value, fun}, log}}), do: %Writer{writer: {v...
    method censor (line 291) | def censor(writer, fun) do

FILE: mix.exs
  class Algae.Mixfile (line 1) | defmodule Algae.Mixfile
    method project (line 4) | def project do
    method aliases (line 26) | defp aliases do
    method elixirc_paths (line 35) | defp elixirc_paths(:test), do: ["lib", "test/support"]
    method elixirc_paths (line 36) | defp elixirc_paths(_), do: ["lib"]
    method deps (line 38) | defp deps do
    method docs (line 52) | defp docs do
    method package (line 61) | defp package do

FILE: test/algae_dsl_aliasing_test.exs
  class AlgaeDslAliasingTest.Base (line 1) | defmodule AlgaeDslAliasingTest.Base
  class A (line 6) | defmodule A
  class B (line 12) | defmodule B
  class C (line 18) | defmodule C

FILE: test/algae_test.exs
  class AlgaeTest (line 1) | defmodule AlgaeTest

FILE: test/support/example.ex
  class Example (line 3) | defmodule Example
  class Embedded.One (line 12) | defmodule Embedded.One
  class Embedded.Many (line 18) | defmodule Embedded.Many
  class Simple (line 33) | defmodule Simple
  class Sum.Lights (line 39) | defmodule Sum.Lights
  class Sum.Maybe (line 49) | defmodule Sum.Maybe
  class Player (line 61) | defmodule Player
    method attack (line 80) | def attack(player = %{experience: xp}, target = %{hit_points: hp}) do
  class Id (line 88) | defmodule Id
  class Person (line 96) | defmodule Person
  class Animal (line 105) | defmodule Animal
  class Constant (line 118) | defmodule Constant
    method new (line 123) | def new(value), do: %Constant{constant: fn _ -> value end}
  class Nothing (line 126) | defmodule Nothing
  class Light (line 132) | defmodule Light
    method from_number (line 150) | def from_number(1), do: %Light.Red{}
    method from_number (line 151) | def from_number(2), do: %Light.Yellow{}
    method from_number (line 152) | def from_number(3), do: %Light.Green{}
  class Pet (line 155) | defmodule Pet
  class Option (line 171) | defmodule Option
  class Media (line 183) | defmodule Media