diff --git a/numhask-range.cabal b/numhask-range.cabal
--- a/numhask-range.cabal
+++ b/numhask-range.cabal
@@ -2,10 +2,10 @@
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: 62fc752e10fc215ee3f1cacd5452edc20d82a58c25ee596a682e1eccbd3a98ea
+-- hash: eb71b3256d9227210388010a697953048c3c2bb2f48b3d3d4c8cb6c4eda5aee7
 
 name:           numhask-range
-version:        0.2.1.0
+version:        0.2.2.0
 synopsis:       Numbers that are range representations
 description:    Numbers that represent ranges of all sorts.
 category:       project
@@ -36,7 +36,7 @@
     , adjunctions
     , base >=4.7 && <4.12
     , distributive
-    , numhask-prelude >=0.0.1.0
+    , numhask-prelude >=0.0.4.0
     , protolude
     , semigroupoids
   exposed-modules:
@@ -59,7 +59,7 @@
   build-depends:
       base >=4.7 && <5
     , doctest
-    , numhask-prelude >=0.0.1.0
+    , numhask-prelude >=0.0.4.0
     , numhask-range
     , tasty
   other-modules:
diff --git a/src/NumHask/Pair.hs b/src/NumHask/Pair.hs
--- a/src/NumHask/Pair.hs
+++ b/src/NumHask/Pair.hs
@@ -189,14 +189,20 @@
     where
       (da, ma) = a0 `divMod` a1
       (db, mb) = b0 `divMod` b1
+  (Pair a0 b0) `quotRem` (Pair a1 b1) = (Pair da db, Pair ma mb)
+    where
+      (da, ma) = a0 `quotRem` a1
+      (db, mb) = b0 `quotRem` b1
 
 instance (Signed a) => Signed (Pair a) where
   sign (Pair a b) = Pair (sign a) (sign b)
   abs (Pair a b) = Pair (abs a) (abs b)
 
-instance (ExpField a, MultiplicativeUnital a) =>
+instance (ExpField a, Normed a a, MultiplicativeUnital a) =>
          Normed (Pair a) a where
-  size (Pair a b) = sqrt (a ** (one + one) + b ** (one + one))
+  normL1 (Pair a b) = normL1 a + normL1 b
+  normL2 (Pair a b) = sqrt (a ** (one + one) + b ** (one + one))
+  normLp p (Pair a b) = (normL1 a ** p + normL1 b ** p) ** (one/p)
 
 -- | L1-based Ord instance
 instance (Eq a, Ord a, Signed a, Additive a) => Ord (Pair a) where
@@ -206,25 +212,31 @@
   nearZero (Pair a b) = nearZero a && nearZero b
   aboutEqual a b = nearZero $ a - b
 
-instance (ExpField a) => Metric (Pair a) a where
-  distance (Pair a0 b0) (Pair a1 b1) = size (Pair (a1 - a0) (b1 - b0))
+instance (ExpField a, Normed a a) => Metric (Pair a) a where
+  distanceL1 a b = normL1 (a - b)
+  distanceL2 a b = normL2 (a - b)
+  distanceLp p a b = normLp p (a - b)
 
-instance (AdditiveGroup a, Distribution a) => Distribution (Pair a)
+instance (Distribution a) => Distribution (Pair a)
 
-instance (Ring a) => Ring (Pair a)
+instance (Semiring a) => Semiring (Pair a)
 
-instance (AdditiveGroup a, Semiring a) => Semiring (Pair a)
+instance (Ring a) => Ring (Pair a)
 
 instance (CRing a) => CRing (Pair a)
 
+instance (Semifield a) => Semifield (Pair a)
+
 instance (Field a) => Field (Pair a)
 
 instance (ExpField a) => ExpField (Pair a) where
   exp (Pair a b) = Pair (exp a) (exp b)
   log (Pair a b) = Pair (log a) (log b)
 
-instance (BoundedField a) => BoundedField (Pair a) where
+instance (UpperBoundedField a) => UpperBoundedField (Pair a) where
   isNaN (Pair a b) = isNaN a || isNaN b
+
+instance (LowerBoundedField a) => LowerBoundedField (Pair a)
 
 instance (Additive a) => AdditiveBasis Pair a where
     (.+.) = liftR2 (+)
diff --git a/src/NumHask/Range.hs b/src/NumHask/Range.hs
--- a/src/NumHask/Range.hs
+++ b/src/NumHask/Range.hs
@@ -156,7 +156,7 @@
     plus (Range l0 u0) (Range l1 u1) = Range (min l0 l1) (max u0 u1) 
 
 instance (Ord a, BoundedField a) => AdditiveUnital (Range a) where
-    zero = Range infinity neginfinity
+    zero = Range infinity negInfinity
 
 instance (Ord a) => AdditiveAssociative (Range a)
 
@@ -200,13 +200,23 @@
     abs (Range l u) = if u >= l then Range l u else Range u l
 
 instance (AdditiveGroup a) => Normed (Range a) a where
-    size (Range l u) = u-l
+    normL1 (Range l u) = u-l
+    normL2 (Range l u) = u-l
+    normLp _ (Range l u) = u-l
 
 instance (Ord a, AdditiveGroup a) => Metric (Range a) a where
-    distance (Range l u) (Range l' u')
+    distanceL1 (Range l u) (Range l' u')
         | u < l' = l' - u
         | u' < l = l - u'
         | otherwise = zero
+    distanceL2 (Range l u) (Range l' u')
+        | u < l' = l' - u
+        | u' < l = l - u'
+        | otherwise = zero
+    distanceLp _ (Range l u) (Range l' u')
+        | u < l' = l' - u
+        | u' < l = l - u'
+        | otherwise = zero
 
 instance (BoundedField a, Ord a, Epsilon a) => Epsilon (Range a) where
     nearZero (Range l u) = nearZero (l - u)
@@ -223,7 +233,7 @@
     Space (Range a) where
     type Element (Range a) = a
     union (Range l0 u0) (Range l1 u1) = Range (min l0 l1) (max u0 u1)
-    nul = Range infinity neginfinity
+    nul = Range infinity negInfinity
     lower (Range l _) = l
     upper (Range _ u) = u
     singleton a = Range a a
@@ -252,7 +262,7 @@
 
 -- | turn a range into n `a`s pleasing to human sense and sensibility
 -- the `a`s may well lie outside the original range as a result
-gridSensible :: (FromInteger a, Fractional a, Ord a, QuotientField a, ExpField a) =>
+gridSensible :: (FromInteger a, Fractional a, QuotientField a, ExpField a) =>
     Pos -> Range a -> Int -> [a]
 gridSensible tp (Range l u) n =
     (+ if tp==MidPos then step/two else zero) <$> posns
diff --git a/src/NumHask/Rect.hs b/src/NumHask/Rect.hs
--- a/src/NumHask/Rect.hs
+++ b/src/NumHask/Rect.hs
@@ -1,4 +1,5 @@
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE DeriveTraversable #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE FlexibleInstances #-}
@@ -84,7 +85,8 @@
 -- [Pair 2.5 0.25,Pair 2.5 0.75,Pair 7.5 0.25,Pair 7.5 0.75]
 newtype Rect a =
   Rect' (Compose Pair Range a)
-  deriving (Eq, Functor, Apply, Applicative, Foldable, Foldable1, Traversable)
+  deriving (Eq, Functor, Apply, Applicative, Foldable, Foldable1, Traversable,
+            Generic)
 
 -- | pattern of Rect lowerx upperx lowery uppery
 pattern Rect :: a -> a -> a -> a -> Rect a
@@ -100,6 +102,13 @@
   show (Rect a b c d) =
     "Rect " <> show a <> " " <> show b <> " " <> show c <> " " <> show d
 
+-- rect'' :: Dhall.Type (Rect a)
+-- rect'' = pair (pair double double) (pair double double)
+
+-- instance (Interpret a) => Interpret (Rect a)
+-- input auto "{ _1 = {_1 = 1.1, _2 = 1.1 }}" :: IO (Range Double)
+
+
 instance Traversable1 Rect where
   traverse1 f (Rect a b c d) = Rect <$> f a <.> f b <.> f c <.> f d
 
@@ -158,7 +167,9 @@
   abs (Ranges l u) = Ranges (sign l * l) (sign u * u)
 
 instance (AdditiveGroup a) => Normed (Rect a) (Pair a) where
-  size (Ranges l u) = Pair (size l) (size u)
+  normL1 (Ranges l u) = Pair (normL1 l) (normL1 u)
+  normL2 (Ranges l u) = Pair (normL2 l) (normL2 u)
+  normLp (Pair pl pu) (Ranges l u) = Pair (normLp pl l) (normLp pu u)
 
 instance (BoundedField a, Ord a, Epsilon a) => Epsilon (Rect a) where
     nearZero (Ranges a b) = nearZero a && nearZero b
diff --git a/stack.yaml b/stack.yaml
--- a/stack.yaml
+++ b/stack.yaml
@@ -1,8 +1,8 @@
-resolver: nightly-2018-04-05
+resolver: nightly-2018-05-08
 
 packages:
   - .
 
 extra-deps:
-  - numhask-prelude-0.0.3.0
-  - numhask-0.2.0.0
+  - numhask-prelude-0.0.4.0
+  - numhask-0.2.1.0
diff --git a/test/test.hs b/test/test.hs
--- a/test/test.hs
+++ b/test/test.hs
@@ -63,21 +63,21 @@
   -> [Law2 s (Element s)]
 projectSpaceFuzzyLaws x =
   [ ( "project o n (lower o) ≈ lower n"
-    , Ternary2
-        (\o n _ ->
+    , Binary20
+        (\o n ->
            singular o ||
            singular n ||
-           x < abs (size o) ||
-           x < abs (size n) || project o n (lower o) ≈ lower n))
+           x < abs (normL1 o) ||
+           x < abs (normL1 n) || project o n (lower o) ≈ lower n))
   , ( "project o n (upper o) ≈ upper n"
-    , Ternary2
-        (\o n _ ->
+    , Binary20
+        (\o n ->
            singular o ||
            singular n ||
-           x < abs (size o) ||
-           x < abs (size n) || project o n (upper o) ≈ upper n))
+           x < abs (normL1 o) ||
+           x < abs (normL1 n) || project o n (upper o) ≈ upper n))
   , ( "project a a x ≈ x"
-    , Ternary2 (\o _ s -> singular o || x < abs (size o) || project o o s ≈ s))
+    , Binary11 (\o s -> singular o || x < abs (normL1 o) || project o o s ≈ s))
   ]
 
 additiveSpaceFuzzyLaws ::
@@ -91,16 +91,16 @@
   -> [Law s]
 additiveSpaceFuzzyLaws n =
   [ ( "left unital: zero + a ≈ a"
-    , Unary (\a -> n < abs (size a) || zero + a ≈ a))
+    , Unary (\a -> n < abs (normL1 a) || zero + a ≈ a))
   , ( "right unital: a + zero ≈ a"
-    , Unary (\a -> n < abs (size a) || zero + a ≈ a))
+    , Unary (\a -> n < abs (normL1 a) || zero + a ≈ a))
   , ( "associative: (a + b) + c ≈ a + (b +c)"
-    , Ternary (\a b c -> n < abs (size a) || (a + b) + c ≈ a + (b + c)))
+    , Ternary (\a b c -> n < abs (normL1 a) || (a + b) + c ≈ a + (b + c)))
   , ( "commutative a + b ≈ b + a"
-    , Binary (\a b -> n < abs (size a) || a + b ≈ b + a))
-  , ("idempotent a + a ≈ a", Unary (\a -> n < abs (size a) || a + a ≈ a))
+    , Binary (\a b -> n < abs (normL1 a) || a + b ≈ b + a))
+  , ("idempotent a + a ≈ a", Unary (\a -> n < abs (normL1 a) || a + a ≈ a))
   , ( "idempotent negate a + negate a ≈ abs a"
-    , Unary (\a -> n < abs (size a) || a + negate a ≈ abs a))
+    , Unary (\a -> n < abs (normL1 a) || a + negate a ≈ abs a))
   ]
 
 multiplicativeSpaceFuzzyLaws ::
@@ -114,15 +114,15 @@
   => Element s
   -> [Law s]
 multiplicativeSpaceFuzzyLaws n =
-  [ ("left unital: one * a ≈ a", Unary (\a -> n < abs (size a) || one * a ≈ a))
-  , ("right unital: a * one ≈ a", Unary (\a -> n < abs (size a) || one * a ≈ a))
+  [ ("left unital: one * a ≈ a", Unary (\a -> n < abs (normL1 a) || one * a ≈ a))
+  , ("right unital: a * one ≈ a", Unary (\a -> n < abs (normL1 a) || one * a ≈ a))
   , ( "associative: (a * b) * c ≈ a * (b *c)"
     , Ternary
         (\a b c ->
-           n < abs (size a) ||
-           n < abs (size b) || n < abs (size c) || (a * b) * c ≈ a * (b * c)))
+           n < abs (normL1 a) ||
+           n < abs (normL1 b) || n < abs (normL1 c) || (a * b) * c ≈ a * (b * c)))
   , ( "commutative a * b ≈ b * a"
-    , Binary (\a b -> n < abs (size a) || a * b ≈ b * a))
+    , Binary (\a b -> n < abs (normL1 a) || a * b ≈ b * a))
   ]
 
 multiplicativeGroupSpaceFuzzyLaws ::
@@ -138,13 +138,13 @@
   -> [Law s]
 multiplicativeGroupSpaceFuzzyLaws n =
   [ ( "divide: a / a ≈ one"
-    , Unary (\a -> singular a || n < abs (size a) || (a / a) ≈ one))
+    , Unary (\a -> singular a || n < abs (normL1 a) || (a / a) ≈ one))
   , ( "recip divide: recip a ≈ one / a"
-    , Unary (\a -> singular a || n < abs (size a) || recip a ≈ one / a))
+    , Unary (\a -> singular a || n < abs (normL1 a) || recip a ≈ one / a))
   , ( "recip left: recip a * a ≈ one"
-    , Unary (\a -> singular a || n < abs (size a) || recip a * a ≈ one))
+    , Unary (\a -> singular a || n < abs (normL1 a) || recip a * a ≈ one))
   , ( "recip right: a * recip a ≈ one"
-    , Unary (\a -> singular a || n < abs (size a) || a * recip a ≈ one))
+    , Unary (\a -> singular a || n < abs (normL1 a) || a * recip a ≈ one))
   ]
 
 fieldFuzzyLaws ::
@@ -159,52 +159,52 @@
   -> [Law (r a)]
 fieldFuzzyLaws n =
   [ ( "left unital: zero + a ≈ a"
-    , Unary (\a -> n < abs (size a) || zero + a ≈ a))
+    , Unary (\a -> n < abs (normL1 a) || zero + a ≈ a))
   , ( "right unital: a + zero ≈ a"
-    , Unary (\a -> n < abs (size a) || zero + a ≈ a))
+    , Unary (\a -> n < abs (normL1 a) || zero + a ≈ a))
   , ( "associative: (a + b) + c ≈ a + (b +c)"
-    , Ternary (\a b c -> n < abs (size a) || (a + b) + c ≈ a + (b + c)))
+    , Ternary (\a b c -> n < abs (normL1 a) || (a + b) + c ≈ a + (b + c)))
   , ( "commutative a + b ≈ b + a"
-    , Binary (\a b -> n < abs (size a) || a + b ≈ b + a))
+    , Binary (\a b -> n < abs (normL1 a) || a + b ≈ b + a))
   , ( "minus: a - a ≈ zero"
-    , Unary (\a -> nearZero a || n < abs (size a) || (a - a) ≈ zero))
+    , Unary (\a -> nearZero a || n < abs (normL1 a) || (a - a) ≈ zero))
   , ( "negate minus: negate a ≈ zero - a"
-    , Unary (\a -> nearZero a || n < abs (size a) || negate a ≈ zero - a))
+    , Unary (\a -> nearZero a || n < abs (normL1 a) || negate a ≈ zero - a))
   , ( "negate left: negate a * a ≈ zero"
-    , Unary (\a -> nearZero a || n < abs (size a) || negate a + a ≈ zero))
+    , Unary (\a -> nearZero a || n < abs (normL1 a) || negate a + a ≈ zero))
   , ( "negate right: a * negate a ≈ zero"
-    , Unary (\a -> nearZero a || n < abs (size a) || a + negate a ≈ zero))
-  , ("left unital: one * a ≈ a", Unary (\a -> n < abs (size a) || one * a ≈ a))
-  , ("right unital: a * one ≈ a", Unary (\a -> n < abs (size a) || one * a ≈ a))
+    , Unary (\a -> nearZero a || n < abs (normL1 a) || a + negate a ≈ zero))
+  , ("left unital: one * a ≈ a", Unary (\a -> n < abs (normL1 a) || one * a ≈ a))
+  , ("right unital: a * one ≈ a", Unary (\a -> n < abs (normL1 a) || one * a ≈ a))
   , ( "associative: (a * b) * c ≈ a * (b *c)"
     , Ternary
         (\a b c ->
-           n < abs (size a) ||
-           n < abs (size b) || n < abs (size c) || (a * b) * c ≈ a * (b * c)))
+           n < abs (normL1 a) ||
+           n < abs (normL1 b) || n < abs (normL1 c) || (a * b) * c ≈ a * (b * c)))
   , ( "commutative a * b ≈ b * a"
-    , Binary (\a b -> n < abs (size a) || a * b ≈ b * a))
+    , Binary (\a b -> n < abs (normL1 a) || a * b ≈ b * a))
   , ( "divide: a / a ≈ one"
-    , Unary (\a -> nearZero a || n < abs (size a) || (a / a) ≈ one))
+    , Unary (\a -> nearZero a || n < abs (normL1 a) || (a / a) ≈ one))
   , ( "recip divide: recip a ≈ one / a"
-    , Unary (\a -> nearZero a || n < abs (size a) || recip a ≈ one / a))
+    , Unary (\a -> nearZero a || n < abs (normL1 a) || recip a ≈ one / a))
   , ( "recip left: recip a * a ≈ one"
-    , Unary (\a -> nearZero a || n < abs (size a) || recip a * a ≈ one))
+    , Unary (\a -> nearZero a || n < abs (normL1 a) || recip a * a ≈ one))
   , ( "recip right: a * recip a ≈ one"
-    , Unary (\a -> nearZero a || n < abs (size a) || a * recip a ≈ one))
+    , Unary (\a -> nearZero a || n < abs (normL1 a) || a * recip a ≈ one))
   , ( "left annihilation: a * zero ≈ zero"
-    , Unary (\a -> n < abs (size a) || a * zero ≈ zero))
+    , Unary (\a -> n < abs (normL1 a) || a * zero ≈ zero))
   , ( "right annihilation: zero * a ≈ zero"
-    , Unary (\a -> n < abs (size a) || zero * a ≈ zero))
+    , Unary (\a -> n < abs (normL1 a) || zero * a ≈ zero))
   , ( "left distributivity: a * (b + c) ≈ a * b + a * c"
     , Ternary
         (\a b c ->
-           n < abs (size a) ||
-           n < abs (size b) || n < abs (size c) || a * (b + c) ≈ a * b + a * c))
+           n < abs (normL1 a) ||
+           n < abs (normL1 b) || n < abs (normL1 c) || a * (b + c) ≈ a * b + a * c))
   , ( "right distributivity: (a + b) * c ≈ a * c + b * c"
     , Ternary
         (\a b c ->
-           n < abs (size a) ||
-           n < abs (size b) || n < abs (size c) || (a + b) * c ≈ a * c + b * c))
+           n < abs (normL1 a) ||
+           n < abs (normL1 b) || n < abs (normL1 c) || (a + b) * c ≈ a * c + b * c))
   ]
 
 semiringFuzzyLaws ::