diff --git a/Data/Array/Convert.hs b/Data/Array/Convert.hs
--- a/Data/Array/Convert.hs
+++ b/Data/Array/Convert.hs
@@ -17,6 +17,7 @@
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE TypeOperators #-}
 module Data.Array.Convert(Convert(..)) where
 import Data.Proxy
 import qualified Data.Vector as V
diff --git a/Data/Array/Internal/Dynamic.hs b/Data/Array/Internal/Dynamic.hs
--- a/Data/Array/Internal/Dynamic.hs
+++ b/Data/Array/Internal/Dynamic.hs
@@ -134,7 +134,7 @@
 shapeL :: Array a -> ShapeL
 shapeL = G.shapeL . unA
 
--- | The rank of an array, i.e., the number if dimensions it has.
+-- | The rank of an array, i.e., the number of dimensions it has.
 -- O(1) time.
 rank :: Array a -> Int
 rank = G.rank . unA
@@ -301,8 +301,8 @@
 
 -- | Extract a slice of an array.
 -- The first argument is a list of (offset, length) pairs.
--- The length of the slicing argument must not exceed the rank of the arrar.
--- The extracted slice mul fall within the array dimensions.
+-- The length of the slicing argument must not exceed the rank of the array.
+-- The extracted slice must fall within the array dimensions.
 -- E.g. @slice [1,2] (fromList [4] [1,2,3,4]) == [2,3]@.
 -- O(1) time.
 slice :: (HasCallStack) => [(Int, Int)] -> Array a -> Array a
diff --git a/Data/Array/Internal/DynamicG.hs b/Data/Array/Internal/DynamicG.hs
--- a/Data/Array/Internal/DynamicG.hs
+++ b/Data/Array/Internal/DynamicG.hs
@@ -92,7 +92,7 @@
 shapeL :: Array v a -> ShapeL
 shapeL (A s _) = s
 
--- | The rank of an array, i.e., the number if dimensions it has.
+-- | The rank of an array, i.e., the number of dimensions it has.
 -- O(1) time.
 {-# INLINE rank #-}
 rank :: Array v a -> Int
@@ -352,8 +352,8 @@
 
 -- | Extract a slice of an array.
 -- The first argument is a list of (offset, length) pairs.
--- The length of the slicing argument must not exceed the rank of the arrar.
--- The extracted slice mul fall within the array dimensions.
+-- The length of the slicing argument must not exceed the rank of the array.
+-- The extracted slice must fall within the array dimensions.
 -- E.g. @slice [1,2] (fromList [4] [1,2,3,4]) == [2,3]@.
 -- O(1) time.
 {-# INLINE slice #-}
@@ -473,7 +473,7 @@
 -- | Test if the predicate holds for all elements.
 {-# INLINE allA #-}
 allA :: (Vector v, VecElem v a) => (a -> Bool) -> Array v a -> Bool
-allA p (A sh t) = anyT sh p t
+allA p (A sh t) = allT sh p t
 
 -- | Put the dimensions of the argument into the specified dimensions,
 -- and just replicate the data along all other dimensions.
diff --git a/Data/Array/Internal/DynamicS.hs b/Data/Array/Internal/DynamicS.hs
--- a/Data/Array/Internal/DynamicS.hs
+++ b/Data/Array/Internal/DynamicS.hs
@@ -141,7 +141,7 @@
 shapeL :: Array a -> ShapeL
 shapeL = G.shapeL . unA
 
--- | The rank of an array, i.e., the number if dimensions it has.
+-- | The rank of an array, i.e., the number of dimensions it has.
 -- O(1) time.
 rank :: Array a -> Int
 rank = G.rank . unA
@@ -305,8 +305,8 @@
 
 -- | Extract a slice of an array.
 -- The first argument is a list of (offset, length) pairs.
--- The length of the slicing argument must not exceed the rank of the arrar.
--- The extracted slice mul fall within the array dimensions.
+-- The length of the slicing argument must not exceed the rank of the array.
+-- The extracted slice must fall within the array dimensions.
 -- E.g. @slice [1,2] (fromList [4] [1,2,3,4]) == [2,3]@.
 -- O(1) time.
 slice :: (HasCallStack) => [(Int, Int)] -> Array a -> Array a
diff --git a/Data/Array/Internal/DynamicU.hs b/Data/Array/Internal/DynamicU.hs
--- a/Data/Array/Internal/DynamicU.hs
+++ b/Data/Array/Internal/DynamicU.hs
@@ -138,7 +138,7 @@
 shapeL :: Array a -> ShapeL
 shapeL = G.shapeL . unA
 
--- | The rank of an array, i.e., the number if dimensions it has.
+-- | The rank of an array, i.e., the number of dimensions it has.
 -- O(1) time.
 rank :: Array a -> Int
 rank = G.rank . unA
@@ -296,8 +296,8 @@
 
 -- | Extract a slice of an array.
 -- The first argument is a list of (offset, length) pairs.
--- The length of the slicing argument must not exceed the rank of the arrar.
--- The extracted slice mul fall within the array dimensions.
+-- The length of the slicing argument must not exceed the rank of the array.
+-- The extracted slice must fall within the array dimensions.
 -- E.g. @slice [1,2] (fromList [4] [1,2,3,4]) == [2,3]@.
 -- O(1) time.
 slice :: (HasCallStack) => [(Int, Int)] -> Array a -> Array a
diff --git a/Data/Array/Internal/Ranked.hs b/Data/Array/Internal/Ranked.hs
--- a/Data/Array/Internal/Ranked.hs
+++ b/Data/Array/Internal/Ranked.hs
@@ -92,7 +92,7 @@
 shapeL :: Array n a -> ShapeL
 shapeL = G.shapeL . unA
 
--- | The rank of an array, i.e., the number if dimensions it has,
+-- | The rank of an array, i.e., the number of dimensions it has,
 -- which is the @n@ in @Array n a@.
 -- O(1) time.
 rank :: (KnownNat n) => Array n a -> Int
diff --git a/Data/Array/Internal/RankedG.hs b/Data/Array/Internal/RankedG.hs
--- a/Data/Array/Internal/RankedG.hs
+++ b/Data/Array/Internal/RankedG.hs
@@ -103,7 +103,7 @@
 shapeL :: Array n v a -> ShapeL
 shapeL (A s _) = s
 
--- | The rank of an array, i.e., the number if dimensions it has.
+-- | The rank of an array, i.e., the number of dimensions it has.
 -- O(1) time.
 {-# INLINE rank #-}
 rank :: forall n v a . (KnownNat n) => Array n v a -> Int
@@ -367,8 +367,8 @@
 
 -- | Extract a slice of an array.
 -- The first argument is a list of (offset, length) pairs.
--- The length of the slicing argument must not exceed the rank of the arrar.
--- The extracted slice mul fall within the array dimensions.
+-- The length of the slicing argument must not exceed the rank of the array.
+-- The extracted slice must fall within the array dimensions.
 -- E.g. @slice [1,2] (fromList [4] [1,2,3,4]) == [2,3]@.
 -- O(1) time.
 {-# INLINE slice #-}
@@ -489,7 +489,7 @@
 -- | Test if the predicate holds for all elements.
 {-# INLINE allA #-}
 allA :: (Vector v, VecElem v a) => (a -> Bool) -> Array r v a -> Bool
-allA p (A sh t) = anyT sh p t
+allA p (A sh t) = allT sh p t
 
 -- | Put the dimensions of the argument into the specified dimensions,
 -- and just replicate the data along all other dimensions.
diff --git a/Data/Array/Internal/RankedS.hs b/Data/Array/Internal/RankedS.hs
--- a/Data/Array/Internal/RankedS.hs
+++ b/Data/Array/Internal/RankedS.hs
@@ -95,7 +95,7 @@
 shapeL :: Array n a -> ShapeL
 shapeL = G.shapeL . unA
 
--- | The rank of an array, i.e., the number if dimensions it has,
+-- | The rank of an array, i.e., the number of dimensions it has,
 -- which is the @n@ in @Array n a@.
 -- O(1) time.
 rank :: (KnownNat n) => Array n a -> Int
@@ -108,23 +108,27 @@
 
 -- | Convert to a list with the elements in the linearization order.
 -- O(n) time.
+{-# INLINABLE toList #-}
 toList :: (Unbox a) => Array n a -> [a]
 toList = G.toList . unA
 
 -- | Convert from a list with the elements given in the linearization order.
 -- Fails if the given shape does not have the same number of elements as the list.
 -- O(n) time.
+{-# INLINABLE fromList #-}
 fromList :: (Unbox a, KnownNat n) => ShapeL -> [a] -> Array n a
 fromList ss = A . G.fromList ss
 
 -- | Convert to a vector with the elements in the linearization order.
 -- O(n) or O(1) time (the latter if the vector is already in the linearization order).
+{-# INLINABLE toVector #-}
 toVector :: (Unbox a) => Array n a -> V.Vector a
 toVector = G.toVector . unA
 
 -- | Convert from a vector with the elements given in the linearization order.
 -- Fails if the given shape does not have the same number of elements as the list.
 -- O(1) time.
+{-# INLINABLE fromVector #-}
 fromVector :: (Unbox a, KnownNat n) => ShapeL -> V.Vector a -> Array n a
 fromVector ss = A . G.fromVector ss
 
@@ -210,12 +214,14 @@
 -- | Turn a rank-1 array of arrays into a single array by making the outer array into the outermost
 -- dimension of the result array.  All the arrays must have the same shape.
 -- O(n) time.
+{-# INLINABLE ravel #-}
 ravel :: (Unbox a, KnownNat (1+n)) =>
          R.Array 1 (Array n a) -> Array (1+n) a
 ravel = A . G.ravel . G.mapA unA . R.unA
 
 -- | Turn an array into a nested array, this is the inverse of 'ravel'.
 -- I.e., @ravel . unravel == id@.
+{-# INLINABLE unravel #-}
 unravel :: (Unbox a) =>
            Array (1+n) a -> R.Array 1 (Array n a)
 unravel = R.A . G.mapA A . G.unravel . unA
@@ -259,8 +265,8 @@
 
 -- | Extract a slice of an array.
 -- The first argument is a list of (offset, length) pairs.
--- The length of the slicing argument must not exceed the rank of the arrar.
--- The extracted slice mul fall within the array dimensions.
+-- The length of the slicing argument must not exceed the rank of the array.
+-- The extracted slice must fall within the array dimensions.
 -- E.g. @slice [1,2] (fromList [4] [1,2,3,4]) == [2,3]@.
 -- O(1) time.
 slice :: [(Int, Int)] -> Array n a -> Array n a
diff --git a/Data/Array/Internal/RankedU.hs b/Data/Array/Internal/RankedU.hs
--- a/Data/Array/Internal/RankedU.hs
+++ b/Data/Array/Internal/RankedU.hs
@@ -94,7 +94,7 @@
 shapeL :: Array n a -> ShapeL
 shapeL = G.shapeL . unA
 
--- | The rank of an array, i.e., the number if dimensions it has,
+-- | The rank of an array, i.e., the number of dimensions it has,
 -- which is the @n@ in @Array n a@.
 -- O(1) time.
 rank :: (KnownNat n) => Array n a -> Int
@@ -258,8 +258,8 @@
 
 -- | Extract a slice of an array.
 -- The first argument is a list of (offset, length) pairs.
--- The length of the slicing argument must not exceed the rank of the arrar.
--- The extracted slice mul fall within the array dimensions.
+-- The length of the slicing argument must not exceed the rank of the array.
+-- The extracted slice must fall within the array dimensions.
 -- E.g. @slice [1,2] (fromList [4] [1,2,3,4]) == [2,3]@.
 -- O(1) time.
 slice :: [(Int, Int)] -> Array n a -> Array n a
diff --git a/Data/Array/Internal/Shaped.hs b/Data/Array/Internal/Shaped.hs
--- a/Data/Array/Internal/Shaped.hs
+++ b/Data/Array/Internal/Shaped.hs
@@ -92,7 +92,7 @@
 shapeL :: (Shape sh) => Array sh a -> ShapeL
 shapeL = G.shapeL . unA
 
--- | The rank of an array, i.e., the number if dimensions it has,
+-- | The rank of an array, i.e., the number of dimensions it has,
 -- which is the @n@ in @Array n a@.
 -- O(1) time.
 rank :: (Shape sh, KnownNat (Rank sh)) => Array sh a -> Int
@@ -249,8 +249,8 @@
 
 -- | Extract a slice of an array.
 -- The first argument is a list of (offset, length) pairs.
--- The length of the slicing argument must not exceed the rank of the arrar.
--- The extracted slice mul fall within the array dimensions.
+-- The length of the slicing argument must not exceed the rank of the array.
+-- The extracted slice must fall within the array dimensions.
 -- E.g. @slice [1,2] (fromList [4] [1,2,3,4]) == [2,3]@.
 -- O(1) time.
 slice :: forall sl sh' sh a .
diff --git a/Data/Array/Internal/ShapedG.hs b/Data/Array/Internal/ShapedG.hs
--- a/Data/Array/Internal/ShapedG.hs
+++ b/Data/Array/Internal/ShapedG.hs
@@ -107,7 +107,7 @@
 shapeL :: forall sh v a . (Shape sh) => Array sh v a -> ShapeL
 shapeL _ = shapeP (Proxy :: Proxy sh)
 
--- | The rank of an array, i.e., the number if dimensions it has.
+-- | The rank of an array, i.e., the number of dimensions it has.
 -- O(1) time.
 {-# INLINE rank #-}
 rank :: forall sh v a . (Shape sh, KnownNat (Rank sh)) => Array sh v a -> Int
@@ -172,14 +172,14 @@
 reshape :: forall sh' sh v a .
            (Vector v, VecElem v a, Shape sh, Shape sh', Size sh ~ Size sh') =>
            Array sh v a -> Array sh' v a
-reshape a = reshape' (shapeL a) (shapeP (Proxy :: Proxy sh')) a
+reshape a = reshape' (shapeP (Proxy :: Proxy sh')) (shapeL a) a
 
 reshape' :: (Vector v, VecElem v a) =>
             ShapeL -> ShapeL -> Array sh v a -> Array sh' v a
 reshape' sh sh' (A t@(T ost oo v))
   | vLength v == 1 = A $ T (map (const 0) sh) 0 v  -- Fast special case for singleton vector
-  | Just nst <- simpleReshape ost sh sh' = A $ T nst oo v
-  | otherwise = A $ fromVectorT sh' $ toVectorT sh t
+  | Just nst <- simpleReshape ost sh' sh = A $ T nst oo v
+  | otherwise = A $ fromVectorT sh $ toVectorT sh' t
 
 -- | Change the size of dimensions with size 1.  These dimension can be changed to any size.
 -- All other dimensions must remain the same.
@@ -430,7 +430,7 @@
 -- | Test if the predicate holds for all elements.
 {-# INLINE allA #-}
 allA :: (Vector v, VecElem v a, Shape sh) => (a -> Bool) -> Array sh v a -> Bool
-allA p a@(A t) = anyT (shapeL a) p t
+allA p a@(A t) = allT (shapeL a) p t
 
 -- | Put the dimensions of the argument into the specified dimensions,
 -- and just replicate the data along all other dimensions.
diff --git a/Data/Array/Internal/ShapedS.hs b/Data/Array/Internal/ShapedS.hs
--- a/Data/Array/Internal/ShapedS.hs
+++ b/Data/Array/Internal/ShapedS.hs
@@ -96,7 +96,7 @@
 shapeL :: (Shape sh) => Array sh a -> ShapeL
 shapeL = G.shapeL . unA
 
--- | The rank of an array, i.e., the number if dimensions it has,
+-- | The rank of an array, i.e., the number of dimensions it has,
 -- which is the @n@ in @Array n a@.
 -- O(1) time.
 rank :: (Shape sh, KnownNat (Rank sh)) => Array sh a -> Int
@@ -109,23 +109,27 @@
 
 -- | Convert to a list with the elements in the linearization order.
 -- O(n) time.
+{-# INLINABLE toList #-}
 toList :: forall sh a . (Unbox a, Shape sh) => Array sh a -> [a]
 toList = G.toList . unA
 
 -- | Convert from a list with the elements given in the linearization order.
 -- Fails if the given shape does not have the same number of elements as the list.
 -- O(n) time.
+{-# INLINABLE fromList #-}
 fromList :: forall sh a . (HasCallStack, Unbox a, Shape sh) => [a] -> Array sh a
 fromList = A . G.fromList
 
 -- | Convert to a vector with the elements in the linearization order.
 -- O(n) or O(1) time (the latter if the vector is already in the linearization order).
+{-# INLINABLE toVector #-}
 toVector :: (Unbox a, Shape sh) => Array sh a -> V.Vector a
 toVector = G.toVector . unA
 
 -- | Convert from a vector with the elements given in the linearization order.
 -- Fails if the given shape does not have the same number of elements as the list.
 -- O(1) time.
+{-# INLINABLE fromVector #-}
 fromVector :: forall sh a . (HasCallStack, Unbox a, Shape sh) => V.Vector a -> Array sh a
 fromVector = A . G.fromVector
 
@@ -136,7 +140,7 @@
 normalize :: (Unbox a, Shape sh) => Array sh a -> Array sh a
 normalize = A . G.normalize . unA
 
--- | Change the shape of an array.  Fails if the arrays have different number of elements.
+-- | Change the shape of an array.  Type error if the arrays have different number of elements.
 -- O(n) or O(1) time.
 reshape :: forall sh' sh a . (Unbox a, Shape sh, Shape sh', Size sh ~ Size sh') =>
            Array sh a -> Array sh' a
@@ -208,12 +212,14 @@
 -- | Turn a rank-1 array of arrays into a single array by making the outer array into the outermost
 -- dimension of the result array.  All the arrays must have the same shape.
 -- O(n) time.
+{-# INLINABLE ravel #-}
 ravel :: (Unbox a, Shape sh, KnownNat s) =>
          S.Array '[s] (Array sh a) -> Array (s:sh) a
 ravel = A . G.ravel . G.mapA unA . S.unA
 
 -- | Turn an array into a nested array, this is the inverse of 'ravel'.
 -- I.e., @ravel . unravel == id@.
+{-# INLINABLE unravel #-}
 unravel :: (Unbox a, Shape sh, KnownNat s) =>
            Array (s:sh) a -> S.Array '[s] (Array sh a)
 unravel = S.A . G.mapA A . G.unravel . unA
@@ -240,8 +246,8 @@
 
 -- | Extract a slice of an array.
 -- The first argument is a list of (offset, length) pairs.
--- The length of the slicing argument must not exceed the rank of the arrar.
--- The extracted slice mul fall within the array dimensions.
+-- The length of the slicing argument must not exceed the rank of the array.
+-- The extracted slice must fall within the array dimensions.
 -- E.g. @slice [1,2] (fromList [4] [1,2,3,4]) == [2,3]@.
 -- O(1) time.
 slice :: forall sl sh' sh a .
diff --git a/Data/Array/Internal/ShapedU.hs b/Data/Array/Internal/ShapedU.hs
--- a/Data/Array/Internal/ShapedU.hs
+++ b/Data/Array/Internal/ShapedU.hs
@@ -94,7 +94,7 @@
 shapeL :: (Shape sh) => Array sh a -> ShapeL
 shapeL = G.shapeL . unA
 
--- | The rank of an array, i.e., the number if dimensions it has,
+-- | The rank of an array, i.e., the number of dimensions it has,
 -- which is the @n@ in @Array n a@.
 -- O(1) time.
 rank :: (Shape sh, KnownNat (Rank sh)) => Array sh a -> Int
@@ -134,7 +134,7 @@
 normalize :: (Unbox a, Shape sh) => Array sh a -> Array sh a
 normalize = A . G.normalize . unA
 
--- | Change the shape of an array.  Fails if the arrays have different number of elements.
+-- | Change the shape of an array.  Type error if the arrays have different number of elements.
 -- O(n) or O(1) time.
 reshape :: forall sh' sh a . (Unbox a, Shape sh, Shape sh', Size sh ~ Size sh') =>
            Array sh a -> Array sh' a
@@ -238,8 +238,8 @@
 
 -- | Extract a slice of an array.
 -- The first argument is a list of (offset, length) pairs.
--- The length of the slicing argument must not exceed the rank of the arrar.
--- The extracted slice mul fall within the array dimensions.
+-- The length of the slicing argument must not exceed the rank of the array.
+-- The extracted slice must fall within the array dimensions.
 -- E.g. @slice [1,2] (fromList [4] [1,2,3,4]) == [2,3]@.
 -- O(1) time.
 slice :: forall sl sh' sh a .
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -84,6 +84,8 @@
 fromList [2,3] [1,2,3,4,5,6]
 > shapeL m
 [2,3]
+> rank m
+2
 > size m
 6
 ```
@@ -116,4 +118,135 @@
 13 14 15 16
 17 18 19 20
 21 22 23 24
+```
+
+Indexing into an array removes the outermost dimension of it by selecting a subarray with the given index.
+
+```
+> pp $ index v 1
+8
+> shapeL $ index v 1
+[]
+> pp $ index a 1
+13 14 15 16
+17 18 19 20
+21 22 23 24
+> pp $ a `index` 1 `index` 2 `index` 0
+21
+```
+
+The `scalar` and `unScalar` functions can be used to convert an element to/from and array.
+```
+> :type scalar 42
+scalar 42 :: Num a => Array a
+> :type index v 1
+index v 1 :: Num a => Array a
+> :type unScalar (index v 1)
+unScalar (index v 1) :: Num a => a
+```
+
+The `constant` function makes an array with all identical elements.
+
+```
+> pp $ constant [2,3] 8
+8 8 8
+8 8 8
+```
+
+Arrays are also instances of `Functor`, `Foldable`, and `Traversable`.
+
+```
+> pp $ fmap succ v
+ 8  9 10
+foldr (+) 0 a
+300
+```
+
+The `transpose` operation can be used to rearrange the dimensions of an array.
+The first argument describes how to transpose.
+
+```
+> shapeL a
+[2,3,4]
+> shapeL (transpose [1,0,2] a)
+[3,2,4]
+> pp $ transpose [1,0,2] a
+ 1  2  3  4
+13 14 15 16
+
+ 5  6  7  8
+17 18 19 20
+
+ 9 10 11 12
+21 22 23 24
+```
+
+The `reshape` operation keeps the elements of an array,
+but changes its shape.
+
+```
+> pp $ reshape [3,8] a
+ 1  2  3  4  5  6  7  8
+ 9 10 11 12 13 14 15 16
+17 18 19 20 21 22 23 24
+```
+
+
+
+### Similar examples using `Shaped`
+
+```
+> import Data.Array.Shaped
+> :set -XDataKinds
+> :set -XTypeApplications
+```
+
+The shape is now given by the type.
+
+```
+> m :: Array [2,3] Integer; m = fromList [1..6]
+> m
+fromList @[2,3] [1,2,3,4,5,6]
+> shapeL m
+[2,3]
+> rank m
+2
+> size m
+6
+```
+
+The type information can be given in different ways.
+
+```
+> s :: Array '[] Integer; s = fromList [42]
+> v = fromList [7,8,9] :: Array '[3] Integer
+> m = fromList @[2,3,4] [1..24]
+```
+
+There are also numeric instances for shaped arrays.
+They allow pointwise arithmetic on arrays with the same shape.
+Numeric constants are automatically of the right shape.
+
+```
+> import Data.Array.Shaped.Instances
+> pp $ v * 2
+14 16 18
+> pp $ a + a
+ 2  4  6  8
+10 12 14 16
+18 20 22 24
+
+26 28 30 32
+34 36 38 40
+42 44 46 48
+```
+
+What is value arguments for `Dynamic` arrays sometimes turn into type arguments
+for shaped arrays.
+
+```
+> pp $ reshape @[3,8] a
+ 1  2  3  4  5  6  7  8
+ 9 10 11 12 13 14 15 16
+17 18 19 20 21 22 23 24
 ```
diff --git a/orthotope.cabal b/orthotope.cabal
--- a/orthotope.cabal
+++ b/orthotope.cabal
@@ -1,5 +1,5 @@
 name:                orthotope
-version:             0.1.2.0
+version:             0.1.4.0
 synopsis:            Multidimensional arrays inspired by APL
 license:             Apache
 license-file:        LICENSE
@@ -55,12 +55,12 @@
                      , Data.Array.Internal.ShapedS
                      , Data.Array.Internal.ShapedU
 
-  build-depends:       base >= 4.12 && < 4.18
-                     , deepseq
-                     , dlist
-                     , pretty
-                     , QuickCheck
-                     , vector
+  build-depends:       base             >= 4.12 && < 4.18,
+                       QuickCheck       >= 2.14.3 && < 2.15,
+                       deepseq          >= 1.4.6 && < 1.5,
+                       pretty           >= 1.1.3 && < 1.2,
+                       dlist            >= 1.0 && < 1.1,
+                       vector           >= 0.13.0 && < 0.14
 
   default-language:    Haskell2010
 
@@ -85,9 +85,9 @@
     base,
     deepseq,
     orthotope,
-    test-framework >= 0.3.3,
-    test-framework-quickcheck2,
-    test-framework-hunit,
-    HUnit,
+    HUnit                      >= 1.6.2 && < 1.7,
+    test-framework             >= 0.8.2 && < 0.9,
+    test-framework-hunit       >= 0.3.0 && < 0.4,
+    test-framework-quickcheck2 >= 0.3.0 && < 0.4,
     QuickCheck >= 2.4.0.1,
     vector