pro_mode

defmodule ProMode do
  @moduledoc """
  Brevity is bliss.
            - APLJKQ

  Provides shortcuts for common Elixir functions.
  """

  @doc "Enum.map"
  def m(a, b), do: Enum.map(a, b)

  @doc "Enum.each"
  def e(a, b), do: Enum.each(a, b)

  @doc "Enum.join"
  def j(a, b), do: Enum.join(a, b)

  @doc "Enum.reduce"
  def r(a, b), do: Enum.reduce(a, b)

  @doc "Enum.reduce"
  def r(a, b, c), do: Enum.reduce(a, b, c)

  @doc "Enum.filter"
  def f(a, b), do: Enum.filter(a, b)

  @doc "Enum.reject"
  def f!(a, b), do: Enum.reject(a, b)

  @doc "Enum.at"
  def a(a, b), do: Enum.at(a, b)

  @doc "Enum.all?"
  def all?(a, b), do: Enum.all?(a, b)

  @doc "Enum.any?"
  def any?(a, b), do: Enum.any?(a, b)

  @doc "Enum.with_index"
  def wi(a), do: Enum.with_index(a)

  @doc "then"
  def t(a, b), do: then(a, b)

  @doc "Map.get"
  def mg(a, b), do: Map.get(a, b)

  @doc "Map.put"
  def mp(a, b, c), do: Map.put(a, b, c)

  @doc "Map.keys"
  def keys(a), do: Map.keys(a)

  @doc "Map.values"
  def vals(a), do: Map.values(a)

  @doc "IO.puts"
  def p(a), do: IO.puts(a)

  @doc "Enum.max"
  def max(a), do: Enum.max(a)

  @doc "Enum.min"
  def min(a), do: Enum.min(a)

  @doc "List.first"
  def lf(a), do: List.first(a)

  @doc "List.last"
  def ll(a), do: List.last(a)

  @doc "elem"
  def el(a, b), do: elem(a, b)

  @doc "Enum.reverse"
  def rv(a), do: Enum.reverse(a)

  @doc "Enum.concat"
  def cc(a, b), do: Enum.concat(a, b)

  @doc "Enum.find"
  def fd(a, b), do: Enum.find(a, b)

  @doc "Enum.zip"
  def zip(a, b), do: Enum.zip(a, b)

  @doc "Enum.unzip"
  def unzip(a), do: Enum.unzip(a)

  @doc "Keyword.get"
  def kwg(a, b), do: Keyword.get(a, b)

  @doc "Keyword.put"
  def kwp(a, b, c), do: Keyword.put(a, b, c)

  @doc "length"
  def l(a), do: length(a)

  @doc "Matrix transpose"
  def tpose(matrix) do
    r(matrix, %{}, fn row, acc ->
      r(wi(row), acc, fn {cell, i}, acc1 ->
        if col = mg(acc, i) do
          mp(acc1, i, [cell | col])
        else
          mp(acc1, i, [cell])
        end
      end)
    end)
    |> vals()
    |> m(&rv/1)
  end

  @doc "String.length"
  def sl(a), do: String.length(a)

  @doc "String.trim"
  def trim(a), do: String.trim(a)

  @doc "String.split"
  def split(a, b), do: String.split(a, b)
end