# Having

Haskell like `where` sugar for Elixir. A pipe-able `with` special form.

## Usage

```elixir
import Having
```

The `having` macro is a tiny syntax sugar around `with`. To make it work a bit
like the `where` keyword for Haskell, where you can have an expression and
then some bindings for evaling it on.

For example, the following Haskell code

```haskell
a + b
where
  a = 3
  b = a * a
```

Could be written in Elixir like:

```elixir
iex> a + b
...> |> having(a: 3, b: a * a)
12
```

that will be compiled into:

```elixir
with a = 3,
     b = a * a,
do: a + b
```

Every `having` gets rewritten into a corresponding `with` special form.
And thus can have its own `else:` clauses, guards on `<-` just like `with`.

For example if you pipe an expression into two `having`s:

```elixir
{a, b}
|> having(a = b * b)
|> having(b when b < 10 <- 2)
```

will get rewritten to:

```elixir
with(b when b < 10 <- 2) do
  with(a = b * b) do
    {a, b}
  end
end
```

Note that in the `having` example, the expression you want to compute
is the first thing you see, instead of it being nested inside `with` forms.
Also note that the most external `with` corresponds to the latest piped `having`
this is important if you need to have some values that depend on others.


For more examples look at the documentation of [having.ex](https://github.com/vic/having/blob/master/lib/having.ex)

## Installation

[Available in Hex](https://hex.pm/packages/having), the package can be installed as:

  1. Add `having` to your list of dependencies in `mix.exs`:

    ```elixir
    def deps do
      [{:having, "~> 0.1.0"}]
    end
    ```

  2. Ensure `having` is started before your application:

    ```elixir
    def application do
      [applications: [:having]]
    end
    ```