From 9bd0e10d2c4a18c21269d520190a5d6b65b6390f Mon Sep 17 00:00:00 2001
From: Michael Orlitzky <michael@orlitzky.com>
Date: Mon, 4 Feb 2013 20:22:47 -0500
Subject: [PATCH] Clean up imports in FixedVector.hs.

---
 src/FixedVector.hs | 76 +++++++++++++++++++++++++++++-----------------
 1 file changed, 48 insertions(+), 28 deletions(-)

diff --git a/src/FixedVector.hs b/src/FixedVector.hs
index 844b9b5..1bb828d 100644
--- a/src/FixedVector.hs
+++ b/src/FixedVector.hs
@@ -8,7 +8,27 @@ module FixedVector
 where
 
 import Data.List (intercalate)
-import qualified Data.Vector.Fixed as V
+import Data.Vector.Fixed (
+  Dim,
+  Fun(..),
+  N1,
+  N2,
+  N3,
+  N4,
+  Vector(..),
+  (!),
+  construct,
+  inspect,
+  toList,
+  )
+import qualified Data.Vector.Fixed as V (
+  foldl,
+  length,
+  map,
+  replicate,
+  sum,
+  zipWith
+  )
 
 import Normed
 
@@ -18,18 +38,18 @@ newtype Vn v a = Vn (v a)
 
 -- | Declare the dimension of the wrapper to be the dimension of what
 --   it contains.
-type instance V.Dim (Vn v) = V.Dim v
+type instance Dim (Vn v) = Dim v
 
-instance (V.Vector v a) => V.Vector (Vn v) a where
+instance (Vector v a) => Vector (Vn v) a where
   -- | Fortunately, 'Fun' is an instance of 'Functor'. The
-  --   'V.construct' defined on our contained type will return a
+  --   'construct' defined on our contained type will return a
   --   'Fun', and we simply slap our constructor on top with fmap.
-  construct = fmap Vn V.construct
+  construct = fmap Vn construct
 
-  -- | Defer to the V.inspect defined on the contained type.
-  inspect (Vn v1) = V.inspect v1
+  -- | Defer to the inspect defined on the contained type.
+  inspect (Vn v1) = inspect v1
 
-instance (Show a, V.Vector v a) => Show (Vn v a) where
+instance (Show a, Vector v a) => Show (Vn v a) where
   -- | Display vectors as ordinary tuples. This is poor practice, but
   --   these results are primarily displayed interactively and
   --   convenience trumps correctness (said the guy who insists his
@@ -44,7 +64,7 @@ instance (Show a, V.Vector v a) => Show (Vn v a) where
   show (Vn v1) =
     "(" ++ (intercalate "," element_strings) ++ ")"
     where
-      v1l = V.toList v1
+      v1l = toList v1
       element_strings = Prelude.map show v1l
 
 
@@ -62,14 +82,14 @@ instance (Show a, V.Vector v a) => Show (Vn v a) where
 --   >>> v1 == v3
 --   False
 --
-instance (Eq a, V.Vector v a, V.Vector v Bool) => Eq (Vn v a) where
+instance (Eq a, Vector v a, Vector v Bool) => Eq (Vn v a) where
   (Vn v1) == (Vn v2) = V.foldl (&&) True (V.zipWith (==) v1 v2)
 
 
 -- | The use of 'Num' here is of course incorrect (otherwise, we
 --   wouldn't have to throw errors). But it's really nice to be able
 --   to use normal addition/subtraction.
-instance (Num a, V.Vector v a) => Num (Vn v a) where
+instance (Num a, Vector v a) => Num (Vn v a) where
   -- | Componentwise addition.
   --
   --   Examples:
@@ -113,7 +133,7 @@ instance (Functor v) => Functor (Vn v) where
   fmap f (Vn v1) = Vn (f `fmap` v1)
 
 
-instance (RealFloat a, Ord a, V.Vector v a) => Normed (Vn v a) where
+instance (RealFloat a, Ord a, Vector v a) => Normed (Vn v a) where
   -- | The infinity norm. We don't use V.maximum here because it
   --   relies on a type constraint that the vector be non-empty and I
   --   don't know how to pattern match it away.
@@ -151,7 +171,7 @@ instance (RealFloat a, Ord a, V.Vector v a) => Normed (Vn v a) where
 --   >>> dot v1 v2
 --   32
 --
-dot :: (Num a, V.Vector v a) => Vn v a -> Vn v a -> a
+dot :: (Num a, Vector v a) => Vn v a -> Vn v a -> a
 dot (Vn v1) (Vn v2) = V.sum $ V.zipWith (*) v1 v2
 
 
@@ -164,7 +184,7 @@ dot (Vn v1) (Vn v2) = V.sum $ V.zipWith (*) v1 v2
 --   >>> angle v1 v2 == pi/2.0
 --   True
 --
-angle :: (RealFloat a, V.Vector v a) => Vn v a -> Vn v a -> a
+angle :: (RealFloat a, Vector v a) => Vn v a -> Vn v a -> a
 angle v1 v2 =
   acos theta
   where
@@ -182,10 +202,10 @@ angle v1 v2 =
 --   >>> v1 !? 3
 --   Nothing
 --
-(!?) :: (V.Vector v a) => v a -> Int -> Maybe a
+(!?) :: (Vector v a) => v a -> Int -> Maybe a
 (!?) v1 idx
   | idx < 0 || idx >= V.length v1 = Nothing
-  | otherwise                     = Just $ v1 V.! idx
+  | otherwise                     = Just $ v1 ! idx
 
 
 
@@ -198,22 +218,22 @@ angle v1 v2 =
 -- components.
 
 data Vec2D a = Vec2D a a
-type instance V.Dim Vec2D = V.N2
-instance V.Vector Vec2D a where
-  inspect (Vec2D x y) (V.Fun f) = f x y
-  construct = V.Fun Vec2D
+type instance Dim Vec2D = N2
+instance Vector Vec2D a where
+  inspect (Vec2D x y) (Fun f) = f x y
+  construct = Fun Vec2D
 
 data Vec3D a = Vec3D a a a
-type instance V.Dim Vec3D = V.N3
-instance V.Vector Vec3D a where
-  inspect (Vec3D x y z) (V.Fun f) = f x y z
-  construct = V.Fun Vec3D
+type instance Dim Vec3D = N3
+instance Vector Vec3D a where
+  inspect (Vec3D x y z) (Fun f) = f x y z
+  construct = Fun Vec3D
 
 data Vec4D a = Vec4D a a a a
-type instance V.Dim Vec4D = V.N4
-instance V.Vector Vec4D a where
-  inspect (Vec4D w x y z) (V.Fun f) = f w x y z
-  construct = V.Fun Vec4D
+type instance Dim Vec4D = N4
+instance Vector Vec4D a where
+  inspect (Vec4D w x y z) (Fun f) = f w x y z
+  construct = Fun Vec4D
 
 
 -- | Convenience function for creating 2d vectors.
-- 
2.43.2