# lawful: Assert that your typeclass instances are lawful

## What is this package for?

This small library provides a single two-parameter typeclass `Lawful c t`

,
where `c`

is a typeclass and `t`

is a type. Declaring an instance of
`Lawful C T`

is an assertion that “the instance for `C T`

obeys the laws of
the class `C`

(whatever *that* means!)”

For example, a lawful instance of `Eq T`

should satisfy the reflexive
law `x == x`

for all `x :: T`

. This is certainly true for most types, such
as `Int`

or `[a]`

when `Eq a`

is lawful, so we can define

```
Lawful Eq Int
Lawful Eq a => Lawful Eq [a]
```

But it *isn’t* true for `Double`

:

```
λ> nan = 0 / 0 :: Double
λ> nan == nan
False
```

## Why is there a `c t`

constraint on `Lawful c t`

?

This constraint lets you use a `Lawful c t`

wherever a `c t`

would be expected,
as in:

```
same :: Lawful Eq a => a -> a -> Bool
same x y = x == y
```

## How do I know what laws are expected from a typeclass?

If everybody more-or-less agrees on what the right laws are, hopefully they bothered to
write them down somewhere. If they didn’t, then sorry! You’re on your own!

## Shouldn’t all typeclass instances be lawful anyway, making this package useless?

Wouldn’t that be nice?