diff --git a/Setup.hs b/Setup.hs
deleted file mode 100644
--- a/Setup.hs
+++ /dev/null
@@ -1,2 +0,0 @@
-import Distribution.Simple
-main = defaultMain
diff --git a/numhask.cabal b/numhask.cabal
--- a/numhask.cabal
+++ b/numhask.cabal
@@ -1,6 +1,6 @@
-cabal-version: 3.0
+cabal-version: 2.4
 name: numhask
-version: 0.5.0
+version: 0.6.0
 synopsis:
   numeric classes
 description:
@@ -25,7 +25,8 @@
   Simple
 
 extra-doc-files:
-  other/*.svg
+  other/*.svg,
+  readme.md
 
 source-repository head
   type:
@@ -38,6 +39,7 @@
   hs-source-dirs:
     src
   default-extensions:
+    NoImplicitPrelude
     NegativeLiterals
     OverloadedStrings
     UnicodeSyntax
@@ -48,7 +50,12 @@
     -Wincomplete-uni-patterns
     -Wredundant-constraints
   build-depends:
-    base >=4.7 && <5
+    base >=4.7 && <5,
+    protolude >=0.3 && <0.4,
+    bifunctors >= 3.2,
+    mmorph >= 1.1,
+    transformers >= 0.5,
+    text >= 1.2
   exposed-modules:
     NumHask.Algebra.Abstract
     NumHask.Algebra.Abstract.Action
@@ -59,7 +66,6 @@
     NumHask.Algebra.Abstract.Module
     NumHask.Algebra.Abstract.Multiplicative
     NumHask.Algebra.Abstract.Ring
-    NumHask.Algebra.Linear.Hadamard
     NumHask.Analysis.Metric
     NumHask.Data.Complex
     NumHask.Data.Integral
@@ -69,5 +75,6 @@
     NumHask.Data.Rational
     NumHask.Data.Wrapped
     NumHask.Exception
+    NumHask.Prelude
   other-modules:
   default-language: Haskell2010
diff --git a/readme.md b/readme.md
new file mode 100644
--- /dev/null
+++ b/readme.md
@@ -0,0 +1,41 @@
+numhask
+===
+
+[![Build Status](https://travis-ci.org/tonyday567/numhask.svg)](https://travis-ci.org/tonyday567/numhask) [![Gitter chat](https://badges.gitter.im/numhask/Lobby.png)](https://gitter.im/numhask/Lobby)
+
+A numeric class hierarchy, providing a structure for numbers and functions that combine them.
+
+Field hierarchy
+---
+
+[![Field Hierarchy](other/field.svg)](numhask/other/field.svg)
+
+
+NumHask class structure
+---
+
+[![NumHask Hierarchy](other/numhask.svg)](numhask/other/numhask.svg)
+
+
+`numhask` begins with separately named magma-derived classes for addition and multiplication, and then being symetrical in the treatment of the two heirarchies.  A short magma structure is provided with the intention of supplying appropriate classes for operators that are neither addition nor multiplication, but this structure is not hooked up to the main classes.
+
+To be as compatible as practical with the existing haskell ecosystem.  Ints, Integers, Floats, Doubles and Complex are taken from base and given numhask class instances, so they are also Num instances.  Monoid and Semigroup are not used in numhask to maintain compatability.
+
+`numhask` replaces all the relevant numeric operators in Prelude, so you're going to get clashes.
+
+QuickCheck tests of numeric laws are included.  This also includes tracking where laws are approximate or fail for non-exact numbers.
+
+The usual operators (+) and (*) operators are reserved for commutative relationships, with plus and times being used for non-commutative ones.
+
+In summary, the library doesn't do anything fancy. But if having to define `(*)` when you just want a `(+)` offends your sensibilities, it may bring some sanity.
+
+NumHask.Prelude
+---
+
+``` {.sourceCode .literate .haskell}
+{-# LANGUAGE NoImplicitPrelude #-}
+import NumHask.Prelude
+```
+
+'Numhask.Prelude' is designed as a drop-in replacement for Prelude and 'NoImplicitPrelude' is obligatory. Behind the scenes, the module wraps [protolude](https://www.stackage.org/package/protolude).
+
diff --git a/src/NumHask/Algebra/Abstract.hs b/src/NumHask/Algebra/Abstract.hs
--- a/src/NumHask/Algebra/Abstract.hs
+++ b/src/NumHask/Algebra/Abstract.hs
@@ -1,30 +1,29 @@
 {-# OPTIONS_GHC -Wall #-}
 
 -- | The abstract algebraic class structure of a number.
---
 module NumHask.Algebra.Abstract
   ( -- * Mapping from Num
     --
     -- $numMap
-    module NumHask.Algebra.Abstract.Group
-  , module NumHask.Algebra.Abstract.Additive
-  , module NumHask.Algebra.Abstract.Multiplicative
-  , module NumHask.Algebra.Abstract.Ring
-  , module NumHask.Algebra.Abstract.Field
-  , module NumHask.Algebra.Abstract.Module
-  , module NumHask.Algebra.Abstract.Action
-  , module NumHask.Algebra.Abstract.Lattice
+    module NumHask.Algebra.Abstract.Group,
+    module NumHask.Algebra.Abstract.Additive,
+    module NumHask.Algebra.Abstract.Multiplicative,
+    module NumHask.Algebra.Abstract.Ring,
+    module NumHask.Algebra.Abstract.Field,
+    module NumHask.Algebra.Abstract.Module,
+    module NumHask.Algebra.Abstract.Action,
+    module NumHask.Algebra.Abstract.Lattice,
   )
 where
 
-import NumHask.Algebra.Abstract.Group
+import NumHask.Algebra.Abstract.Action
 import NumHask.Algebra.Abstract.Additive
-import NumHask.Algebra.Abstract.Multiplicative
-import NumHask.Algebra.Abstract.Ring
 import NumHask.Algebra.Abstract.Field
-import NumHask.Algebra.Abstract.Module
-import NumHask.Algebra.Abstract.Action
+import NumHask.Algebra.Abstract.Group
 import NumHask.Algebra.Abstract.Lattice
+import NumHask.Algebra.Abstract.Module
+import NumHask.Algebra.Abstract.Multiplicative
+import NumHask.Algebra.Abstract.Ring
 
 -- $numMap
 --
@@ -69,4 +68,3 @@
 -- >    fromInteger         :: Integer -> a
 --
 -- `fromInteger` is given its own class `FromInteger`
---
diff --git a/src/NumHask/Algebra/Abstract/Action.hs b/src/NumHask/Algebra/Abstract/Action.hs
--- a/src/NumHask/Algebra/Abstract/Action.hs
+++ b/src/NumHask/Algebra/Abstract/Action.hs
@@ -5,12 +5,13 @@
 
 -- | Action
 module NumHask.Algebra.Abstract.Action
-  ( Actor
-  , AdditiveAction(..)
-  , SubtractiveAction(..)
-  , MultiplicativeAction(..)
-  , DivisiveAction(..)
-  ) where
+  ( Actor,
+    AdditiveAction (..),
+    SubtractiveAction (..),
+    MultiplicativeAction (..),
+    DivisiveAction (..),
+  )
+where
 
 import NumHask.Algebra.Abstract.Additive
 import NumHask.Algebra.Abstract.Multiplicative
@@ -18,7 +19,8 @@
 -- | a type class to represent an action on elements of a higher-kinded number
 type family Actor h
 
-class (Additive (Actor h)) =>
+class
+  (Additive (Actor h)) =>
   AdditiveAction h where
   infixl 6 .+
   (.+) :: h -> Actor h -> h
@@ -26,7 +28,8 @@
   infixl 6 +.
   (+.) :: Actor h -> h -> h
 
-class (Subtractive (Actor h)) =>
+class
+  (Subtractive (Actor h)) =>
   SubtractiveAction h where
   infixl 6 .-
   (.-) :: h -> Actor h -> h
@@ -34,14 +37,16 @@
   infixl 6 -.
   (-.) :: Actor h -> h -> h
 
-class (Multiplicative (Actor h)) =>
+class
+  (Multiplicative (Actor h)) =>
   MultiplicativeAction h where
   infixl 7 .*
   (.*) :: h -> Actor h -> h
   infixl 7 *.
   (*.) :: Actor h -> h -> h
 
-class (Divisive (Actor h)) =>
+class
+  (Divisive (Actor h)) =>
   DivisiveAction h where
   infixl 7 ./
   (./) :: h -> Actor h -> h
diff --git a/src/NumHask/Algebra/Abstract/Additive.hs b/src/NumHask/Algebra/Abstract/Additive.hs
--- a/src/NumHask/Algebra/Abstract/Additive.hs
+++ b/src/NumHask/Algebra/Abstract/Additive.hs
@@ -2,16 +2,16 @@
 
 -- | Additive
 module NumHask.Algebra.Abstract.Additive
-  ( Additive(..)
-  , sum
-  , Subtractive(..)
+  ( Additive (..),
+    sum,
+    Subtractive (..),
   )
 where
 
-import Data.Int (Int8, Int16, Int32, Int64)
-import Data.Word (Word, Word8, Word16, Word32, Word64)
-import GHC.Natural (Natural(..))
-import Prelude (Int, Integer, Float, Double, Bool)
+import Data.Int (Int16, Int32, Int64, Int8)
+import Data.Word (Word, Word16, Word32, Word64, Word8)
+import GHC.Natural (Natural (..))
+import Prelude (Bool, Double, Float, Int, Integer)
 import qualified Prelude as P
 
 -- | For practical reasons, 'Additive' has no super classes. Using `Associative` and 'Unital' from this library, or using 'Semigroup' and 'Monoid' from base tends to complexify the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication.
@@ -149,9 +149,8 @@
 instance Subtractive Word64 where
   negate = P.negate
 
-
 instance Additive b => Additive (a -> b) where
-  f + f' = \a -> f a + f' a 
+  f + f' = \a -> f a + f' a
   zero _ = zero
 
 instance Subtractive b => Subtractive (a -> b) where
diff --git a/src/NumHask/Algebra/Abstract/Field.hs b/src/NumHask/Algebra/Abstract/Field.hs
--- a/src/NumHask/Algebra/Abstract/Field.hs
+++ b/src/NumHask/Algebra/Abstract/Field.hs
@@ -1,21 +1,20 @@
 {-# LANGUAGE DefaultSignatures #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeApplications #-}
-{-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE TypeSynonymInstances #-}
 {-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications #-}
 {-# OPTIONS_GHC -Wall #-}
 
 -- | Field classes
 module NumHask.Algebra.Abstract.Field
-  ( Field
-  , ExpField(..)
-  , QuotientField(..)
-  , UpperBoundedField(..)
-  , LowerBoundedField(..)
-  , TrigField(..)
-  , half
+  ( Field,
+    ExpField (..),
+    QuotientField (..),
+    UpperBoundedField (..),
+    LowerBoundedField (..),
+    TrigField (..),
+    half,
   )
 where
 
@@ -24,8 +23,8 @@
 import NumHask.Algebra.Abstract.Multiplicative
 import NumHask.Algebra.Abstract.Ring
 import NumHask.Data.Integral
-import qualified Prelude as P
 import Prelude ((.))
+import qualified Prelude as P
 
 -- | A <https://en.wikipedia.org/wiki/Field_(mathematics) Field> is a set
 --   on which addition, subtraction, multiplication, and division are defined. It is also assumed that multiplication is distributive over addition.
@@ -52,8 +51,9 @@
 -- > recip a = one / a
 -- > recip a * a = one
 -- > a * recip a = one
-class (Distributive a, Subtractive a, Divisive a) =>
-      Field a
+class
+  (Distributive a, Subtractive a, Divisive a) =>
+  Field a
 
 instance Field P.Double
 
@@ -66,8 +66,9 @@
 -- > sqrt . (**2) == identity
 -- > log . exp == identity
 -- > for +ive b, a != 0,1: a ** logBase a b ≈ b
-class (Field a) =>
-      ExpField a where
+class
+  (Field a) =>
+  ExpField a where
   exp :: a -> a
   log :: a -> a
   logBase :: a -> a -> a
@@ -101,29 +102,30 @@
   properFraction :: a -> (b, a)
 
   round :: a -> b
-  default round ::(P.Ord a, P.Ord b, Subtractive b, Integral b) => a -> b
+  default round :: (P.Ord a, P.Ord b, Subtractive b, Integral b) => a -> b
   round x = case properFraction x of
-    (n,r) -> let
-      m         = bool (n+one) (n-one) (r P.< zero)
-      half_down = abs' r - (one/(one+one))
-      abs' a
-        | a P.< zero = negate a
-        | P.otherwise = a
-      in
-        case P.compare half_down zero of
-          P.LT -> n
-          P.EQ -> bool m n (even n)
-          P.GT -> m
+    (n, r) ->
+      let m = bool (n + one) (n - one) (r P.< zero)
+          half_down = abs' r - (one / (one + one))
+          abs' a
+            | a P.< zero = negate a
+            | P.otherwise = a
+       in case P.compare half_down zero of
+            P.LT -> n
+            P.EQ -> bool m n (even n)
+            P.GT -> m
 
   ceiling :: a -> b
   default ceiling :: (P.Ord a) => a -> b
-  ceiling x = bool n (n+one) (r P.>= zero)
-    where (n,r) = properFraction x
+  ceiling x = bool n (n + one) (r P.>= zero)
+    where
+      (n, r) = properFraction x
 
   floor :: a -> b
   default floor :: (P.Ord a, Subtractive b) => a -> b
-  floor x = bool n (n-one) (r P.< zero)
-    where (n,r) = properFraction x
+  floor x = bool n (n - one) (r P.< zero)
+    where
+      (n, r) = properFraction x
 
   truncate :: a -> b
   default truncate :: (P.Ord a) => a -> b
@@ -137,7 +139,7 @@
 
 instance QuotientField b c => QuotientField (a -> b) (a -> c) where
   properFraction f = (P.fst . frac, P.snd . frac)
-     where
+    where
       frac a = properFraction @b @c (f a)
 
   round f = round . f
@@ -155,9 +157,9 @@
 -- > zero / zero != nan
 --
 -- Note the tricky law that, although nan is assigned to zero/zero, they are never-the-less not equal. A committee decided this.
-class (Field a) =>
-      UpperBoundedField a where
-
+class
+  (Field a) =>
+  UpperBoundedField a where
   infinity :: a
   infinity = one / zero
 
@@ -172,9 +174,9 @@
   infinity _ = infinity
   nan _ = nan
 
-class (Subtractive a, Field a) =>
-      LowerBoundedField a where
-
+class
+  (Subtractive a, Field a) =>
+  LowerBoundedField a where
   negInfinity :: a
   negInfinity = negate (one / zero)
 
@@ -186,8 +188,9 @@
   negInfinity _ = negInfinity
 
 -- | Trigonometric Field
-class (Field a) =>
-      TrigField a where
+class
+  (Field a) =>
+  TrigField a where
   pi :: a
   sin :: a -> a
   cos :: a -> a
diff --git a/src/NumHask/Algebra/Abstract/Group.hs b/src/NumHask/Algebra/Abstract/Group.hs
--- a/src/NumHask/Algebra/Abstract/Group.hs
+++ b/src/NumHask/Algebra/Abstract/Group.hs
@@ -4,21 +4,22 @@
 
 -- | The Group hierarchy
 module NumHask.Algebra.Abstract.Group
-  ( Magma(..)
-  , Unital(..)
-  , Associative
-  , Commutative
-  , Absorbing(..)
-  , Invertible(..)
-  , Idempotent
-  , Group
-  , AbelianGroup
+  ( Magma (..),
+    Unital (..),
+    Associative,
+    Commutative,
+    Absorbing (..),
+    Invertible (..),
+    Idempotent,
+    Group,
+    AbelianGroup,
   )
 where
 
 import Prelude
 
 -- * Magma structure
+
 -- | A <https://en.wikipedia.org/wiki/Magma_(algebra) Magma> is a tuple (T,magma) consisting of
 --
 -- - a type a, and
@@ -36,8 +37,6 @@
 -- > ∀ a, b ∈ T: a magma b ∈ T
 --
 -- These laws are true by construction in haskell: the type signature of 'magma' and the above mathematical laws are synonyms.
---
---
 class Magma a where
   magma :: a -> a -> a
 
@@ -51,8 +50,8 @@
 --
 -- > unit magma a = a
 -- > a magma unit = a
---
-class Magma a =>
+class
+  Magma a =>
   Unital a where
   unit :: a
 
@@ -63,7 +62,8 @@
 -- | An Associative Magma
 --
 -- > (a magma b) magma c = a magma (b magma c)
-class Magma a =>
+class
+  Magma a =>
   Associative a
 
 instance Associative b => Associative (a -> b)
@@ -72,7 +72,8 @@
 -- <https://en.wikipedia.org/wiki/Commutative_property commutative>.
 --
 -- > a magma b = b magma a
-class Magma a =>
+class
+  Magma a =>
   Commutative a
 
 instance Commutative b => Commutative (a -> b)
@@ -80,8 +81,8 @@
 -- | An Invertible Magma
 --
 -- > ∀ a,b ∈ T: inv a `magma` (a `magma` b) = b = (b `magma` a) `magma` inv a
---
-class Magma a =>
+class
+  Magma a =>
   Invertible a where
   inv :: a -> a
 
@@ -92,13 +93,15 @@
 -- | A <https://en.wikipedia.org/wiki/Group_(mathematics) Group> is a
 --   Associative, Unital and Invertible Magma.
 class (Associative a, Unital a, Invertible a) => Group a
+
 instance (Associative a, Unital a, Invertible a) => Group a
 
 -- | An Absorbing is a Magma with an
 --   <https://en.wikipedia.org/wiki/Absorbing_element Absorbing Element>
 --
 -- > a `times` absorb = absorb
-class Magma a =>
+class
+  Magma a =>
   Absorbing a where
   absorb :: a
 
@@ -110,7 +113,8 @@
 --   <https://en.wikipedia.org/wiki/Idempotence Idempotent>.
 --
 -- > a magma a = a
-class Magma a =>
+class
+  Magma a =>
   Idempotent a
 
 instance Idempotent b => Idempotent (a -> b)
@@ -119,4 +123,5 @@
 --   Associative, Unital, Invertible and Commutative Magma . In other words, it
 --   is a Commutative Group
 class (Associative a, Unital a, Invertible a, Commutative a) => AbelianGroup a
+
 instance (Associative a, Unital a, Invertible a, Commutative a) => AbelianGroup a
diff --git a/src/NumHask/Algebra/Abstract/Lattice.hs b/src/NumHask/Algebra/Abstract/Lattice.hs
--- a/src/NumHask/Algebra/Abstract/Lattice.hs
+++ b/src/NumHask/Algebra/Abstract/Lattice.hs
@@ -4,10 +4,19 @@
 
 module NumHask.Algebra.Abstract.Lattice where
 
-import Data.Int (Int8, Int16, Int32, Int64)
-import Data.Word (Word8, Word16, Word32, Word64)
-import GHC.Natural (Natural(..))
+import Data.Int (Int16, Int32, Int64, Int8)
+import Data.Word (Word16, Word32, Word64, Word8)
+import GHC.Natural (Natural (..))
 import NumHask.Algebra.Abstract.Field
+import Data.Bool
+import Data.Eq
+import GHC.Float (Float, Double)
+import GHC.Int (Int)
+import GHC.Num (Integer)
+import GHC.Word (Word)
+import Data.Ord (Ord(..))
+import GHC.Enum (Bounded(..))
+import Data.Function (const)
 
 -- | A algebraic structure with element joins: <http://en.wikipedia.org/wiki/Semilattice>
 --
@@ -15,8 +24,8 @@
 -- > Commutativity: x \/ y == y \/ x
 -- > Idempotency:   x \/ x == x
 class (Eq a) => JoinSemiLattice a where
-    infixr 5 \/
-    (\/) :: a -> a -> a
+  infixr 5 \/
+  (\/) :: a -> a -> a
 
 -- | The partial ordering induced by the join-semilattice structure
 joinLeq :: (JoinSemiLattice a) => a -> a -> Bool
@@ -28,8 +37,8 @@
 -- > Commutativity: x /\ y == y /\ x
 -- > Idempotency:   x /\ x == x
 class (Eq a) => MeetSemiLattice a where
-    infixr 6 /\
-    (/\) :: a -> a -> a
+  infixr 6 /\
+  (/\) :: a -> a -> a
 
 -- | The partial ordering induced by the meet-semilattice structure
 meetLeq :: (MeetSemiLattice a) => a -> a -> Bool
@@ -40,22 +49,24 @@
 --
 -- > Absorption: a \/ (a /\ b) == a /\ (a \/ b) == a
 class (JoinSemiLattice a, MeetSemiLattice a) => Lattice a
+
 instance (JoinSemiLattice a, MeetSemiLattice a) => Lattice a
 
 -- | A join-semilattice with an identity element 'bottom' for '\/'.
 --
 -- > Identity: x \/ bottom == x
 class JoinSemiLattice a => BoundedJoinSemiLattice a where
-    bottom :: a
+  bottom :: a
 
 -- | A meet-semilattice with an identity element 'top' for '/\'.
 --
 -- > Identity: x /\ top == x
 class MeetSemiLattice a => BoundedMeetSemiLattice a where
-    top :: a
+  top :: a
 
 -- | Lattices with both bounds
 class (JoinSemiLattice a, MeetSemiLattice a, BoundedJoinSemiLattice a, BoundedMeetSemiLattice a) => BoundedLattice a
+
 instance (JoinSemiLattice a, MeetSemiLattice a, BoundedJoinSemiLattice a, BoundedMeetSemiLattice a) => BoundedLattice a
 
 instance JoinSemiLattice Float where
@@ -149,10 +160,10 @@
   (/\) = max
 
 instance (Eq (a -> b), JoinSemiLattice b) => JoinSemiLattice (a -> b) where
-  f \/ f' = \a -> f a \/ f' a 
+  f \/ f' = \a -> f a \/ f' a
 
 instance (Eq (a -> b), MeetSemiLattice b) => MeetSemiLattice (a -> b) where
-  f /\ f' = \a -> f a /\ f' a 
+  f /\ f' = \a -> f a /\ f' a
 
 -- from here
 
@@ -242,7 +253,3 @@
 
 instance (Eq (a -> b), BoundedMeetSemiLattice b) => BoundedMeetSemiLattice (a -> b) where
   top = const top
-
-
-
-
diff --git a/src/NumHask/Algebra/Abstract/Module.hs b/src/NumHask/Algebra/Abstract/Module.hs
--- a/src/NumHask/Algebra/Abstract/Module.hs
+++ b/src/NumHask/Algebra/Abstract/Module.hs
@@ -4,11 +4,12 @@
 
 -- | Algebra for Modules
 module NumHask.Algebra.Abstract.Module
-  ( Module
-  ) where
+  ( Module,
+  )
+where
 
-import NumHask.Algebra.Abstract.Ring
 import NumHask.Algebra.Abstract.Action
+import NumHask.Algebra.Abstract.Ring
 
 -- | A <https://en.wikipedia.org/wiki/Module_(mathematics) Module> over r a is
 --   a (Ring a), an abelian (Group r a) and a scalar multiplier (.*, *.) with the
diff --git a/src/NumHask/Algebra/Abstract/Multiplicative.hs b/src/NumHask/Algebra/Abstract/Multiplicative.hs
--- a/src/NumHask/Algebra/Abstract/Multiplicative.hs
+++ b/src/NumHask/Algebra/Abstract/Multiplicative.hs
@@ -2,16 +2,16 @@
 
 -- | Multiplicative
 module NumHask.Algebra.Abstract.Multiplicative
-  ( Multiplicative(..)
-  , product
-  , Divisive(..)
+  ( Multiplicative (..),
+    product,
+    Divisive (..),
   )
 where
 
-import Data.Int (Int8, Int16, Int32, Int64)
-import Data.Word (Word, Word8, Word16, Word32, Word64)
-import GHC.Natural (Natural(..))
-import Prelude (Int, Integer, Float, Double)
+import Data.Int (Int16, Int32, Int64, Int8)
+import Data.Word (Word, Word16, Word32, Word64, Word8)
+import GHC.Natural (Natural (..))
+import Prelude (Double, Float, Int, Integer)
 import qualified Prelude as P
 
 -- | For practical reasons, 'Multiplicative' has no super classes. Using 'Associative' and 'Unital' from this library, or using 'Semigroup' and 'Monoid' from base tends to complexify the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication.
@@ -23,7 +23,6 @@
 --
 -- By convention, (*) is regarded as commutative, but this is not universal, and the introduction of another symbol which means non-commutative multiplication seems a bit dogmatic.
 class Multiplicative a where
-
   infixl 7 *
   (*) :: a -> a -> a
 
@@ -83,6 +82,7 @@
 instance Multiplicative Int16 where
   (*) = (P.*)
   one = 1
+
 instance Multiplicative Int32 where
   (*) = (P.*)
   one = 1
@@ -112,7 +112,7 @@
   one = 1
 
 instance Multiplicative b => Multiplicative (a -> b) where
-  f * f' = \a -> f a * f' a 
+  f * f' = \a -> f a * f' a
   one _ = one
 
 instance Divisive b => Divisive (a -> b) where
diff --git a/src/NumHask/Algebra/Abstract/Ring.hs b/src/NumHask/Algebra/Abstract/Ring.hs
--- a/src/NumHask/Algebra/Abstract/Ring.hs
+++ b/src/NumHask/Algebra/Abstract/Ring.hs
@@ -4,20 +4,20 @@
 
 -- | Ring
 module NumHask.Algebra.Abstract.Ring
-  ( Distributive
-  , Semiring
-  , Ring
-  , IntegralDomain
-  , StarSemiring(..)
-  , KleeneAlgebra
-  , InvolutiveRing(..)
-  , two
+  ( Distributive,
+    Semiring,
+    Ring,
+    IntegralDomain,
+    StarSemiring (..),
+    KleeneAlgebra,
+    InvolutiveRing (..),
+    two,
   )
 where
 
-import Data.Int (Int8, Int16, Int32, Int64)
-import Data.Word (Word, Word8, Word16, Word32, Word64)
-import GHC.Natural (Natural(..))
+import Data.Int (Int16, Int32, Int64, Int8)
+import Data.Word (Word, Word16, Word32, Word64, Word8)
+import GHC.Natural (Natural (..))
 import NumHask.Algebra.Abstract.Additive
 import NumHask.Algebra.Abstract.Group
 import NumHask.Algebra.Abstract.Multiplicative
@@ -31,46 +31,68 @@
 -- > a * zero == zero
 --
 -- The sneaking in of the <https://en.wikipedia.org/wiki/Absorbing_element annihilation> laws here glosses over the possibility that the multiplicative zero element does not have to correspond with the additive unital zero.
-class (Additive a, Multiplicative a) =>
+class
+  (Additive a, Multiplicative a) =>
   Distributive a
 
 instance Distributive P.Double
+
 instance Distributive P.Float
+
 instance Distributive P.Int
+
 instance Distributive P.Integer
+
 instance Distributive Natural
+
 instance Distributive Int8
+
 instance Distributive Int16
+
 instance Distributive Int32
+
 instance Distributive Int64
+
 instance Distributive Word
+
 instance Distributive Word8
+
 instance Distributive Word16
+
 instance Distributive Word32
+
 instance Distributive Word64
+
 instance Distributive P.Bool
+
 instance Distributive b => Distributive (a -> b)
 
 -- | A <https://en.wikipedia.org/wiki/Semiring Semiring> is commutative monoidal under addition, has a monoidal multiplication operator (not necessarily commutative), and where multiplication distributes over addition.
-class (Distributive a) =>
-  Semiring a where
-instance (Distributive a) =>
+class
+  (Distributive a) =>
   Semiring a
 
+instance
+  (Distributive a) =>
+  Semiring a
+
 -- | A <https://en.wikipedia.org/wiki/Ring_(mathematics) Ring> is an abelian
 --   group under addition and monoidal under multiplication, and where multiplication
 --   distributes over addition.
-class (Distributive a, Subtractive a) =>
+class
+  (Distributive a, Subtractive a) =>
   Ring a
-instance (Distributive a, Subtractive a) =>
+
+instance
+  (Distributive a, Subtractive a) =>
   Ring a
 
 -- | An <https://en.wikipedia.org/wiki/Integral_domain Integral Domain>
 --   generalizes a ring of integers by requiring the product of any two nonzero
 --   elements to be nonzero. This means that if a ≠ 0, an equality ab = ac
 --   implies b = c.
---
-class (Distributive a) =>
+class
+  (Distributive a) =>
   IntegralDomain a
 
 instance IntegralDomain P.Double
@@ -83,7 +105,6 @@
 --   is a semiring with an additional unary operator star satisfying:
 --
 -- > star a = one + a `times` star a
---
 class (Distributive a) => StarSemiring a where
   star :: a -> a
   star a = one + plus a
@@ -98,7 +119,6 @@
 --
 -- > a `times` x + x = a ==> star a `times` x + x = x
 -- > x `times` a + x = a ==> x `times` star a + x = x
---
 class (StarSemiring a, Idempotent a) => KleeneAlgebra a
 
 instance KleeneAlgebra b => KleeneAlgebra (a -> b)
@@ -111,25 +131,38 @@
 -- > adj (adj a) ==> a
 --
 -- Note: elements for which @adj a == a@ are called "self-adjoint".
---
 class (Distributive a) => InvolutiveRing a where
   adj :: a -> a
   adj x = x
 
 instance InvolutiveRing P.Double
+
 instance InvolutiveRing P.Float
+
 instance InvolutiveRing P.Integer
+
 instance InvolutiveRing P.Int
+
 instance InvolutiveRing Natural
+
 instance InvolutiveRing Int8
+
 instance InvolutiveRing Int16
+
 instance InvolutiveRing Int32
+
 instance InvolutiveRing Int64
+
 instance InvolutiveRing Word
+
 instance InvolutiveRing Word8
+
 instance InvolutiveRing Word16
+
 instance InvolutiveRing Word32
+
 instance InvolutiveRing Word64
+
 instance InvolutiveRing b => InvolutiveRing (a -> b)
 
 -- | Defining 'two' requires adding the multiplicative unital to itself.
diff --git a/src/NumHask/Algebra/Linear/Hadamard.hs b/src/NumHask/Algebra/Linear/Hadamard.hs
deleted file mode 100644
--- a/src/NumHask/Algebra/Linear/Hadamard.hs
+++ /dev/null
@@ -1,39 +0,0 @@
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# OPTIONS_GHC -Wall #-}
-
--- | Element-by-element operations
-module NumHask.Algebra.Linear.Hadamard
-  ( HadamardMultiplication(..)
-  , HadamardDivision(..)
-  , Hadamard
-  )
-where
-
-import NumHask.Algebra.Abstract.Multiplicative
-
--- | element by element multiplication
---
--- > (a .*. b) .*. c == a .*. (b .*. c)
--- > singleton one .*. a = a
--- > a .*. singleton one = a
--- > a .*. b == b .*. a
-class (Multiplicative a) =>
-  HadamardMultiplication m a where
-  infixl 7 .*.
-  (.*.) :: m a -> m a -> m a
-
-
--- | element by element division
---
--- > a ./. a == singleton one
-class (Divisive a) =>
-  HadamardDivision m a where
-  infixl 7 ./.
-  (./.) :: m a -> m a -> m a
-
-class (HadamardMultiplication m a, HadamardDivision m a) => Hadamard m a
-instance (HadamardMultiplication m a, HadamardDivision m a) => Hadamard m a
-
diff --git a/src/NumHask/Analysis/Metric.hs b/src/NumHask/Analysis/Metric.hs
--- a/src/NumHask/Analysis/Metric.hs
+++ b/src/NumHask/Analysis/Metric.hs
@@ -4,35 +4,35 @@
 
 -- | Metric classes
 module NumHask.Analysis.Metric
-  ( Signed(..)
-  , Normed(..)
-  , Metric(..)
-  , Epsilon(..)
-  , (~=)
+  ( Signed (..),
+    Normed (..),
+    Metric (..),
+    Epsilon (..),
+    (~=),
   )
 where
 
-import qualified Prelude as P
-import Prelude
-  hiding ( Bounded(..)
-  , Integral(..)
-  , (-)
-  , negate
-  )
-
-import Data.Int (Int8, Int16, Int32, Int64)
-import Data.Word (Word8, Word16, Word32, Word64)
-import GHC.Natural (Natural(..))
+import Data.Int (Int16, Int32, Int64, Int8)
+import Data.Word (Word16, Word32, Word64, Word8)
+import GHC.Natural (Natural (..))
 import NumHask.Algebra.Abstract.Additive
-import NumHask.Algebra.Abstract.Multiplicative
 import NumHask.Algebra.Abstract.Lattice
+import NumHask.Algebra.Abstract.Multiplicative
+import Prelude hiding
+  ( (-),
+    Bounded (..),
+    Integral (..),
+    negate,
+  )
+import qualified Prelude as P
 
 -- | 'signum' from base is not an operator replicated in numhask, being such a very silly name, and preferred is the much more obvious 'sign'.  Compare with 'Norm' where there is a change in codomain
 --
 -- > abs a * sign a == a
 --
 -- Generalising this class tends towards size and direction (abs is the size on the one-dim number line of a vector with its tail at zero, and sign is the direction, right?).
-class (Multiplicative a) =>
+class
+  (Multiplicative a) =>
   Signed a where
   sign :: a -> a
   abs :: a -> a
@@ -129,146 +129,112 @@
     | otherwise = one
   abs = P.abs
 
--- | L1 and L2 norms are provided for potential speedups, as well as the generalized p-norm.
---
--- for p >= 1
+-- | Cab be Normed
 --
--- > normLp p a >= zero
--- > normLp p zero == zero
+-- > norm a >= zero
+-- > norm zero == zero
 --
 -- Note that the Normed codomain can be different to the domain.
---
 class (Additive a, Additive b) => Normed a b where
-  normL1 :: a -> b
-  normL2 :: a -> b
+  norm :: a -> b
 
 instance Normed Double Double where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Float Float where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Int Int where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Integer Integer where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Natural Natural where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Int8 Int8 where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Int16 Int16 where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Int32 Int32 where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Int64 Int64 where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Word Word where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Word8 Word8 where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Word16 Word16 where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Word32 Word32 where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
 instance Normed Word64 Word64 where
-  normL1 = P.abs
-  normL2 = P.abs
+  norm = P.abs
 
--- | distance between numbers using L1, L2 or Lp-norms
+-- | distance between numbers using L1 norm
 --
--- > distanceL2 a b >= zero
--- > distanceL2 a a == zero
--- > \a b c -> distanceL2 a c + distanceL2 b c - distanceL2 a b >= zero &&
--- >           distanceL2 a b + distanceL2 b c - distanceL2 a c >= zero &&
--- >           distanceL2 a b + distanceL2 a c - distanceL2 b c >= zero &&
+-- > distance a b >= zero
+-- > distance a a == zero
+--
 class Metric a b where
-  distanceL1 :: a -> a -> b
-  distanceL2 :: a -> a -> b
+  distance :: a -> a -> b
 
 instance Metric Double Double where
-  distanceL1 a b = normL1 (a - b)
-  distanceL2 a b = normL2 (a - b)
+  distance a b = norm (a - b)
 
 instance Metric Float Float where
-  distanceL1 a b = normL1 (a - b)
-  distanceL2 a b = normL2 (a - b)
+  distance a b = norm (a - b)
 
 instance Metric Int Int where
-  distanceL1 a b = normL1 (a - b)
-  distanceL2 a b = normL2 (a - b)
+  distance a b = norm (a - b)
 
 instance Metric Integer Integer where
-  distanceL1 a b = normL1 (a - b)
-  distanceL2 a b = normL2 (a - b)
+  distance a b = norm (a - b)
 
 instance Metric Natural Natural where
-  distanceL1 a b = P.fromInteger $ normL1 (P.toInteger a - P.toInteger b)
-  distanceL2 a b = P.fromInteger $ normL2 (P.toInteger a - P.toInteger b)
+  distance a b = P.fromInteger $ norm (P.toInteger a - P.toInteger b)
 
 instance Metric Int8 Int8 where
-  distanceL1 a b = normL1 (a - b)
-  distanceL2 a b = normL2 (a - b)
+  distance a b = norm (a - b)
 
 instance Metric Int16 Int16 where
-  distanceL1 a b = normL1 (a - b)
-  distanceL2 a b = normL2 (a - b)
+  distance a b = norm (a - b)
 
 instance Metric Int32 Int32 where
-  distanceL1 a b = normL1 (a - b)
-  distanceL2 a b = normL2 (a - b)
+  distance a b = norm (a - b)
 
 instance Metric Int64 Int64 where
-  distanceL1 a b = normL1 (a - b)
-  distanceL2 a b = normL2 (a - b)
+  distance a b = norm (a - b)
 
+
 -- fixme: circular distance may be more appropriate
 instance Metric Word Word where
-  distanceL1 a b = P.fromInteger $ normL1 (P.toInteger a - P.toInteger b)
-  distanceL2 a b = P.fromInteger $ normL2 (P.toInteger a - P.toInteger b)
+  distance a b = P.fromInteger $ norm (P.toInteger a - P.toInteger b)
 
 instance Metric Word8 Word8 where
-  distanceL1 a b = P.fromInteger $ normL1 (P.toInteger a - P.toInteger b)
-  distanceL2 a b = P.fromInteger $ normL2 (P.toInteger a - P.toInteger b)
+  distance a b = P.fromInteger $ norm (P.toInteger a - P.toInteger b)
 
 instance Metric Word16 Word16 where
-  distanceL1 a b = P.fromInteger $ normL1 (P.toInteger a - P.toInteger b)
-  distanceL2 a b = P.fromInteger $ normL2 (P.toInteger a - P.toInteger b)
+  distance a b = P.fromInteger $ norm (P.toInteger a - P.toInteger b)
 
 instance Metric Word32 Word32 where
-  distanceL1 a b = P.fromInteger $ normL1 (P.toInteger a - P.toInteger b)
-  distanceL2 a b = P.fromInteger $ normL2 (P.toInteger a - P.toInteger b)
+  distance a b = P.fromInteger $ norm (P.toInteger a - P.toInteger b)
 
 instance Metric Word64 Word64 where
-  distanceL1 a b = P.fromInteger $ normL1 (P.toInteger a - P.toInteger b)
-  distanceL2 a b = P.fromInteger $ normL2 (P.toInteger a - P.toInteger b)
+  distance a b = P.fromInteger $ norm (P.toInteger a - P.toInteger b)
 
-class (Eq a, Additive a, Subtractive a, MeetSemiLattice a) =>
+class
+  (Eq a, Additive a, Subtractive a, MeetSemiLattice a) =>
   Epsilon a where
-
   epsilon :: a
   epsilon = zero
 
diff --git a/src/NumHask/Data/Complex.hs b/src/NumHask/Data/Complex.hs
--- a/src/NumHask/Data/Complex.hs
+++ b/src/NumHask/Data/Complex.hs
@@ -8,7 +8,17 @@
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# OPTIONS_GHC -Wall #-}
 
-module NumHask.Data.Complex where
+module NumHask.Data.Complex
+  ( Complex (..),
+    realPart,
+    imagPart,
+    mkPolar,
+    cis,
+    polar,
+    magnitude,
+    phase,
+  )
+where
 
 import Data.Data (Data)
 import GHC.Generics (Generic, Generic1)
@@ -19,9 +29,20 @@
 import NumHask.Algebra.Abstract.Ring
 import NumHask.Analysis.Metric
 import NumHask.Data.Integral
-import Prelude
-  hiding (Num(..), (/), atan, cos, exp, log, negate, pi, recip, sin, sqrt)
-import qualified Prelude as P (Ord(..), (&&), (<), (<=), (==), (>), otherwise)
+import Prelude hiding
+  ( (/),
+    Num (..),
+    atan,
+    cos,
+    exp,
+    log,
+    negate,
+    pi,
+    recip,
+    sin,
+    sqrt,
+  )
+import qualified Prelude as P ((&&), (<), (<=), (==), (>), Ord (..), otherwise)
 
 -- -----------------------------------------------------------------------------
 -- The Complex type
@@ -34,19 +55,21 @@
 -- has the phase of @z@, but unit magnitude.
 --
 -- The 'Foldable' and 'Traversable' instances traverse the real part first.
-data Complex a =
-  !a :+ !a -- ^ forms a complex number from its real and imaginary
-                -- rectangular components.
-  deriving ( Eq
-           , Show
-           , Read
-           , Data
-           , Generic
-           , Generic1
-           , Functor
-           , Foldable
-           , Traversable
-           )
+data Complex a
+  = -- | forms a complex number from its real and imaginary
+    -- rectangular components.
+    !a :+ !a
+  deriving
+    ( Eq,
+      Show,
+      Read,
+      Data,
+      Generic,
+      Generic1,
+      Functor,
+      Foldable,
+      Traversable
+    )
 
 -- | Extracts the real part of a complex number.
 realPart :: Complex a -> a
@@ -63,37 +86,48 @@
 instance (Subtractive a) => Subtractive (Complex a) where
   negate (rx :+ ix) = negate rx :+ negate ix
 
-instance (Distributive a, Subtractive a) =>
+instance
+  (Distributive a, Subtractive a) =>
   Distributive (Complex a)
 
-instance (Subtractive a, Multiplicative a) =>
-  Multiplicative (Complex a) where
+instance
+  (Subtractive a, Multiplicative a) =>
+  Multiplicative (Complex a)
+  where
   (rx :+ ix) * (ry :+ iy) =
     (rx * ry - ix * iy) :+ (ix * ry + iy * rx)
   one = one :+ zero
 
-instance (Subtractive a, Divisive a) =>
-  Divisive (Complex a) where
+instance
+  (Subtractive a, Divisive a) =>
+  Divisive (Complex a)
+  where
   recip (rx :+ ix) = (rx * d) :+ (negate ix * d)
     where
       d = recip ((rx * rx) + (ix * ix))
 
-instance (Additive a, FromIntegral a b) =>
-  FromIntegral (Complex a) b where
+instance
+  (Additive a, FromIntegral a b) =>
+  FromIntegral (Complex a) b
+  where
   fromIntegral_ x = fromIntegral_ x :+ zero
 
-instance (Multiplicative a, ExpField a, Normed a a) =>
-  Normed (Complex a) a where
-  normL1 (rx :+ ix) = normL1 rx + normL1 ix
-  normL2 (rx :+ ix) = sqrt (rx * rx + ix * ix)
+instance
+  (ExpField a, Normed a a) =>
+  Normed (Complex a) a
+  where
+  norm (rx :+ ix) = norm rx + norm ix
 
-instance (Multiplicative a, Subtractive a, ExpField a, Normed a a) =>
-  Metric (Complex a) a where
-  distanceL1 a b = normL1 (a - b)
-  distanceL2 a b = normL2 (a - b)
+instance
+  (Subtractive a, ExpField a, Normed a a) =>
+  Metric (Complex a) a
+  where
+  distance a b = norm (a - b)
 
-instance (Ord a, Signed a, Subtractive a, Epsilon a)
-  => Epsilon (Complex a) where
+instance
+  (Ord a, Signed a, Subtractive a, Epsilon a) =>
+  Epsilon (Complex a)
+  where
   epsilon = epsilon :+ epsilon
   nearZero (a :+ b) = nearZero a && nearZero b
 
@@ -135,13 +169,13 @@
   top = top :+ top
 
 -- * Helpers from Data.Complex
+
 mkPolar :: TrigField a => a -> a -> Complex a
 mkPolar r theta = (r * cos theta) :+ (r * sin theta)
 
 -- | @'cis' t@ is a complex value with magnitude @1@
 -- and phase @t@ (modulo @2*'pi'@).
-{-# SPECIALISE cis :: Double -> Complex Double #-}
-
+{-# SPECIALIZE cis :: Double -> Complex Double #-}
 cis :: TrigField a => a -> Complex a
 cis theta = cos theta :+ sin theta
 
@@ -149,27 +183,25 @@
 -- returns a (magnitude, phase) pair in canonical form:
 -- the magnitude is nonnegative, and the phase in the range @(-'pi', 'pi']@;
 -- if the magnitude is zero, then so is the phase.
-{-# SPECIALISE polar :: Complex Double -> (Double, Double) #-}
-
+{-# SPECIALIZE polar :: Complex Double -> (Double, Double) #-}
 polar :: (RealFloat a, ExpField a) => Complex a -> (a, a)
 polar z = (magnitude z, phase z)
 
 -- | The nonnegative magnitude of a complex number.
-{-# SPECIALISE magnitude :: Complex Double -> Double #-}
-
+{-# SPECIALIZE magnitude :: Complex Double -> Double #-}
 magnitude :: (ExpField a, RealFloat a) => Complex a -> a
-magnitude (x :+ y) = scaleFloat
-  k
-  (sqrt (sqr (scaleFloat mk x) + sqr (scaleFloat mk y)))
- where
-  k = max (exponent x) (exponent y)
-  mk = -k
-  sqr z = z * z
+magnitude (x :+ y) =
+  scaleFloat
+    k
+    (sqrt (sqr (scaleFloat mk x) + sqr (scaleFloat mk y)))
+  where
+    k = max (exponent x) (exponent y)
+    mk = - k
+    sqr z = z * z
 
 -- | The phase of a complex number, in the range @(-'pi', 'pi']@.
 -- If the magnitude is zero, then so is the phase.
-{-# SPECIALISE phase :: Complex Double -> Double #-}
-
+{-# SPECIALIZE phase :: Complex Double -> Double #-}
 phase :: (RealFloat a) => Complex a -> a
 phase (0 :+ 0) = 0 -- SLPJ July 97 from John Peterson
 phase (x :+ y) = atan2 y x
diff --git a/src/NumHask/Data/Integral.hs b/src/NumHask/Data/Integral.hs
--- a/src/NumHask/Data/Integral.hs
+++ b/src/NumHask/Data/Integral.hs
@@ -1,41 +1,42 @@
-{-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE ConstraintKinds #-}
 {-# LANGUAGE DefaultSignatures #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 {-# OPTIONS_GHC -Wall #-}
 
 -- | Integral classes
 module NumHask.Data.Integral
-  ( Integral(..)
-  , ToIntegral(..)
-  , ToInteger
-  , toInteger
-  , FromIntegral(..)
-  , FromInteger(..)
-  , fromIntegral
-  , even
-  , odd
-  , (^)
-  , (^^)
+  ( Integral (..),
+    ToIntegral (..),
+    ToInteger,
+    toInteger,
+    FromIntegral (..),
+    FromInteger (..),
+    fromIntegral,
+    even,
+    odd,
+    (^),
+    (^^),
   )
 where
 
-import Data.Int (Int8, Int16, Int32, Int64)
-import Data.Word (Word, Word8, Word16, Word32, Word64)
-import GHC.Natural (Natural(..))
+import Data.Int (Int16, Int32, Int64, Int8)
+import Data.Word (Word, Word16, Word32, Word64, Word8)
+import GHC.Natural (Natural (..))
 import NumHask.Algebra.Abstract.Additive
 import NumHask.Algebra.Abstract.Multiplicative
 import NumHask.Algebra.Abstract.Ring
-import Prelude (Double, Float, Int, Integer, (.), fst, snd)
+import Prelude ((.), Double, Float, Int, Integer, fst, snd)
 import qualified Prelude as P
 
 -- | Integral laws
 --
 -- > b == zero || b * (a `div` b) + (a `mod` b) == a
-class (Distributive a) =>
+class
+  (Distributive a) =>
   Integral a where
   infixl 7 `div`, `mod`
   div :: a -> a -> a
@@ -288,18 +289,31 @@
   fromInteger = fromIntegral_
 
 instance FromInteger Integer
+
 instance FromInteger Int
+
 instance FromInteger Double
+
 instance FromInteger Float
+
 instance FromInteger Natural
+
 instance FromInteger Int8
+
 instance FromInteger Int16
+
 instance FromInteger Int32
+
 instance FromInteger Int64
+
 instance FromInteger Word
+
 instance FromInteger Word8
+
 instance FromInteger Word16
+
 instance FromInteger Word32
+
 instance FromInteger Word64
 
 -- $operators
@@ -311,32 +325,34 @@
 odd = P.not . even
 
 -------------------------------------------------------
+
 -- | raise a number to a non-negative integral power
-(^)
-  :: (P.Ord b, Multiplicative a, Integral b)
-  => a
-  -> b
-  -> a
+(^) ::
+  (P.Ord b, Multiplicative a, Integral b) =>
+  a ->
+  b ->
+  a
 x0 ^ y0
   | y0 P.< zero = P.undefined
   | -- P.errorWithoutStackTrace "Negative exponent"
-    y0 P.== zero = one
+    y0 P.== zero =
+    one
   | P.otherwise = f x0 y0
   where
+    -- f : x0 ^ y0 = x ^ y
+    f x y
+      | even y = f (x * x) (y `quot` two)
+      | y P.== one = x
+      | P.otherwise = g (x * x) (y `quot` two) x
+    -- See Note [Half of y - 1]
+    -- g : x0 ^ y0 = (x ^ y) * z
+    g x y z
+      | even y = g (x * x) (y `quot` two) z
+      | y P.== one = x * z
+      | P.otherwise = g (x * x) (y `quot` two) (x * z)
 
-  -- f : x0 ^ y0 = x ^ y
-  f x y
-    | even y = f (x * x) (y `quot` two)
-    | y P.== one = x
-    | P.otherwise = g (x * x) (y `quot` two) x
-          -- See Note [Half of y - 1]
-  -- g : x0 ^ y0 = (x ^ y) * z
-  g x y z
-    | even y = g (x * x) (y `quot` two) z
-    | y P.== one = x * z
-    | P.otherwise = g (x * x) (y `quot` two) (x * z)
-                -- See Note [Half of y - 1]
+-- See Note [Half of y - 1]
 
-(^^)
-  :: (Divisive a, Subtractive b, Integral b, P.Ord b) => a -> b -> a
+(^^) ::
+  (Divisive a, Subtractive b, Integral b, P.Ord b) => a -> b -> a
 (^^) x n = if n P.>= zero then x ^ n else recip (x ^ negate n)
diff --git a/src/NumHask/Data/LogField.hs b/src/NumHask/Data/LogField.hs
--- a/src/NumHask/Data/LogField.hs
+++ b/src/NumHask/Data/LogField.hs
@@ -10,35 +10,38 @@
 
 module NumHask.Data.LogField
   ( -- * @LogField@
-    LogField()
-  , logField
-  , fromLogField
+    LogField (),
+    logField,
+    fromLogField,
+
     -- ** Isomorphism to log-domain
-  , logToLogField
-  , logFromLogField
+    logToLogField,
+    logFromLogField,
+
     -- ** Additional operations
-  , accurateSum
-  , accurateProduct
-  , pow
+    accurateSum,
+    accurateProduct,
+    pow,
   )
 where
 
 import Data.Data (Data)
+import qualified Data.Foldable as F
 import GHC.Generics (Generic, Generic1)
 import NumHask.Algebra.Abstract.Additive
 import NumHask.Algebra.Abstract.Field
+import NumHask.Algebra.Abstract.Lattice
 import NumHask.Algebra.Abstract.Multiplicative
 import NumHask.Algebra.Abstract.Ring
-import NumHask.Algebra.Abstract.Lattice
 import NumHask.Analysis.Metric
 import NumHask.Data.Integral
 import NumHask.Data.Rational
-import Prelude hiding (Num(..), exp, log, negate)
-import qualified Data.Foldable as F
+import Prelude hiding (Num (..), exp, log, negate)
 
 -- LogField is adapted from LogFloat
 ----------------------------------------------------------------
 --                                                  ~ 2015.08.06
+
 -- |
 -- Module      :  Data.Number.LogFloat
 -- Copyright   :  Copyright (c) 2007--2015 wren gayle romano
@@ -50,6 +53,7 @@
 ----------------------------------------------------------------
 ----------------------------------------------------------------
 --
+
 -- | A @LogField@ is just a 'Field' with a special interpretation.
 -- The 'LogField' function is presented instead of the constructor,
 -- in order to ensure semantic conversion. At present the 'Show'
@@ -89,18 +93,19 @@
 --
 -- [1] That is, true up-to underflow and floating point fuzziness.
 -- Which is, of course, the whole point of this module.
-newtype LogField a =
-  LogField a
-  deriving ( Eq
-           , Ord
-           , Read
-           , Data
-           , Generic
-           , Generic1
-           , Functor
-           , Foldable
-           , Traversable
-           )
+newtype LogField a
+  = LogField a
+  deriving
+    ( Eq,
+      Ord,
+      Read,
+      Data,
+      Generic,
+      Generic1,
+      Functor,
+      Foldable,
+      Traversable
+    )
 
 ----------------------------------------------------------------
 -- To show it, we want to show the normal-domain value rather than
@@ -114,9 +119,10 @@
 instance (ExpField a, Show a) => Show (LogField a) where
   showsPrec p (LogField x) =
     let y = exp x
-    in y `seq` showParen (p > 9) (showString "LogField " . showsPrec 11 y)
+     in y `seq` showParen (p > 9) (showString "LogField " . showsPrec 11 y)
 
 ----------------------------------------------------------------
+
 -- | Constructor which does semantic conversion from normal-domain
 -- to log-domain. Throws errors on negative and NaN inputs. If @p@
 -- is non-negative, then following equivalence holds:
@@ -136,7 +142,6 @@
 -- equivalence holds (without qualification):
 --
 -- > fromLogField == exp . logFromLogField
---
 fromLogField :: ExpField a => LogField a -> a
 {-# INLINE [0] fromLogField #-}
 fromLogField (LogField x) = exp x
@@ -151,10 +156,11 @@
 -- fire, we have to delay the inlining on two of the four
 -- con-\/destructors.
 {-# RULES
-"log/fromLogField" forall x . log (fromLogField x) =
-                   logFromLogField x
-"fromLogField/LogField" forall x . fromLogField (LogField x) = x
- #-}
+"log/fromLogField" forall x.
+  log (fromLogField x) =
+    logFromLogField x
+"fromLogField/LogField" forall x. fromLogField (LogField x) = x
+  #-}
 
 log1p :: ExpField a => a -> a
 {-# INLINE [0] log1p #-}
@@ -165,12 +171,14 @@
 expm1 x = exp x - one
 
 {-# RULES
-"expm1/log1p" forall x . expm1 (log1p x) = x
-"log1p/expm1" forall x . log1p (expm1 x) = x
- #-}
+"expm1/log1p" forall x. expm1 (log1p x) = x
+"log1p/expm1" forall x. log1p (expm1 x) = x
+  #-}
 
-instance (ExpField a, LowerBoundedField a, Ord a) =>
-  Additive (LogField a) where
+instance
+  (ExpField a, LowerBoundedField a, Ord a) =>
+  Additive (LogField a)
+  where
   x@(LogField x') + y@(LogField y')
     | x == zero && y == zero = zero
     | x == zero = y
@@ -180,31 +188,38 @@
 
   zero = LogField negInfinity
 
-instance (ExpField a, Ord a, LowerBoundedField a, UpperBoundedField a) =>
-  Subtractive (LogField a) where
+instance
+  (ExpField a, Ord a, LowerBoundedField a, UpperBoundedField a) =>
+  Subtractive (LogField a)
+  where
   negate x
     | x == zero = zero
     | otherwise = nan
 
-instance (LowerBoundedField a, Eq a) =>
-  Multiplicative (LogField a) where
+instance
+  (LowerBoundedField a, Eq a) =>
+  Multiplicative (LogField a)
+  where
   (LogField x) * (LogField y)
     | x == negInfinity || y == negInfinity = LogField negInfinity
     | otherwise = LogField (x + y)
 
   one = LogField zero
 
-instance (LowerBoundedField a, Eq a) =>
-  Divisive (LogField a) where
+instance
+  (LowerBoundedField a, Eq a) =>
+  Divisive (LogField a)
+  where
   recip (LogField x) = LogField $ negate x
 
-instance (Ord a, LowerBoundedField a, ExpField a) =>
+instance
+  (Ord a, LowerBoundedField a, ExpField a) =>
   Distributive (LogField a)
 
 instance (Field (LogField a), ExpField a, LowerBoundedField a, Ord a) => ExpField (LogField a) where
-    exp (LogField x) = LogField $ exp x
-    log (LogField x) = LogField $ log x
-    (**) x (LogField y) = pow x $ exp y
+  exp (LogField x) = LogField $ exp x
+  log (LogField x) = LogField $ log x
+  (**) x (LogField y) = pow x $ exp y
 
 instance (FromIntegral a b, ExpField a) => FromIntegral (LogField a) b where
   fromIntegral_ = logField . fromIntegral_
@@ -224,31 +239,39 @@
 instance (Ord a) => MeetSemiLattice (LogField a) where
   (/\) = max
 
-instance (Epsilon a, ExpField a, LowerBoundedField a, UpperBoundedField a, Ord a) =>
-  Epsilon (LogField a) where
+instance
+  (Epsilon a, ExpField a, LowerBoundedField a, UpperBoundedField a, Ord a) =>
+  Epsilon (LogField a)
+  where
   epsilon = logField epsilon
   nearZero (LogField x) = nearZero $ exp x
   aboutEqual (LogField x) (LogField y) = aboutEqual (exp x) (exp y)
 
 instance (Ord a, ExpField a, LowerBoundedField a, UpperBoundedField a) => Field (LogField a)
 
-instance (Ord a, ExpField a, LowerBoundedField a, UpperBoundedField a) =>
+instance
+  (Ord a, ExpField a, LowerBoundedField a, UpperBoundedField a) =>
   LowerBoundedField (LogField a)
 
-instance (Ord a, ExpField a, LowerBoundedField a) =>
-  IntegralDomain (LogField a) where
+instance
+  (Ord a, ExpField a, LowerBoundedField a) =>
+  IntegralDomain (LogField a)
 
-instance (Ord a, ExpField a, LowerBoundedField a, UpperBoundedField a) =>
+instance
+  (Ord a, ExpField a, LowerBoundedField a, UpperBoundedField a) =>
   UpperBoundedField (LogField a)
 
-instance (Ord a, LowerBoundedField a, UpperBoundedField a, ExpField a) =>
-  Signed (LogField a) where
+instance
+  (Ord a, LowerBoundedField a, UpperBoundedField a, ExpField a) =>
+  Signed (LogField a)
+  where
   sign a
     | a == negInfinity = zero
     | otherwise = one
   abs = id
 
 ----------------------------------------------------------------
+
 -- | /O(1)/. Compute powers in the log-domain; that is, the following
 -- equivalence holds (modulo underflow and all that):
 --
@@ -257,6 +280,7 @@
 -- /Since: 0.13/
 pow :: (ExpField a, LowerBoundedField a, Ord a) => LogField a -> a -> LogField a
 {-# INLINE pow #-}
+
 infixr 8 `pow`
 
 pow x@(LogField x') m
@@ -271,6 +295,7 @@
 --     logsumexp[1000,1001,1000]   ~~ 1001.55 ==  1000 + 1.55
 --     logsumexp[-1000,-999,-1000] ~~ -998.45 == -1000 + 1.55
 --
+
 -- | /O(n)/. Compute the sum of a finite list of 'LogField's, being
 -- careful to avoid underflow issues. That is, the following
 -- equivalence holds (modulo underflow and all that):
@@ -283,10 +308,10 @@
 {-# INLINE accurateSum #-}
 accurateSum :: (ExpField a, Foldable f, Ord a) => f (LogField a) -> LogField a
 accurateSum xs = LogField (theMax + log theSum)
- where
-  LogField theMax = maximum xs
--- compute @\log \sum_{x \in xs} \exp(x - theMax)@
-  theSum = F.foldl' (\acc (LogField x) -> acc + exp (x - theMax)) zero xs
+  where
+    LogField theMax = maximum xs
+    -- compute @\log \sum_{x \in xs} \exp(x - theMax)@
+    theSum = F.foldl' (\acc (LogField x) -> acc + exp (x - theMax)) zero xs
 
 -- | /O(n)/. Compute the product of a finite list of 'LogField's,
 -- being careful to avoid numerical error due to loss of precision.
@@ -297,10 +322,9 @@
 {-# INLINE accurateProduct #-}
 accurateProduct :: (ExpField a, Foldable f) => f (LogField a) -> LogField a
 accurateProduct = LogField . fst . F.foldr kahanPlus (zero, zero)
- where
-  kahanPlus (LogField x) (t, c) =
-    let
-      y = x - c
-      t' = t + y
-      c' = (t' - t) - y
-    in (t', c')
+  where
+    kahanPlus (LogField x) (t, c) =
+      let y = x - c
+          t' = t + y
+          c' = (t' - t) - y
+       in (t', c')
diff --git a/src/NumHask/Data/Pair.hs b/src/NumHask/Data/Pair.hs
--- a/src/NumHask/Data/Pair.hs
+++ b/src/NumHask/Data/Pair.hs
@@ -1,4 +1,3 @@
-{-# LANGUAGE CPP #-}
 {-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
@@ -10,24 +9,24 @@
 
 -- | A Pair is *the* classical higher-kinded number but there is no canon.
 module NumHask.Data.Pair
-  ( Pair(..)
-  , pattern Pair
-  ) where
+  ( Pair (..),
+    pattern Pair,
+  )
+where
 
-import qualified Prelude as P
-import Prelude (Foldable, Traversable, Applicative, Monad, Functor(..), Semigroup(..), Monoid(..), Bounded(..), Eq(..), (<$>), (<*>), (&&))
-import GHC.Generics (Generic)
 import Data.Functor.Classes
+import GHC.Generics (Generic)
 import NumHask.Algebra.Abstract
-import NumHask.Data.Integral
 import NumHask.Analysis.Metric
+import NumHask.Data.Integral
 import NumHask.Data.Rational
 import Text.Show
+import Prelude ((&&), (<$>), (<*>), Applicative, Bounded (..), Eq (..), Foldable, Functor (..), Monad, Monoid (..), Semigroup (..), Traversable)
+import qualified Prelude as P
 
 -- $setup
 -- >>> :set -XNoImplicitPrelude
 -- >>> :set -XFlexibleContexts
---
 
 -- | A pair of a's, implemented as a tuple, but api represented as a Pair of a's.
 --
@@ -43,7 +42,7 @@
 -- Pair "a string" "pair mappended"
 --
 -- As a Ring and Field class
--- 
+--
 -- >>> Pair 0 1 + zero
 -- Pair 0 1
 -- >>> Pair 0 1 + Pair 2 3
@@ -61,16 +60,16 @@
 --
 -- >>> Pair 1 2 .+ 3
 -- Pair 4 5
---
-newtype Pair a =
-  Pair' (a, a)
+newtype Pair a
+  = Pair' (a, a)
   deriving (Eq, Generic)
 
 -- | the preferred pattern
 pattern Pair :: a -> a -> Pair a
-pattern Pair a b = Pair' (a,b)
-{-# COMPLETE Pair#-}
+pattern Pair a b = Pair' (a, b)
 
+{-# COMPLETE Pair #-}
+
 instance (Show a) => Show (Pair a) where
   show (Pair a b) = "Pair " <> Text.Show.show a <> " " <> Text.Show.show b
 
@@ -145,22 +144,23 @@
   sign = unaryOp sign
   abs = unaryOp abs
 
-instance (ExpField a, Normed a a) =>
-         Normed (Pair a) a where
-  normL1 (Pair a b) = normL1 a + normL1 b
-  normL2 (Pair a b) = sqrt (a ** (one + one) + b ** (one + one))
+instance
+  (ExpField a, Normed a a) =>
+  Normed (Pair a) a
+  where
+  norm (Pair a b) = norm a + norm b
 
 instance (Subtractive a, Epsilon a) => Epsilon (Pair a) where
   epsilon = Pair epsilon epsilon
   nearZero (Pair a b) = nearZero a && nearZero b
 
 instance (ExpField a, Subtractive a, Normed a a) => Metric (Pair a) a where
-  distanceL1 a b = normL1 (a - b)
-  distanceL2 a b = normL2 (a - b)
+  distance a b = norm (a - b)
 
 instance (Distributive a) => Distributive (Pair a)
 
 instance (Field a) => Field (Pair a)
+
 instance (IntegralDomain a) => IntegralDomain (Pair a)
 
 instance (ExpField a) => ExpField (Pair a) where
@@ -174,17 +174,20 @@
 type instance Actor (Pair a) = a
 
 instance (Additive a) => AdditiveAction (Pair a) where
-    (.+) r s = fmap (s+) r
-    (+.) s r = fmap (s+) r
+  (.+) r s = fmap (s +) r
+  (+.) s r = fmap (s +) r
+
 instance (Subtractive a) => SubtractiveAction (Pair a) where
-    (.-) r s = fmap (\x -> x - s) r
-    (-.) s r = fmap (\x -> x - s) r
+  (.-) r s = fmap (\x -> x - s) r
+  (-.) s r = fmap (\x -> x - s) r
+
 instance (Multiplicative a) => MultiplicativeAction (Pair a) where
-    (.*) r s = fmap (s*) r
-    (*.) s r = fmap (s*) r
+  (.*) r s = fmap (s *) r
+  (*.) s r = fmap (s *) r
+
 instance (Divisive a) => DivisiveAction (Pair a) where
-    (./) r s = fmap (/ s) r
-    (/.) s r = fmap (/ s) r
+  (./) r s = fmap (/ s) r
+  (/.) s r = fmap (/ s) r
 
 instance (JoinSemiLattice a) => JoinSemiLattice (Pair a) where
   (\/) = binOp (\/)
@@ -204,12 +207,14 @@
 instance (FromRatio a b) => FromRatio (Pair a) b where
   fromRatio x = P.pure (fromRatio x)
 
-instance (Normed a a) =>
-  Normed (Pair a) (Pair a) where
-  normL1 = fmap normL1
-  normL2 = fmap normL2
+instance
+  (Normed a a) =>
+  Normed (Pair a) (Pair a)
+  where
+  norm = fmap norm
 
-instance (Subtractive a, Normed a a) =>
-  Metric (Pair a) (Pair a) where
-  distanceL1 a b = normL1 (a - b)
-  distanceL2 a b = normL2 (a - b)
+instance
+  (Subtractive a, Normed a a) =>
+  Metric (Pair a) (Pair a)
+  where
+  distance a b = norm (a - b)
diff --git a/src/NumHask/Data/Positive.hs b/src/NumHask/Data/Positive.hs
--- a/src/NumHask/Data/Positive.hs
+++ b/src/NumHask/Data/Positive.hs
@@ -9,32 +9,32 @@
 
 import NumHask.Algebra.Abstract.Additive
 import NumHask.Algebra.Abstract.Field
+import NumHask.Algebra.Abstract.Lattice
 import NumHask.Algebra.Abstract.Multiplicative
 import NumHask.Algebra.Abstract.Ring
-import NumHask.Algebra.Abstract.Lattice
 import NumHask.Analysis.Metric
 import NumHask.Data.Integral
 import NumHask.Exception
 import qualified Prelude as P
 
-newtype Positive a = Positive { unPositive :: a }
+newtype Positive a = Positive {unPositive :: a}
   deriving
-    ( P.Show
-    , P.Eq
-    , P.Ord
-    , Additive
-    , Multiplicative
-    , Divisive
-    , Distributive
-    , IntegralDomain
-    , Field
-    , ExpField
-    , TrigField
-    , Integral
-    , Signed
-    , JoinSemiLattice
-    , MeetSemiLattice
-    , Epsilon
+    ( P.Show,
+      P.Eq,
+      P.Ord,
+      Additive,
+      Multiplicative,
+      Divisive,
+      Distributive,
+      IntegralDomain,
+      Field,
+      ExpField,
+      TrigField,
+      Integral,
+      Signed,
+      JoinSemiLattice,
+      MeetSemiLattice,
+      Epsilon
     )
 
 -- not sure if this is correct or needed
@@ -59,12 +59,16 @@
     | a P.>= b = Positive (a - b)
     | P.otherwise = throw (NumHaskException "subtracting a larger positive")
 
-instance (P.Ord a, QuotientField a P.Integer) =>
-  QuotientField (Positive a) (Positive P.Integer) where
-  properFraction (Positive a) = let (i,r) = properFraction a in (Positive i, Positive r)
+instance
+  (P.Ord a, QuotientField a P.Integer) =>
+  QuotientField (Positive a) (Positive P.Integer)
+  where
+  properFraction (Positive a) = let (i, r) = properFraction a in (Positive i, Positive r)
 
-instance (P.Ord a, UpperBoundedField a) =>
-  UpperBoundedField (Positive a) where
+instance
+  (P.Ord a, UpperBoundedField a) =>
+  UpperBoundedField (Positive a)
+  where
   infinity = Positive infinity
 
 instance (P.Ord a, UpperBoundedField a) => P.Bounded (Positive a) where
@@ -72,11 +76,11 @@
   maxBound = infinity
 
 -- Metric
-instance (Normed a a) =>
-  Normed a (Positive a) where
-  normL1 a = Positive (normL1 a)
-  normL2 a = Positive (normL2 a)
+instance
+  (Normed a a) =>
+  Normed a (Positive a)
+  where
+  norm a = Positive (norm a)
 
 instance (Subtractive a, Normed a a) => Metric a (Positive a) where
-  distanceL1 a b = Positive P.$ normL1 (a - b)
-  distanceL2 a b = Positive P.$ normL2 (a - b)
+  distance a b = Positive P.$ norm (a - b)
diff --git a/src/NumHask/Data/Rational.hs b/src/NumHask/Data/Rational.hs
--- a/src/NumHask/Data/Rational.hs
+++ b/src/NumHask/Data/Rational.hs
@@ -5,41 +5,41 @@
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeFamilies #-}
-{-# LANGUAGE UndecidableInstances #-}
 {-# OPTIONS_GHC -Wall #-}
 
 -- | Integral classes
 module NumHask.Data.Rational
-  ( Ratio(..)
-  , Rational
-  , ToRatio(..)
-  , ToRational
-  , toRational
-  , FromRatio(..)
-  , FromRational
-  , fromRational
-  , fromRational'
-  , fromBaseRational
-  -- * $integral_functionality
-  , reduce
-  , gcd
+  ( Ratio (..),
+    Rational,
+    ToRatio (..),
+    ToRational,
+    toRational,
+    FromRatio (..),
+    FromRational,
+    fromRational,
+    fromRational',
+    fromBaseRational,
+
+    -- * \$integral_functionality
+    reduce,
+    gcd,
   )
 where
 
-import Data.Int (Int8, Int16, Int32, Int64)
-import Data.Word (Word, Word8, Word16, Word32, Word64)
 import Data.Bool (bool)
+import Data.Int (Int16, Int32, Int64, Int8)
+import Data.Word (Word, Word16, Word32, Word64, Word8)
 import GHC.Float
-import GHC.Natural (Natural(..))
+import GHC.Natural (Natural (..))
+import qualified GHC.Real
 import NumHask.Algebra.Abstract.Additive
 import NumHask.Algebra.Abstract.Field
+import NumHask.Algebra.Abstract.Lattice
 import NumHask.Algebra.Abstract.Multiplicative
 import NumHask.Algebra.Abstract.Ring
-import NumHask.Algebra.Abstract.Lattice
 import NumHask.Analysis.Metric
 import NumHask.Data.Integral
-import Prelude (Int, Integer, Rational, (.))
-import qualified GHC.Real
+import Prelude ((.), Int, Integer, Rational)
 import qualified Prelude as P
 
 data Ratio a = !a :% !a deriving (P.Show)
@@ -48,18 +48,18 @@
   a == b
     | isRNaN a P.|| isRNaN b = P.False
     | P.otherwise = (x P.== x') P.&& (y P.== y')
-      where
-        (x:%y) = a
-        (x':%y') = b
+    where
+      (x :% y) = a
+      (x' :% y') = b
 
 isRNaN :: (P.Eq a, Additive a) => Ratio a -> P.Bool
 isRNaN (x :% y)
   | x P.== zero P.&& y P.== zero = P.True
   | P.otherwise = P.False
 
-instance  (P.Ord a, Multiplicative a, Additive a)  => P.Ord (Ratio a)  where
-  (x:%y) <= (x':%y')  =  x * y' P.<= x' * y
-  (x:%y) <  (x':%y')  =  x * y' P.<  x' * y
+instance (P.Ord a, Multiplicative a, Additive a) => P.Ord (Ratio a) where
+  (x :% y) <= (x' :% y') = x * y' P.<= x' * y
+  (x :% y) < (x' :% y') = x * y' P.< x' * y
 
 -- | These common constraints over the Ratio instances are due to the gcd algorithm. Subtractive is somewhat problematic with obtaining a `Ratio (Positive Integer)` which should be made possible.
 type GCDConstraints a = (P.Ord a, Signed a, Integral a, Subtractive a)
@@ -77,26 +77,29 @@
   negate (x :% y) = negate x :% y
 
 instance (GCDConstraints a) => Multiplicative (Ratio a) where
-  (x:%y) * (x':%y') = reduce (x * x') (y * y')
+  (x :% y) * (x' :% y') = reduce (x * x') (y * y')
 
   one = one :% one
 
-instance (GCDConstraints a) =>
-  Divisive (Ratio a) where
+instance
+  (GCDConstraints a) =>
+  Divisive (Ratio a)
+  where
   recip (x :% y)
     | sign x P.== negate one = negate y :% negate x
     | P.otherwise = y :% x
 
-instance (GCDConstraints a) => Distributive  (Ratio a)
+instance (GCDConstraints a) => Distributive (Ratio a)
 
 instance (GCDConstraints a) => IntegralDomain (Ratio a)
 
 instance (GCDConstraints a) => Field (Ratio a)
 
 instance (GCDConstraints a, GCDConstraints b, ToInteger a, Field a, FromIntegral b a) => QuotientField (Ratio a) b where
-  properFraction (n :% d) = let (w,r) = quotRem n d in (fromIntegral_ w,r:%d)
+  properFraction (n :% d) = let (w, r) = quotRem n d in (fromIntegral_ w, r :% d)
 
-instance (GCDConstraints a, Distributive a, IntegralDomain a) =>
+instance
+  (GCDConstraints a, Distributive a, IntegralDomain a) =>
   UpperBoundedField (Ratio a)
 
 instance (GCDConstraints a, Field a) => LowerBoundedField (Ratio a)
@@ -109,12 +112,10 @@
   abs (n :% d) = abs n :% abs d
 
 instance (GCDConstraints a) => Normed (Ratio a) (Ratio a) where
-  normL1 = abs
-  normL2 = abs
+  norm = abs
 
 instance (GCDConstraints a) => Metric (Ratio a) (Ratio a) where
-  distanceL1 a b = normL1 (a - b)
-  distanceL2 a b = normL2 (a - b)
+  distance a b = norm (a - b)
 
 instance (GCDConstraints a, MeetSemiLattice a) => Epsilon (Ratio a)
 
@@ -194,13 +195,13 @@
 fromBaseRational (n GHC.Real.:% d) = n :% d
 
 instance FromRatio Double Integer where
-  fromRatio (n:%d)= rationalToDouble n d
+  fromRatio (n :% d) = rationalToDouble n d
 
 instance FromRatio Float Integer where
-  fromRatio (n:%d)= rationalToFloat n d
+  fromRatio (n :% d) = rationalToFloat n d
 
 instance FromRatio Rational Integer where
-  fromRatio (n:%d) = n GHC.Real.% d
+  fromRatio (n :% d) = n GHC.Real.% d
 
 instance FromRatio (Ratio Integer) Integer where
   fromRatio = P.id
@@ -212,7 +213,9 @@
   fromRational = fromRatio . fromBaseRational
 
 instance FromRational Double
+
 instance FromRational Float
+
 instance FromRational Rational
 
 -- | Given that fromRational is reserved, fromRational' provides general conversion between numhask rationals.
@@ -225,23 +228,24 @@
 instance (GCDConstraints a) => MeetSemiLattice (Ratio a) where
   (/\) = P.max
 
--- * $integral_functions
+-- * \$integral_functions
 -- integral functionality is largely based on GHC.Real
 --
+
 -- | 'reduce' is a subsidiary function used only in this module.
 -- It normalises a ratio by dividing both numerator and denominator by
 -- their greatest common divisor.
-reduce
-  :: (P.Eq a, Subtractive a, Signed a, Integral a) => a -> a -> Ratio a
+reduce ::
+  (P.Eq a, Subtractive a, Signed a, Integral a) => a -> a -> Ratio a
 reduce x y
   | x P.== zero P.&& y P.== zero = zero :% zero
   | z P.== zero = one :% zero
   | P.otherwise = (x `quot` z) % (y `quot` z)
- where
-  z = gcd x y
-  n % d
-    | sign d P.== negate one = negate n :% negate d
-    | P.otherwise = n :% d
+  where
+    z = gcd x y
+    n % d
+      | sign d P.== negate one = negate n :% negate d
+      | P.otherwise = n :% d
 
 -- | @'gcd' x y@ is the non-negative factor of both @x@ and @y@ of which
 -- every common factor of @x@ and @y@ is also a factor; for example
@@ -254,7 +258,7 @@
 -- necessarily is if the other is @0@ or @'minBound'@) for such types.
 gcd :: (P.Eq a, Signed a, Integral a) => a -> a -> a
 gcd x y = gcd' (abs x) (abs y)
- where
-  gcd' a b
-    | b P.== zero = a
-    | P.otherwise = gcd' b (a `rem` b)
+  where
+    gcd' a b
+      | b P.== zero = a
+      | P.otherwise = gcd' b (a `rem` b)
diff --git a/src/NumHask/Data/Wrapped.hs b/src/NumHask/Data/Wrapped.hs
--- a/src/NumHask/Data/Wrapped.hs
+++ b/src/NumHask/Data/Wrapped.hs
@@ -9,49 +9,51 @@
 
 import NumHask.Algebra.Abstract.Additive
 import NumHask.Algebra.Abstract.Field
+import NumHask.Algebra.Abstract.Group
+import NumHask.Algebra.Abstract.Lattice
 import NumHask.Algebra.Abstract.Multiplicative
 import NumHask.Algebra.Abstract.Ring
-import NumHask.Algebra.Abstract.Lattice
-import NumHask.Algebra.Abstract.Group
 import NumHask.Analysis.Metric
 import NumHask.Data.Integral
 import NumHask.Data.Rational
 import qualified Prelude as P
 
-newtype Wrapped a = Wrapped { unWrapped :: a }
+newtype Wrapped a = Wrapped {unWrapped :: a}
   deriving
-    ( P.Show
-    , P.Eq
-    , P.Ord
-    , Magma
-    , Idempotent
-    , Additive
-    , Subtractive
-    , Multiplicative
-    , Divisive
-    , Distributive
-    , IntegralDomain
-    , InvolutiveRing
-    , StarSemiring
-    , KleeneAlgebra
-    , Field
-    , ExpField
-    , TrigField
-    , Integral
-    , Signed
-    , MeetSemiLattice
-    , JoinSemiLattice
-    , Epsilon
-    , UpperBoundedField
-    , LowerBoundedField
+    ( P.Show,
+      P.Eq,
+      P.Ord,
+      Magma,
+      Idempotent,
+      Additive,
+      Subtractive,
+      Multiplicative,
+      Divisive,
+      Distributive,
+      IntegralDomain,
+      InvolutiveRing,
+      StarSemiring,
+      KleeneAlgebra,
+      Field,
+      ExpField,
+      TrigField,
+      Integral,
+      Signed,
+      MeetSemiLattice,
+      JoinSemiLattice,
+      Epsilon,
+      UpperBoundedField,
+      LowerBoundedField
     )
 
 -- not sure if this is correct or needed
 type role Wrapped representational
 
-instance (P.Ord a, QuotientField a P.Integer) =>
-  QuotientField (Wrapped a) (Wrapped P.Integer) where
-  properFraction (Wrapped a) = let (i,r) = properFraction a in (Wrapped i, Wrapped r)
+instance
+  (P.Ord a, QuotientField a P.Integer) =>
+  QuotientField (Wrapped a) (Wrapped P.Integer)
+  where
+  properFraction (Wrapped a) = let (i, r) = properFraction a in (Wrapped i, Wrapped r)
 
 instance (FromIntegral a b) => FromIntegral (Wrapped a) b where
   fromIntegral_ a = Wrapped (fromIntegral_ a)
@@ -66,9 +68,7 @@
   toRatio (Wrapped a) = toRatio a
 
 instance (Normed a b) => Normed (Wrapped a) (Wrapped b) where
-  normL1 (Wrapped a) = Wrapped (normL1 a)
-  normL2 (Wrapped a) = Wrapped (normL2 a)
+  norm (Wrapped a) = Wrapped (norm a)
 
 instance (Metric a b) => Metric (Wrapped a) (Wrapped b) where
-  distanceL1 (Wrapped a) (Wrapped b) = Wrapped (distanceL1 a b)
-  distanceL2 (Wrapped a) (Wrapped b) = Wrapped (distanceL2 a b)
+  distance (Wrapped a) (Wrapped b) = Wrapped (distance a b)
diff --git a/src/NumHask/Exception.hs b/src/NumHask/Exception.hs
--- a/src/NumHask/Exception.hs
+++ b/src/NumHask/Exception.hs
@@ -1,15 +1,16 @@
 {-# OPTIONS_GHC -Wall #-}
 
 module NumHask.Exception
-  ( NumHaskException(..)
-  , throw
-  ) where
+  ( NumHaskException (..),
+    throw,
+  )
+where
 
-import qualified Prelude as P
 import Control.Exception
 import Data.Typeable (Typeable)
+import qualified Prelude as P
 
-newtype NumHaskException = NumHaskException { errorMessage :: P.String }
+newtype NumHaskException = NumHaskException {errorMessage :: P.String}
   deriving (P.Show, Typeable)
 
 instance Exception NumHaskException
diff --git a/src/NumHask/Prelude.hs b/src/NumHask/Prelude.hs
new file mode 100644
--- /dev/null
+++ b/src/NumHask/Prelude.hs
@@ -0,0 +1,84 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_HADDOCK prune #-}
+
+-- | Combines 'Protolude' and 'numhask'.
+module NumHask.Prelude
+  ( -- * NumHask
+    -- $instances
+    module NumHask.Algebra.Abstract.Action,
+    module NumHask.Algebra.Abstract.Additive,
+    module NumHask.Algebra.Abstract.Field,
+    module NumHask.Algebra.Abstract.Group,
+    module NumHask.Algebra.Abstract.Lattice,
+    module NumHask.Algebra.Abstract.Module,
+    module NumHask.Algebra.Abstract.Multiplicative,
+    module NumHask.Algebra.Abstract.Ring,
+    module NumHask.Analysis.Metric,
+    module NumHask.Data.Complex,
+    module NumHask.Data.Integral,
+    module NumHask.Data.LogField,
+    module NumHask.Data.Rational,
+    module NumHask.Data.Pair,
+    module NumHask.Data.Positive,
+    Natural (..),
+    module NumHask.Exception,
+
+    -- * Backend
+    -- $backend
+    Category (..),
+    module Protolude,
+    module Data.Biapplicative,
+    module Control.Monad.Morph,
+    module Data.Functor.Constant,
+    pack,
+    unpack,
+    -- | Using different types for numbers requires RebindableSyntax.  This then removes all sorts of base-level stuff that has to be put back in.
+    fromString,
+    fail,
+    ifThenElse,
+    fromList,
+    fromListN,
+  )
+where
+
+import Control.Category (Category (..))
+import Control.Monad (fail)
+import Control.Monad.Morph
+import Data.Biapplicative
+import Data.Functor.Constant
+import Data.String
+import Data.Text (pack, unpack)
+import GHC.Exts
+import GHC.Natural (Natural (..))
+import NumHask.Algebra.Abstract.Action
+import NumHask.Algebra.Abstract.Additive
+import NumHask.Algebra.Abstract.Field
+import NumHask.Algebra.Abstract.Group
+import NumHask.Algebra.Abstract.Lattice
+import NumHask.Algebra.Abstract.Module
+import NumHask.Algebra.Abstract.Multiplicative
+import NumHask.Algebra.Abstract.Ring
+import NumHask.Analysis.Metric
+import NumHask.Data.Complex
+import NumHask.Data.Integral
+import NumHask.Data.LogField
+import NumHask.Data.Pair
+import NumHask.Data.Positive
+import NumHask.Data.Rational
+import NumHask.Exception
+import Protolude hiding ((*), (**), (+), (-), (.), (/), (<<$>>), (<<*>>), Complex (..), Integral (..), Product (..), Ratio, Rep, Semiring (..), Sum (..), (^), (^^), abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceiling, cis, cos, cosh, even, exp, floor, fromInteger, fromIntegral, fromRational, gcd, imagPart, infinity, log, logBase, magnitude, mkPolar, negate, odd, phase, pi, polar, product, properFraction, realPart, recip, reduce, round, sin, sinh, sqrt, subtract, sum, tan, tanh, toInteger, toRational, trans, truncate, zero)
+
+-- $backend
+-- NumHask imports Protolude as a starting prelude.
+--
+-- In addition, 'id' is imported (protolude uses 'identity')
+
+-- $instances
+-- NumHask replaces much of the 'Num' and 'Real' heirarchies in protolude & base.
+--
+-- Instances for 'Int', 'Integer', 'Float', 'Double', 'Bool', 'Complex' and 'Natural'are supplied.
+
+-- | rebindable syntax splats this, and I'm not sure where it exists in GHC land
+ifThenElse :: Bool -> a -> a -> a
+ifThenElse True x _ = x
+ifThenElse False _ y = y