Mostly finished refactoring (still needs language/import cleanups bef…

…ore merge, plus review)

diagrams-lib.cabal

@@ -55,6 +55,7 @@ Library
                        Diagrams.Query,
                        Diagrams.TwoD,
                        Diagrams.TwoD.Types,
+                       Diagrams.TwoD.Types.Double,
                        Diagrams.TwoD.Align,
                        Diagrams.TwoD.Arrow,
                        Diagrams.TwoD.Arrowheads,
@@ -85,6 +86,7 @@ Library
                        Diagrams.ThreeD.Shapes,
                        Diagrams.ThreeD.Transform,
                        Diagrams.ThreeD.Types,
+                       Diagrams.ThreeD.Types.Double,
                        Diagrams.ThreeD.Vector,
                        Diagrams.ThreeD,
                        Diagrams.Animation,
@@ -116,6 +118,7 @@ Library
   if impl(ghc < 7.6)
     Build-depends: ghc-prim
   Hs-source-dirs:      src
+  ghc-options: -Wall -Werror
   default-language:    Haskell2010
   -- default-extensions: FlexibleContexts, FlexibleInstances, MultiParamTypeClasses, TypeFamilies
   other-extensions: BangPatterns, CPP, DefaultSignatures, DeriveDataTypeable, DeriveFunctor, DeriveGeneric, EmptyDataDecls, ExistentialQuantification, GADTs, 

src/Diagrams/Angle.hs

@@ -26,13 +26,14 @@ module Diagrams.Angle
        , HasPhi(..)
        ) where
 
-import Control.Lens            (Iso', Lens', iso, review, (^.))
+import Control.Lens            (Iso', Lens', iso, review)
 
 import Data.Monoid      hiding ((<>))
 import Data.Semigroup
 import Data.VectorSpace
 
 import Diagrams.Core.V
+import Diagrams.Points
 
 -- | Angles can be expressed in a variety of units.  Internally,
 -- they are represented in radians.
@@ -136,3 +137,10 @@ class HasTheta t where
 class HasPhi t where
     _phi :: Lens' t (Angle (Scalar (V t)))
 
+-- Point instances
+instance (HasTheta v, v ~ V v) => HasTheta (Point v) where
+    _theta = _pIso . _theta
+
+instance (HasPhi v, v ~ V v) => HasPhi (Point v) where
+    _phi = _pIso . _phi
+

src/Diagrams/Animation.hs

@@ -1,6 +1,7 @@
 {-# LANGUAGE FlexibleContexts      #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE TypeFamilies          #-}
+{-# LANGUAGE ConstraintKinds, TypeFamilies, FlexibleContexts #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Diagrams.Animation
@@ -109,18 +110,18 @@ animEnvelope' r a = withEnvelope (simulate r a) <$> a
 --
 --   Uses 30 samples per time unit by default; to adjust this number
 --   see 'animRect''.
-animRect :: (TrailLike t, Enveloped t, Transformable t, Monoid t, V t ~ R2
+animRect :: (TrailLike t, Enveloped t, Transformable t, Monoid t, V t ~ v, R2Ish v
             , Monoid' m)
-         => QAnimation b R2 m -> t
+         => QAnimation b v m -> t
 animRect = animRect' 30
 
 -- | Like 'animRect', but with an adjustible sample rate.  The first
 --   parameter is the number of samples per time unit to use.  Lower
 --   rates will be faster but less accurate; higher rates are more
 --   accurate but slower.
-animRect' :: (TrailLike t, Enveloped t, Transformable t, Monoid t, V t ~ R2
+animRect' :: (TrailLike t, Enveloped t, Transformable t, Monoid t, V t ~ v, R2Ish v
              , Monoid' m)
-          => Rational -> QAnimation b R2 m -> t
+          => Rational -> QAnimation b v m -> t
 animRect' r anim
     | null results = rect 1 1
     | otherwise    = boxFit (foldMap boundingBox results) (rect 1 1)

src/Diagrams/Coordinates.hs

@@ -23,17 +23,10 @@ module Diagrams.Coordinates
 import           Control.Lens          (Lens')
 import           Data.VectorSpace
 
-import           Diagrams.Core.Points
+import           Diagrams.Points
+import           Data.AffineSpace.Point
 import           Diagrams.Core.V
 
--- | A pair of values, with a convenient infix (left-associative)
---   data constructor.
-data a :& b = a :& b
-  deriving (Eq, Ord, Show)
-
-infixl 7 :&
-
-
 -- | Types which are instances of the @Coordinates@ class can be
 --   constructed using '^&' (for example, a three-dimensional vector
 --   could be constructed by @1 ^& 6 ^& 3@), and deconstructed using
@@ -78,14 +71,30 @@ class Coordinates c where
 
 infixl 7 ^&
 
+-- | A pair of values, with a convenient infix (left-associative)
+--   data constructor.
+data a :& b = a :& b
+  deriving (Eq, Ord, Show)
+
+infixl 7 :&
+
+-- Instance for :& (the buck stops here)
+instance Coordinates (a :& b) where
+  type FinalCoord (a :& b) = b
+  type PrevDim (a :& b) = a
+  type Decomposition (a :& b) = a :& b
+  x ^& y                    = x :& y
+  coords (x :& y)           = x :& y
+
+
 -- Some standard instances for plain old tuples
 
 instance Coordinates (a,b) where
   type FinalCoord (a,b)    = b
   type PrevDim (a,b)       = a
   type Decomposition (a,b) = a :& b
 
-  x ^& y                    = (x,y)
+  x ^& y                   = (x,y)
   coords (x,y)             = x :& y
 
 instance Coordinates (a,b,c) where
@@ -128,3 +137,16 @@ class HasZ t where
 -- magnitude of a vector, or the distance from the origin of a point.
 class HasR t where
     _r :: Lens' t (Scalar (V t))
+
+instance (HasX v, v ~ V v) => HasX (Point v) where
+    _x = _pIso . _x
+
+instance (HasY v, v ~ V v) => HasY (Point v) where
+    _y = _pIso . _y
+
+instance (HasZ v, v ~ V v) => HasZ (Point v) where
+    _z = _pIso . _z
+
+instance (HasR v, v ~ V v) => HasR (Point v) where
+    _r = _pIso . _r
+

src/Diagrams/Points.hs

@@ -20,17 +20,22 @@ module Diagrams.Points
          -- * Point-related utilities
        , centroid
        , pointDiagram
-
+       , _pIso
        ) where
 
 import           Diagrams.Core          (pointDiagram)
 import           Diagrams.Core.Points
 
 import           Control.Arrow          ((&&&))
+import           Control.Lens           (Iso', iso)
 
 import           Data.AffineSpace.Point
 import           Data.VectorSpace
 
+-- Point v <-> v
+_pIso :: Iso' (Point v) v
+_pIso = iso unPoint P
+
 -- | The centroid of a set of /n/ points is their sum divided by /n/.
 centroid :: (VectorSpace v, Fractional (Scalar v)) => [Point v] -> Point v
 centroid = P . uncurry (^/) . (sumV &&& (fromIntegral . length)) . map unPoint

src/Diagrams/Tangent.hs

@@ -23,7 +23,6 @@ module Diagrams.Tangent
     , normalAtStart
     , normalAtEnd
     , Tangent(..)
-    , MoreLikeR2
     )
     where
 
@@ -35,7 +34,8 @@ import           Diagrams.Located
 import           Diagrams.Parametric
 import           Diagrams.Segment
 import           Diagrams.Trail
-import           Diagrams.TwoD.Vector (perp, LikeR2)
+import           Diagrams.TwoD.Vector (perp)
+import           Diagrams.TwoD.Types  (R2Ish)
 
 ------------------------------------------------------------
 -- Tangent
@@ -157,8 +157,6 @@ instance ( InnerSpace v
 -- Normal
 ------------------------------------------------------------
 
-type MoreLikeR2 v = (LikeR2 v, InnerSpace v, Floating (Scalar v))
-
 -- | Compute the (unit) normal vector to a segment or trail at a
 --   particular parameter.
 --
@@ -172,22 +170,22 @@ type MoreLikeR2 v = (LikeR2 v, InnerSpace v, Floating (Scalar v))
 --
 --   See the instances listed for the 'Tangent' newtype for more.
 normalAtParam
-  :: (MoreLikeR2 (Codomain (Tangent t)), Parametric (Tangent t))
+  :: (R2Ish (Codomain (Tangent t)), Parametric (Tangent t))
   => t -> Scalar (V t) -> Codomain (Tangent t)
 normalAtParam t p = normize (t `tangentAtParam` p)
 
 -- | Compute the normal vector at the start of a segment or trail.
 normalAtStart
-  :: (MoreLikeR2 (Codomain (Tangent t)), EndValues (Tangent t))
+  :: (R2Ish (Codomain (Tangent t)), EndValues (Tangent t))
   => t -> Codomain (Tangent t)
 normalAtStart = normize . tangentAtStart
 
 -- | Compute the normal vector at the end of a segment or trail.
 normalAtEnd
-  :: (MoreLikeR2 (Codomain (Tangent t)), EndValues (Tangent t))
+  :: (R2Ish (Codomain (Tangent t)), EndValues (Tangent t))
   => t -> Codomain (Tangent t)
 normalAtEnd = normize . tangentAtEnd
 
 -- | Construct a normal vector from a tangent.
-normize :: (MoreLikeR2 v) => v -> v
+normize :: (R2Ish v) => v -> v
 normize = negateV . perp . normalized