diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+# 0.1.3
+
+GHC-8.0.1 compatibility
+
 # 0.1.2.1
 
 Improved documentation based on suggestions by Alexander Kjeldaas
diff --git a/Frames.cabal b/Frames.cabal
--- a/Frames.cabal
+++ b/Frames.cabal
@@ -1,5 +1,5 @@
 name:                Frames
-version:             0.1.2.1
+version:             0.1.3
 synopsis:            Data frames For working with tabular data files
 description:         User-friendly, type safe, runtime efficient tooling for
                      working with tabular data deserialized from
@@ -18,6 +18,7 @@
                      demo/Main.hs CHANGELOG.md
                      data/GetData.hs
 cabal-version:       >=1.10
+tested-with:         GHC == 7.10.3, GHC == 8.0.1
 
 source-repository head
   type:     git
@@ -47,8 +48,8 @@
                        TypeOperators, ConstraintKinds, StandaloneDeriving,
                        UndecidableInstances, ScopedTypeVariables,
                        OverloadedStrings
-  build-depends:       base >=4.7 && <4.9,
-                       ghc-prim >=0.3 && <0.5,
+  build-depends:       base >=4.7 && <4.10,
+                       ghc-prim >=0.3 && <0.6,
                        primitive >= 0.6 && < 0.7,
                        text >= 1.1.1.0,
                        template-haskell,
@@ -82,8 +83,8 @@
                    lens-family-core, vector, text,
                    template-haskell,
                    pipes >= 4.1.5 && < 4.2, 
-                   Chart >= 1.5 && < 1.6,
-                   Chart-diagrams >= 1.5 && < 1.6,
+                   Chart >= 1.5 && < 1.8,
+                   Chart-diagrams >= 1.5 && < 1.8,
                    diagrams-rasterific >= 1.3 && < 1.4,
                    diagrams-lib >= 1.3 && < 1.4,
                    readable, containers, statistics
@@ -98,8 +99,8 @@
     build-depends: base, Frames,
                    lens-family-core, vector, text, template-haskell,
                    pipes >= 4.1.5 && < 4.2,
-                   Chart >= 1.5 && < 1.6,
-                   Chart-diagrams >= 1.5 && < 1.6,
+                   Chart >= 1.5 && < 1.8,
+                   Chart-diagrams >= 1.5 && < 1.8,
                    diagrams-rasterific >= 1.3 && < 1.4,
                    diagrams-lib >= 1.3 && < 1.4, 
                    readable, containers, statistics
@@ -126,7 +127,7 @@
   if flag(demos)
     build-depends: base, Frames,
                    lens-family-core, vector, text, template-haskell, readable,
-                   foldl >= 1.1.0 && < 1.2,
+                   foldl >= 1.1.0 && < 1.3,
                    pipes >= 4.1.5 && < 4.2
   hs-source-dirs: demo
   default-language: Haskell2010
@@ -138,7 +139,7 @@
   main-is:          BenchDemo.hs
   if flag(demos)
     build-depends:    base, Frames, lens-family-core,
-                      foldl >= 1.1.0 && < 1.2,
+                      foldl >= 1.1.0 && < 1.3,
                       pipes >= 4.1.5 && < 4.2
   hs-source-dirs:   benchmarks
   default-language: Haskell2010
@@ -162,5 +163,15 @@
   main-is:          InsuranceBench.hs
   build-depends:    base, criterion, Frames, lens-family-core, transformers,
                     pipes >= 4.1.5 && < 4.2
-  ghc-options:      -O2 -fllvm
+  ghc-options:      -O2
+  default-language: Haskell2010
+
+-- Demonstration of tab-separated value parsing
+executable kata04
+  if !flag(demos)
+    buildable: False
+  main-is: Kata04.hs
+  if flag(demos)
+    build-depends: base, Frames, vinyl, text, readable
+  hs-source-dirs: demo
   default-language: Haskell2010
diff --git a/demo/Kata04.hs b/demo/Kata04.hs
new file mode 100644
--- /dev/null
+++ b/demo/Kata04.hs
@@ -0,0 +1,57 @@
+{-# LANGUAGE DataKinds, FlexibleContexts, OverloadedStrings,
+             TemplateHaskell, TypeFamilies, TypeOperators,
+             MultiParamTypeClasses, ScopedTypeVariables,
+             FlexibleContexts, FlexibleInstances #-}
+module Main where
+import qualified Data.Foldable as F
+import Data.Ord (comparing)
+import Data.Proxy
+import qualified Data.Text as T
+import qualified Data.Text.IO as T
+import Data.Vinyl.Functor (Identity(..))
+import Data.Vinyl.TypeLevel (Nat(..))
+import Frames
+
+-- Data set from http://codekata.com/data/04/weather.dat
+-- Associated with this problem set:
+-- http://codekata.com/kata/kata04-data-munging/
+tableTypes "Row" "data/weather.csv"
+
+getTemperatureRange :: (MxT ∈ rs, MnT ∈ rs) => Record rs -> Double
+getTemperatureRange row = rget mxT row - rget mnT row
+
+partOne :: IO T.Text
+partOne = do tbl <- inCoreAoS (readTable "data/weather.csv") :: IO (Frame Row)
+             return $ rget dy (F.maximumBy (comparing getTemperatureRange) tbl)
+
+
+-- shapr: Fight the dying of the light!
+
+type family Find i xs where
+  Find 'Z ((s :-> x) ': xs) = x
+  Find ('S i) (x ': xs) = Find i xs
+
+class GetFieldByIndex i rs where
+  getFieldByIndex :: proxy i -> Record rs -> Find i rs
+
+instance GetFieldByIndex 'Z ((s :-> r) ': rs) where
+  getFieldByIndex _ (Identity x :& _) = x
+
+instance GetFieldByIndex i rs => GetFieldByIndex ('S i) ((s :-> r) ': rs) where
+  getFieldByIndex _ (_ :& xs) = getFieldByIndex (Proxy :: Proxy i) xs
+
+getTemperatureRange' :: (GetFieldByIndex (S Z) rs, GetFieldByIndex (S (S Z)) rs,
+                         Find (S Z) rs ~ Double, Find (S (S Z)) rs ~ Double )
+                     => Record rs -> Double
+getTemperatureRange' row = mx - mn
+  where mx = getFieldByIndex (Proxy::Proxy ('S 'Z)) row
+        mn = getFieldByIndex (Proxy::Proxy ('S ('S 'Z))) row
+
+partOne' :: IO T.Text
+partOne' = do tbl <- inCoreAoS (readTable "data/weather.csv") :: IO (Frame Row)
+              return . getFieldByIndex (Proxy::Proxy Z) $
+                F.maximumBy (comparing getTemperatureRange') tbl
+
+main :: IO ()
+main = do partOne >>= T.putStrLn
+          partOne' >>= T.putStrLn
diff --git a/src/Frames/CSV.hs b/src/Frames/CSV.hs
--- a/src/Frames/CSV.hs
+++ b/src/Frames/CSV.hs
@@ -369,14 +369,37 @@
 
 -- * Customized Data Set Parsing
 
--- | Generate a type for a row a table. This will be something like
--- @Record ["x" :-> a, "y" :-> b, "z" :-> c]@.  Column type synonyms are
--- /not/ generated (see 'tableTypes'').
+-- | Generate a type for a row of a table. This will be something like
+-- @Record ["x" :-> a, "y" :-> b, "z" :-> c]@.  Column type synonyms
+-- are /not/ generated (see 'tableTypes'').
 tableType' :: forall a. (ColumnTypeable a, Monoid a)
            => RowGen a -> FilePath -> DecsQ
 tableType' (RowGen {..}) csvFile =
     pure . TySynD (mkName rowTypeName) [] <$>
     (runIO (readColHeaders opts csvFile) >>= recDec')
+  where recDec' = recDec :: [(T.Text, a)] -> Q Type
+        colNames' | null columnNames = Nothing
+                  | otherwise = Just (map T.pack columnNames)
+        opts = ParserOptions colNames' separator (RFC4180Quoting '\"')
+
+-- | Generate a type for a row of a table all of whose columns remain
+-- unparsed 'Text' values.
+tableTypesText' :: forall a. (ColumnTypeable a, Monoid a)
+                => RowGen a -> FilePath -> DecsQ
+tableTypesText' (RowGen {..}) csvFile =
+  do colNames <- runIO $ withFile csvFile ReadMode $ \h ->
+       maybe (tokenizeRow opts <$> T.hGetLine h)
+             pure
+             (headerOverride opts)
+     let headers = zip colNames (repeat (inferType " "))
+     recTy <- tySynD (mkName rowTypeName) [] (recDec' headers)
+     let optsName = case rowTypeName of
+                      [] -> error "Row type name shouldn't be empty"
+                      h:t -> mkName $ toLower h : t ++ "Parser"
+     optsTy <- sigD optsName [t|ParserOptions|]
+     optsDec <- valD (varP optsName) (normalB $ lift opts) []
+     colDecs <- concat <$> mapM (uncurry $ colDec (T.pack tablePrefix)) headers
+     return (recTy : optsTy : optsDec : colDecs)
   where recDec' = recDec :: [(T.Text, a)] -> Q Type
         colNames' | null columnNames = Nothing
                   | otherwise = Just (map T.pack columnNames)
diff --git a/src/Frames/CoRec.hs b/src/Frames/CoRec.hs
--- a/src/Frames/CoRec.hs
+++ b/src/Frames/CoRec.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE BangPatterns,
              ConstraintKinds,
+             CPP,
              DataKinds,
              FlexibleContexts,
              FlexibleInstances,
@@ -23,11 +24,15 @@
 import Data.Maybe(fromJust)
 import Data.Proxy
 import Data.Vinyl
-import Data.Vinyl.Functor (Compose(..), (:.), Identity(..))
-import Data.Vinyl.TypeLevel (RIndex)
+import Data.Vinyl.Functor (Compose(..), (:.), Identity(..), Const(..))
+import Data.Vinyl.TypeLevel (RIndex, RecAll)
 import Frames.RecF (reifyDict)
 import Frames.TypeLevel (LAll, HasInstances, AllHave)
+#if __GLASGOW_HASKELL__ < 800
 import GHC.Prim (Constraint)
+#else
+import Data.Kind (Constraint)
+#endif
 
 -- | Generalize algebraic sum types.
 data CoRec :: (* -> *) -> [*] -> * where
@@ -54,6 +59,21 @@
           shower = reifyDict (Proxy::Proxy Show) (Op show)
           show' = runOp (rget Proxy shower)
 
+instance forall ts. (RecAll Maybe ts Eq, RecApplicative ts)
+  => Eq (CoRec Identity ts) where
+  crA == crB = and . recordToList
+             $ zipRecsWith f (toRec crA) (corecToRec' crB)
+    where
+      f :: forall a. (Dict Eq :. Maybe) a -> Maybe a -> Const Bool a
+      f (Compose (Dict a)) b = Const $ a == b
+      toRec = reifyConstraint (Proxy :: Proxy Eq) . corecToRec'
+
+-- | 'zipWith' for Rec's.
+zipRecsWith :: (forall a. f a -> g a -> h a) -> Rec f as -> Rec g as -> Rec h as
+zipRecsWith _ RNil      _         = RNil
+zipRecsWith f (r :& rs) (s :& ss) = f r s :& zipRecsWith f rs ss
+
+
 -- | Remove a 'Dict' wrapper from a value.
 dictId :: Dict c a -> Identity a
 dictId (Dict x) = Identity x
@@ -191,10 +211,10 @@
 match'      :: RecApplicative ts => CoRec Identity ts -> Handlers ts b -> Maybe b
 match' c hs = match'' hs $ corecToRec' c
   where
-    match''                            :: Handlers ts b -> Rec Maybe ts -> Maybe b
-    match'' RNil        RNil           = Nothing
-    match'' (H f :& _)  (Just x  :& _) = Just $ f x
-    match'' (H _ :& fs) (Nothing :& c) = match'' fs c
+    match''                             :: Handlers ts b -> Rec Maybe ts -> Maybe b
+    match'' RNil        RNil            = Nothing
+    match'' (H f :& _)  (Just x  :& _)  = Just $ f x
+    match'' (H _ :& fs) (Nothing :& c') = match'' fs c'
 
 
 -- | Newtype around functions for a to b
diff --git a/src/Frames/Col.hs b/src/Frames/Col.hs
--- a/src/Frames/Col.hs
+++ b/src/Frames/Col.hs
@@ -1,11 +1,14 @@
-{-# LANGUAGE DataKinds,
+{-# LANGUAGE CPP,
+             DataKinds,
              GeneralizedNewtypeDeriving,
              KindSignatures,
              ScopedTypeVariables,
              TypeOperators #-}
 -- | Column types
 module Frames.Col where
+#if __GLASGOW_HASKELL__ < 800
 import Data.Monoid
+#endif
 import Data.Proxy
 import GHC.TypeLits
 
diff --git a/src/Frames/ColumnTypeable.hs b/src/Frames/ColumnTypeable.hs
--- a/src/Frames/ColumnTypeable.hs
+++ b/src/Frames/ColumnTypeable.hs
@@ -18,8 +18,8 @@
   -- returns 'Just Possibly' if a value can be read, but is likely
   -- ambiguous (e.g. an empty string); returns 'Just Definitely' if a
   -- value can be read and is unlikely to be ambiguous."
-  parse :: (Functor m, MonadPlus m) => T.Text -> m (Parsed a)
-  default parse :: (Readable a, Functor m, MonadPlus m)
+  parse :: MonadPlus m => T.Text -> m (Parsed a)
+  default parse :: (Readable a, MonadPlus m)
                 => T.Text -> m (Parsed a)
   parse = fmap Definitely . fromText
   {-# INLINE parse #-}
@@ -31,7 +31,7 @@
 
 -- | Acts just like 'fromText': tries to parse a value from a 'T.Text'
 -- and discards any estimate of the parse's ambiguity.
-parse' :: (Functor m, MonadPlus m, Parseable a) => T.Text -> m a
+parse' :: (MonadPlus m, Parseable a) => T.Text -> m a
 parse' = fmap discardConfidence . parse
 
 instance Parseable Bool where
diff --git a/src/Frames/ColumnUniverse.hs b/src/Frames/ColumnUniverse.hs
--- a/src/Frames/ColumnUniverse.hs
+++ b/src/Frames/ColumnUniverse.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE BangPatterns,
              ConstraintKinds,
+             CPP,
              DataKinds,
              FlexibleContexts,
              FlexibleInstances,
@@ -19,7 +20,9 @@
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 module Frames.ColumnUniverse (CoRec, Columns, ColumnUniverse, CommonColumns) where
 import Language.Haskell.TH
+#if __GLASGOW_HASKELL__ < 800
 import Data.Monoid
+#endif
 import Data.Proxy
 import qualified Data.Text as T
 import Data.Typeable (Typeable, showsTypeRep, typeRep)
diff --git a/src/Frames/Frame.hs b/src/Frames/Frame.hs
--- a/src/Frames/Frame.hs
+++ b/src/Frames/Frame.hs
@@ -1,9 +1,10 @@
-{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE CPP, TypeOperators #-}
 -- | A 'Frame' is a finite 'Int'-indexed collection of rows.
 module Frames.Frame where
-import Control.Applicative
 import Data.Foldable
+#if __GLASGOW_HASKELL__ < 800
 import Data.Monoid
+#endif
 import qualified Data.Vector as V
 import Data.Vinyl.TypeLevel
 import Frames.Rec (Record)
diff --git a/src/Frames/InCore.hs b/src/Frames/InCore.hs
--- a/src/Frames/InCore.hs
+++ b/src/Frames/InCore.hs
@@ -1,4 +1,5 @@
 {-# LANGUAGE BangPatterns,
+             CPP,
              DataKinds,
              EmptyCase,
              FlexibleInstances,
@@ -9,7 +10,6 @@
              UndecidableInstances #-}
 -- | Efficient in-memory (in-core) storage of tabular data.
 module Frames.InCore where
-import Control.Applicative
 import Control.Monad.Primitive
 import Control.Monad.ST (runST)
 import Data.Proxy
@@ -24,7 +24,9 @@
 import Frames.Frame
 import Frames.Rec
 import Frames.RecF
+#if __GLASGOW_HASKELL__ < 800
 import GHC.Prim (RealWorld)
+#endif
 import qualified Pipes as P
 import qualified Pipes.Prelude as P
 
@@ -60,12 +62,12 @@
 -- | Tooling to allocate, grow, write to, freeze, and index into
 -- records of vectors.
 class RecVec rs where
-  allocRec   :: (Applicative m, PrimMonad m)
+  allocRec   :: PrimMonad m
              => proxy rs -> m (Record (VectorMs m rs))
-  freezeRec  :: (Applicative m, PrimMonad m)
+  freezeRec  :: PrimMonad m
              => proxy rs -> Int -> Record (VectorMs m rs)
              -> m (Record (Vectors rs))
-  growRec    :: (Applicative m, PrimMonad m)
+  growRec    :: PrimMonad m
              => proxy rs -> Record (VectorMs m rs) -> m (Record (VectorMs m rs))
   writeRec   :: PrimMonad m
              => proxy rs -> Int -> Record (VectorMs m rs) -> Record rs -> m ()
@@ -82,27 +84,34 @@
   {-# INLINE allocRec #-}
 
   freezeRec _ _ V.RNil = return V.RNil
+#if __GLASGOW_HASKELL__ < 800
   freezeRec _ _ x = case x of
+#endif
   {-# INLINE freezeRec #-}
 
   growRec _ V.RNil = return V.RNil
+#if __GLASGOW_HASKELL__ < 800
   growRec _ x = case x of
+#endif
   {-# INLINE growRec #-}
 
   indexRec _ _ _ = V.RNil
   {-# INLINE indexRec #-}
 
   writeRec _ _ V.RNil V.RNil = return ()
+#if __GLASGOW_HASKELL__ < 800
   writeRec _ _ x _ = case x of
+#endif
   {-# INLINE writeRec #-}
 
   produceRec _ V.RNil = V.RNil
+#if __GLASGOW_HASKELL__ < 800
   produceRec _ x = case x of
+#endif
   {-# INLINE produceRec #-}
 
 instance forall s a rs.
   (VGM.MVector (VectorMFor a) a,
-   VG.Mutable (VectorFor a) ~ VectorMFor a,
    VG.Vector (VectorFor a) a,
    RecVec rs)
   => RecVec (s :-> a ': rs) where
@@ -112,27 +121,37 @@
   freezeRec _ n (Identity (Col x) V.:& xs) =
     (&:) <$> (VG.unsafeFreeze $ VGM.unsafeSlice 0 n x)
          <*> freezeRec (Proxy::Proxy rs) n xs
+#if __GLASGOW_HASKELL__ < 800
   freezeRec _ _ x = case x of
+#endif
   {-# INLINE freezeRec #-}
 
   growRec _ (Identity (Col x) V.:& xs) = (&:) <$> VGM.grow x (VGM.length x)
                                               <*> growRec (Proxy :: Proxy rs) xs
+#if __GLASGOW_HASKELL__ < 800
   growRec _ x = case x of
+#endif
   {-# INLINE growRec #-}
 
   writeRec _ !i !(Identity (Col v) V.:& vs) (Identity (Col x) V.:& xs) =
     VGM.unsafeWrite v i x >> writeRec (Proxy::Proxy rs) i vs xs
+#if __GLASGOW_HASKELL__ < 800
   writeRec _ _ _ x = case x of
+#endif
   {-# INLINE writeRec #-}
 
   indexRec _ !i !(Identity (Col x) V.:& xs) =
     x VG.! i &: indexRec (Proxy :: Proxy rs) i xs
+#if __GLASGOW_HASKELL__ < 800
   indexRec _ _ x = case x of
+#endif
   {-# INLINE indexRec #-}
 
   produceRec _ (Identity (Col v) V.:& vs) = frameCons (v VG.!) $
                                             produceRec (Proxy::Proxy rs) vs
+#if __GLASGOW_HASKELL__ < 800
   produceRec _ x = case x of
+#endif
   {-# INLINE produceRec #-}
 
 -- | Stream a finite sequence of rows into an efficient in-memory
@@ -143,7 +162,7 @@
 -- indexing functions. See 'toAoS' to convert the result to a 'Frame'
 -- which provides an easier-to-use function that indexes into the
 -- table in a row-major fashion.
-inCoreSoA :: forall m rs. (Applicative m, PrimMonad m, RecVec rs)
+inCoreSoA :: forall m rs. (PrimMonad m, RecVec rs)
           => P.Producer (Record rs) m () -> m (Int, V.Rec ((->) Int) rs)
 inCoreSoA xs =
   do mvs <- allocRec (Proxy :: Proxy rs)
@@ -164,13 +183,13 @@
 -- resulting generators a matter of indexing into a densely packed
 -- representation. Returns a 'Frame' that provides a function to index
 -- into the table.
-inCoreAoS :: (Applicative m, PrimMonad m, RecVec rs)
+inCoreAoS :: (PrimMonad m, RecVec rs)
           => P.Producer (Record rs) m () -> m (FrameRec rs)
 inCoreAoS = fmap (uncurry toAoS) . inCoreSoA
 
 -- | Like 'inCoreAoS', but applies the provided function to the record
 -- of columns before building the 'Frame'.
-inCoreAoS' :: (Applicative m, PrimMonad m, RecVec rs)
+inCoreAoS' :: (PrimMonad m, RecVec rs)
            => (V.Rec ((->) Int) rs -> V.Rec ((->) Int) ss)
            -> P.Producer (Record rs) m () -> m (FrameRec ss)
 inCoreAoS' f = fmap (uncurry toAoS . aux) . inCoreSoA
@@ -187,7 +206,7 @@
 -- table will be stored optimally based on its type, making use of the
 -- resulting generator a matter of indexing into a densely packed
 -- representation.
-inCore :: forall m n rs. (Applicative m, PrimMonad m, RecVec rs, Monad n)
+inCore :: forall m n rs. (PrimMonad m, RecVec rs, Monad n)
        => P.Producer (Record rs) m () -> m (P.Producer (Record rs) n ())
 inCore xs =
   do mvs <- allocRec (Proxy :: Proxy rs)
diff --git a/src/Frames/RecF.hs b/src/Frames/RecF.hs
--- a/src/Frames/RecF.hs
+++ b/src/Frames/RecF.hs
@@ -1,4 +1,5 @@
 {-# LANGUAGE ConstraintKinds,
+             CPP,
              DataKinds,
              FlexibleContexts,
              FlexibleInstances,
@@ -17,7 +18,6 @@
                     UnColumn, AsVinyl(..), mapMono, mapMethod,
                     ShowRec, showRec, ColFun, ColumnHeaders, 
                     columnHeaders, reifyDict) where
-import Control.Applicative
 import Data.List (intercalate)
 import Data.Proxy
 import qualified Data.Vinyl as V
@@ -49,7 +49,10 @@
 frameSnoc r x = V.rappend r (x V.:& RNil)
 {-# INLINE frameSnoc #-}
 
+-- Nil :: Rec f '[]
 pattern Nil = V.RNil
+
+-- (:&) :: Functor f => f r -> Rec f rs -> Rec f (r ': rs)
 pattern x :& xs <- (frameUncons -> (x, xs))
 
 -- NOTE: A bidirectional pattern synonym would be great, but we'll
@@ -94,7 +97,9 @@
 instance AsVinyl ts => AsVinyl (s :-> t ': ts) where
   toVinyl (x V.:& xs) = fmap getCol x V.:& toVinyl xs
   fromVinyl (x V.:& xs) = fmap Col x V.:& fromVinyl xs
+#if __GLASGOW_HASKELL__ < 800
   fromVinyl _ = error "GHC coverage checker isn't great"
+#endif
 
 -- | Map a function across a homogeneous, monomorphic 'V.Rec'.
 mapMonoV :: (Functor f, AllAre a ts) => (a -> a) -> V.Rec f ts -> V.Rec f ts
diff --git a/src/Frames/TypeLevel.hs b/src/Frames/TypeLevel.hs
--- a/src/Frames/TypeLevel.hs
+++ b/src/Frames/TypeLevel.hs
@@ -1,7 +1,11 @@
-{-# LANGUAGE DataKinds, TypeFamilies, TypeOperators #-}
+{-# LANGUAGE CPP, DataKinds, TypeFamilies, TypeOperators #-}
 -- | Helpers for working with type-level lists.
 module Frames.TypeLevel where
+#if __GLASGOW_HASKELL__ < 800
 import GHC.Prim (Constraint)
+#else
+import Data.Kind (Constraint)
+#endif
 
 -- | Remove the first occurence of a type from a type-level list.
 type family RDelete r rs where