# lawful

Assert the lawfulness of your typeclass instances.

https://github.com/matt-noonan/lawful#readme

 LTS Haskell 22.34: 0.1.0.0 Stackage Nightly 2024-09-16: 0.1.0.0 Latest on Hackage: 0.1.0.0

See all snapshots `lawful` appears in

BSD-3-Clause licensed by
Maintained by
This version can be pinned in stack with:`lawful-0.1.0.0@sha256:d531511cdeeeb157ec4c8907dc529f546f28b8ab0a303b6c893b397ea7fa5f65,815`

#### Module documentation for 0.1.0.0

Depends on 1 package(full list with versions):
Used by 1 package in lts-21.7(full list with versions):

# 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?