Croma

Elixir macro utilities.

Usage

• Add :croma as a mix dependency.
• $ mix deps.get
• Add use Croma to import all macros defined in this package.
• Hack!

Defining functions

Croma.Defpt.defpt

• Unit-testable defp that is simply converted to
  • def if Mix.env == :test,
  • defp otherwise.

Croma.Defun

• Type specification oriented function definition

  • Example 1

    import Croma.Defun
    defun f(a: integer, b: String.t) :: String.t do
      "#{a} #{b}"
    end
    

  is expanded to ex @spec f(integer, String.t) :: String.t def f(a, b) do "#{a} #{b}" end

  • Example 2

    import Croma.Defun
    defun dumbmap(as: [a], f: (a -> b)) :: [b] when a: term, b: term do
      ([]     , _) -> []
      ([h | t], f) -> [f.(h) | dumbmap(t, f)]
    end
    

  is expanded to ex @spec dumbmap([a], (a -> b)) :: [b] when a: term, b: term def dumbmap(as, f) def dumbmap([], _) do [] end def dumbmap([h | t], f) do [f.(h) | dumbmap(t, f)] end
  • There are also defunp and defunpt macros for private functions.
  • Known limitations:
    • Pattern matching against function parameters should use (param1, param2) when guards -> block style.
    • Overloaded typespecs are not supported.

Croma.Monad

• An interface definition of the monad typeclass.

• Modules that use Croma.Monad must implement the following interface:

  • @type t(a) with a type parameter a.
  • @spec pure(a: a) :: t(a) when a: any
  • @spec bind(t(a), (a -> t(b))) :: t(b) when a: any, b: any

• By using the concrete implementations of the above interface, Croma.Monad provides the default implementations of the following functions:

  • As Functor:
    • @spec map(t(a), (a -> b)) :: t(b) when a: any, b: any
  • As Applicative:
    • @spec ap(t(a), t((a -> b))) :: t(b) when a: any, b: any
    • @spec sequence([t(a)]) :: t([a]) when a: any

• Note that the order of parameters in map/ap is different from that of Haskell counterparts, in order to leverage Elixir's pipe operator |>.

• Croma.Monad also provides bind-less syntax similar to Haskell's do-notation. For example,

  MonadImpl.m do
    x <- mx
    y <- my
    pure f(x, y)
  end
  

is converted to ex MonadImpl.bind(mx, fn x -> MonadImpl.bind(my, fn y -> MonadImpl.pure f(x, y) end) end)

Croma.Result

• Corma.Result.t(a) is defined as @type t(a) :: {:ok, a} | {:error, any}. This module implements Croma.Monad interface.

Croma.List

• Implementation of Croma.Monad for lists. Croma.List.t(a) is just an alias to [a].