This BIG PATCH contains most of the work for the New Coercion Representation

See the paper "Practical aspects of evidence based compilation in System FC"

* Coercion becomes a data type, distinct from Type

* Coercions become value-level things, rather than type-level things,
  (although the value is zero bits wide, like the State token)
  A consequence is that a coerion abstraction increases the arity by 1
  (just like a dictionary abstraction)

* There is a new constructor in CoreExpr, namely Coercion, to inject
  coercions into terms

1 files changed, 47 insertions, 0 deletions

diff --git a/compiler/utils/Pair.lhs b/compiler/utils/Pair.lhs
new file mode 100644
index 0000000000..eb594af45f
--- /dev/null
+++ b/compiler/utils/Pair.lhs
@@ -0,0 +1,47 @@
+

+A simple homogeneous pair type with useful Functor, Applicative, and

+Traversable instances.

+

+\begin{code}

+module Pair ( Pair(..), unPair, toPair, swap ) where

+

+#include "HsVersions.h"

+

+import Outputable

+import Data.Monoid

+import Control.Applicative

+import Data.Foldable

+import Data.Traversable

+

+data Pair a = Pair { pFst :: a, pSnd :: a }

+-- Note that Pair is a *unary* type constructor

+-- whereas (,) is binary

+

+-- The important thing about Pair is that it has a *homogenous*

+-- Functor instance, so you can easily apply the same function

+-- to both components

+instance Functor Pair where

+  fmap f (Pair x y) = Pair (f x) (f y)

+

+instance Applicative Pair where

+  pure x = Pair x x

+  (Pair f g) <*> (Pair x y) = Pair (f x) (g y)

+

+instance Foldable Pair where

+  foldMap f (Pair x y) = f x `mappend` f y

+

+instance Traversable Pair where

+  traverse f (Pair x y) = Pair <$> f x <*> f y

+

+instance Outputable a => Outputable (Pair a) where

+  ppr (Pair a b) = ppr a <+> char '~' <+> ppr b

+

+unPair :: Pair a -> (a,a)

+unPair (Pair x y) = (x,y)

+

+toPair :: (a,a) -> Pair a

+toPair (x,y) = Pair x y

+

+swap :: Pair a -> Pair a

+swap (Pair x y) = Pair y x

+\end{code}
\ No newline at end of file