diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,11 @@
 # Changelog for interval-algebra
 
+## 0.8.1
+
+* Generalizes `gaps`, `gapsWithin`, and `combineIntervals` to take general `Intervallic` inputs but still return `Interval`s.
+* Relaxes the `Show a` constraint on `Intervallic` class.
+* Removes unnecessary pragmas.
+
 ## 0.8.0
 
 * Removes the `IntervalAlgebraic` typeclass. The functions that were in this class are now regular functions exported in the main module.
diff --git a/interval-algebra.cabal b/interval-algebra.cabal
--- a/interval-algebra.cabal
+++ b/interval-algebra.cabal
@@ -1,6 +1,6 @@
 cabal-version:  2.2
 name:           interval-algebra
-version:        0.8.0
+version:        0.8.1
 synopsis:       An implementation of Allen's interval algebra for temporal logic
 description:    Please see the README on GitHub at <https://github.com/novisci/interval-algebra>
 category:       Algebra,Time
diff --git a/src/IntervalAlgebra.hs b/src/IntervalAlgebra.hs
--- a/src/IntervalAlgebra.hs
+++ b/src/IntervalAlgebra.hs
@@ -30,7 +30,6 @@
 {-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE UndecidableInstances #-}
 {-# LANGUAGE AllowAmbiguousTypes #-}
 
 module IntervalAlgebra(
@@ -214,12 +213,18 @@
     |  y < x    = Left  $ show y ++ "<" ++ show x
     | otherwise = Right $ Interval (x, y)
 
-intervalBegin :: Interval a -> a
+intervalBegin :: (Ord a) => Interval a -> a
 intervalBegin (Interval x) = fst x
 
-intervalEnd :: Interval a -> a
+intervalEnd :: (Ord a) => Interval a -> a
 intervalEnd (Interval x) = snd x
 
+instance Functor Interval where
+    fmap f (Interval (x, y)) = Interval (f x, f y)
+
+instance (Show a, Ord a) => Show (Interval a) where
+   show x = "(" ++ show (begin x) ++ ", " ++ show (end x) ++ ")"
+
 {- | 
 The @'Intervallic'@ typeclass defines how to get and set the 'Interval' content
 of a data structure. It also includes functions for getting the endpoints of the
@@ -234,7 +239,7 @@
 >>> end (Interval (0, 10))
 10
 -}
-class (Ord a, Show a) => Intervallic i a where
+class (Ord a) => Intervallic i a where
 
     -- | Get the interval from an @i a@.
     getInterval :: i a -> Interval a
@@ -541,7 +546,7 @@
 The 'IntervalSizeable' typeclass provides functions to determine the size of an
 'Intervallic' type and to resize an 'Interval a'.
 -}
-class (Show a, Ord a, Num b, Ord b) => IntervalSizeable a b| a -> b where
+class (Ord a, Num b, Ord b) => IntervalSizeable a b| a -> b where
 
     -- | The smallest duration for an 'Interval a'.
     moment :: b
@@ -650,12 +655,13 @@
 
 {- |
 The @'IntervalCombinable'@ typeclass provides methods for (possibly) combining
-two @i a@s to form an @'Interval'@.
+two @i a@s to form a @'Maybe' 'i' a@, or in case of @><@, a possibly different 
+@Intervallic@ type.
 -}
 class (Intervallic i a) => IntervalCombinable i a where
 
     -- | Maybe form a new @i a@ by the union of two @i a@s that 'meets'.
-    (.+.) ::   i a -> i a -> Maybe (i a)
+    (.+.) ::  i a -> i a -> Maybe (i a)
     (.+.) x y
       | x `meets` y = Just $ setInterval y $ Interval (b, e)
       | otherwise   = Nothing
@@ -692,7 +698,7 @@
 
 -- | Imposes a total ordering on @'Interval' a@ based on first ordering the 
 --   'begin's then the 'end's.
-instance (Eq (Interval a), Intervallic Interval a) => Ord (Interval a) where
+instance (Ord a) => Ord (Interval a) where
     (<=) x y
       | begin x <  begin y = True
       | begin x == begin y = end x <= end y
@@ -702,17 +708,11 @@
       | begin x == begin y = end x < end y
       | otherwise = False
 
-instance Functor Interval where
-    fmap f (Interval (x, y)) = Interval (f x, f y)
-
-instance (Intervallic Interval a) => Show (Interval a) where
-   show x = "(" ++ show (begin x) ++ ", " ++ show (end x) ++ ")"
-
-instance (Ord a, Show a) => Intervallic Interval a where
+instance (Ord a) => Intervallic Interval a where
     getInterval = id
     setInterval _ x = x
 
-instance (Ord a, Show a) => IntervalCombinable Interval a where
+instance (Ord a) => IntervalCombinable Interval a where
     (><) x y
         | x `before` y = Just $ Interval (end x, begin y)
         | otherwise    = Nothing
diff --git a/src/IntervalAlgebra/IntervalUtilities.hs b/src/IntervalAlgebra/IntervalUtilities.hs
--- a/src/IntervalAlgebra/IntervalUtilities.hs
+++ b/src/IntervalAlgebra/IntervalUtilities.hs
@@ -12,8 +12,6 @@
 {-# LANGUAGE Safe #-}
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE MonoLocalBinds #-}
 
 module IntervalAlgebra.IntervalUtilities (
 
@@ -68,7 +66,7 @@
 import Prelude          ( (<*>), seq)
 import GHC.Show         ( Show )
 import GHC.Num          ( )
-import GHC.Int          ( Int ) 
+import GHC.Int          ( Int )
 import Control.Applicative
                         ( Applicative(pure) )
 import Data.Bool        ( Bool, otherwise, not )
@@ -78,7 +76,7 @@
 import Data.Functor     ( Functor(fmap) )
 import Data.Monoid      ( Monoid(mempty) )
 import Data.Maybe       ( Maybe(..), maybe, maybeToList, mapMaybe, catMaybes, fromMaybe )
-import Data.List        ( (++), map )
+import Data.List        ( (++) )
 import Data.Ord         ( Ord(min, max) )
 import Data.Semigroup   ( Semigroup((<>)) )
 import Data.Tuple       ( fst )
@@ -193,7 +191,7 @@
 -- 
 -- >>> intersect (iv 5 0) (iv 2 3)
 -- Just (3, 5)
-intersect :: (Intervallic i a, IntervalSizeable a b) => 
+intersect :: (Intervallic i a, IntervalSizeable a b) =>
     i a -> i a -> Maybe (Interval a)
 intersect x y
     | disjoint x y = Nothing
@@ -207,11 +205,11 @@
 --
 -- >>> gaps [iv 4 1, iv 4 8, iv 3 11]
 -- [(5, 8)]
-gaps :: (IntervalCombinable Interval a
+gaps :: (  IntervalCombinable i a
          , Applicative f
          , Monoid (f (Interval a))
          , Foldable f) =>
-      f (Interval a) ->
+      f (i a) ->
       f (Interval a)
 gaps x = liftListToFoldable (gaps' x)
 
@@ -219,13 +217,13 @@
 --   intervals in the input container. *To work properly, the input should be 
 --   sorted*. This version outputs a list. See 'gaps' for a version that lifts
 --   the result to same input structure @f@.
-gaps' :: (IntervalCombinable Interval a
+gaps' :: ( Intervallic i a
          , Applicative f
          , Monoid (f (Interval a))
          , Foldable f) =>
-      f (Interval a) ->
+      f (i a) ->
       [Interval a]
-gaps' x = catMaybes (foldlAccume (><) x)
+gaps' x = catMaybes (foldlAccume (\i j -> getInterval i >< getInterval j) x)
 
 -- | Returns the 'duration' of each 'Intervallic i a' in the 'Functor' @f@.
 --
@@ -243,15 +241,15 @@
 --
 -- >>> clip (iv 3 0) (iv 2 4)
 -- Nothing
-clip :: (IntervalSizeable a b)=>
-       Interval a
-    -> Interval a
+clip :: (Intervallic i0 a, Intervallic i1 a, IntervalSizeable a b)=>
+       i0 a
+    -> i1 a
     -> Maybe (Interval a)
 clip x y
    | overlaps x y     = Just $ enderval   (diff (end x) (begin y)) (end x)
    | overlappedBy x y = Just $ beginerval (diff (end y) (begin x)) (begin x)
-   | jx x y           = Just x
-   | jy x y           = Just y
+   | jx x y           = Just (getInterval x)
+   | jy x y           = Just (getInterval y)
    | disjoint x y     = Nothing
    where jy = equals <|> startedBy <|> contains <|> finishedBy
          jx = starts <|> during <|> finishes
@@ -267,10 +265,11 @@
                , Foldable f
                , Monoid (f (Interval a))
                , IntervalSizeable a b
-               , IntervalCombinable Interval a
-               , Filterable f)=>
-     Interval a     -- ^ i
-  -> f (Interval a) -- ^ x
+               , IntervalCombinable i0 a
+               , IntervalCombinable i1 a
+               , Filterable f )=>
+        i0 a  -- ^ i
+  -> f (i1 a) -- ^ x
   -> Maybe (f (Interval a))
 gapsWithin i x
   | null ivs  = Nothing
@@ -284,10 +283,10 @@
 -- 'combineIntervals''.
 newtype Box a = Box { unBox :: [a] }
 
-packBoxes :: [a] -> [Box a]
-packBoxes  = Data.List.map (\z -> Box [z])
+packIntervalBoxes :: (Intervallic i a)=> [i a] -> [Box (Interval a)]
+packIntervalBoxes  = fmap (\z -> Box [getInterval z])
 
-instance (Ord a, Show a, IntervalCombinable i a) => Semigroup (Box (i a)) where
+instance (Ord a) => Semigroup (Box (Interval a)) where
     Box x <> Box y = Box $ listCombiner (<->) x y
 
 -- | Returns a container of intervals where any intervals that meet or share support
@@ -297,10 +296,11 @@
 -- >>> combineIntervals [iv 10 0, iv 5 2, iv 2 10, iv 2 13]
 -- [(0, 12),(13, 15)]
 combineIntervals :: ( Applicative f
-                    , Intervallic Interval a
+                    , Ord a
+                    , Intervallic i a
                     , Monoid (f (Interval a))
                     , Foldable f ) =>
-      f (Interval a) ->
+      f (i a) ->
       f (Interval a)
 combineIntervals x = liftListToFoldable (combineIntervals' $ toList x)
 
@@ -310,19 +310,19 @@
 --
 -- >>> combineIntervals' [iv 10 0, iv 5 2, iv 2 10, iv 2 13]
 -- [(0, 12),(13, 15)]
-combineIntervals' :: (Intervallic Interval a)=> [Interval a] -> [Interval a]
-combineIntervals' l = unBox $ foldl' (<>) (Box []) (packBoxes l)
+combineIntervals' :: (Intervallic i a)=> [i a] -> [Interval a]
+combineIntervals' l = unBox $ foldl' (<>) (Box []) (packIntervalBoxes l)
 
 -- Internal function for combining maybe intervals in the 'combineIntervals'' 
 -- function
 (<->) :: (IntervalCombinable i a) =>
        Maybe (i a)
     -> Maybe (i a)
-    -> [i a]
+    -> [Interval a]
 (<->) Nothing Nothing   = []
-(<->) Nothing (Just y)  = [y]
-(<->) (Just x) Nothing  = [x]
-(<->) (Just x) (Just y) = (<+>) x y
+(<->) Nothing (Just y)  = [getInterval y]
+(<->) (Just x) Nothing  = [getInterval x]
+(<->) (Just x) (Just y) = (<+>) (getInterval x) (getInterval y)
 
 -- | Given a predicate combinator, a predicate, and list of intervals, returns 
 --   the input unchanged if the predicate combinator is @True@. Otherwise, returns
@@ -391,11 +391,11 @@
 a (potentially different) 'Intervallic' type using the corresponding interval
 predicate function.
 -}
-filterOverlaps, filterOverlappedBy, filterBefore, filterAfter, 
-  filterStarts, filterStartedBy, filterFinishes, filterFinishedBy, 
+filterOverlaps, filterOverlappedBy, filterBefore, filterAfter,
+  filterStarts, filterStartedBy, filterFinishes, filterFinishedBy,
   filterMeets, filterMetBy, filterDuring, filterContains, filterEquals,
   filterDisjoint, filterNotDisjoint, filterConcur, filterWithin,
-  filterEnclose, filterEnclosedBy :: 
+  filterEnclose, filterEnclosedBy ::
     ( Filterable f , Intervallic i0 a, Intervallic i1 a) =>
     i0 a -> f (i1 a) -> f (i1 a)
 filterOverlaps          = makeFilter overlaps
@@ -423,7 +423,7 @@
 --   combined into one. This function is "safe" in the sense that if the input is
 --   invalid and contains any sequential pairs of intervals with an @IntervalRelation@,
 --   other than 'Meets', then the function returns an empty list. 
-foldMeetingSafe :: (Intervallic (PairedInterval b) a,  Eq b) =>
+foldMeetingSafe :: (Eq b, Ord a, Show a)  =>
            [ PairedInterval b a ] -- ^ Be sure this only contains intervals 
                                   --   that sequentially 'meets'.
         -> [ PairedInterval b a ]
@@ -443,7 +443,7 @@
 
 -- Box up Meeting.
 packMeeting :: [a] -> [Meeting [a]]
-packMeeting = Data.List.map (\z -> Meeting [z])
+packMeeting = fmap (\z -> Meeting [z])
 
 -- Test a list of intervals to be sure they all meet; if not return Nothing.
 parseMeeting :: Intervallic i a => [i a] -> Maybe (Meeting [i a])
@@ -468,7 +468,7 @@
 
 -- The intervals @x@ and @y@ should meet! The predicate function @p@ determines
 -- when the two intervals that meet should be combined.
-join2MeetingWhen :: Intervallic i a => 
+join2MeetingWhen :: Intervallic i a =>
        ComparativePredicateOf1 (i a)
     -> Maybe (i a)
     -> Maybe (i a)
@@ -489,6 +489,7 @@
 -}
 disjoinPaired :: ( Eq b
                  , Monoid b
+                 , Show a
                  , IntervalSizeable a c) =>
        (PairedInterval b) a
     -> (PairedInterval b) a
@@ -523,7 +524,7 @@
 compared to input events. The second of the pair are disjoint events that
 still need to be compared to be input events. 
 -}
-recurseDisjoin :: ( Monoid b, Eq b, IntervalSizeable a c) =>
+recurseDisjoin :: ( Monoid b, Eq b, IntervalSizeable a c, Show a ) =>
        ([(PairedInterval b) a ], [(PairedInterval b) a ])
     -> [(PairedInterval b) a ]
     -> [(PairedInterval b) a ]
@@ -557,11 +558,12 @@
 'Monoid' instance.
 -}
 formMeetingSequence :: ( Eq b
+                       , Show a
                        , Monoid b
                        , IntervalSizeable a c) =>
            [ PairedInterval b a ]
         -> [ PairedInterval b a ]
-formMeetingSequence x = recurseDisjoin ([], []) (recurseDisjoin ([], []) x) 
+formMeetingSequence x = recurseDisjoin ([], []) (recurseDisjoin ([], []) x)
    -- the second pass of recurseDisjoin is to handle the situation where the first pass
    -- disjoins all the events correctly into a meeting sequence but -- due to 
    -- nesting of intervals in the input -- some of the sequential pairs have
diff --git a/src/IntervalAlgebra/PairedInterval.hs b/src/IntervalAlgebra/PairedInterval.hs
--- a/src/IntervalAlgebra/PairedInterval.hs
+++ b/src/IntervalAlgebra/PairedInterval.hs
@@ -10,7 +10,6 @@
 {-# LANGUAGE Safe #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE FlexibleContexts #-}
 
 module IntervalAlgebra.PairedInterval (
       PairedInterval
@@ -36,7 +35,7 @@
 newtype PairedInterval b a = PairedInterval (Interval a, b)
     deriving (Eq)
 
-instance (Ord a, Show a) => Intervallic (PairedInterval b) a where
+instance (Ord a) => Intervallic (PairedInterval b) a where
     getInterval (PairedInterval x)        = fst x
     setInterval (PairedInterval (x, y)) i = PairedInterval (i, y)
 
@@ -45,7 +44,7 @@
 
 -- | Defines A total ordering on 'PairedInterval b a' based on the 'Interval a'
 --   part.
-instance (Eq a, Eq b, Ord a, Show a) => Ord (PairedInterval b a) where
+instance (Eq a, Eq b, Ord a) => Ord (PairedInterval b a) where
   (<=) x y = getInterval x <= getInterval y
   (<) x y  = getInterval x <  getInterval y
 
diff --git a/test/IntervalAlgebra/IntervalUtilitiesSpec.hs b/test/IntervalAlgebra/IntervalUtilitiesSpec.hs
--- a/test/IntervalAlgebra/IntervalUtilitiesSpec.hs
+++ b/test/IntervalAlgebra/IntervalUtilitiesSpec.hs
@@ -1,6 +1,5 @@
 {-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE MonoLocalBinds #-}
 {-# LANGUAGE FlexibleInstances #-}
 module IntervalAlgebra.IntervalUtilitiesSpec (spec) where
 
@@ -160,7 +159,7 @@
 -- Properties
 
 -- Check that the only relation remaining after applying a function is Before
-prop_before:: (Intervallic Interval a, IntervalCombinable Interval a)=>
+prop_before:: (Ord a)=>
       ([Interval a] -> [Interval a])
    -> [Interval a]
    -> Property
@@ -172,7 +171,7 @@
    -> Property
 prop_combineIntervals1 = prop_before combineIntervals
 
-prop_gaps1:: (Intervallic Interval a, IntervalCombinable Interval a)=>
+prop_gaps1:: (Ord a)=>
      [Interval a]
    -> Property
 prop_gaps1 = prop_before gaps
@@ -252,7 +251,7 @@
             gapsWithin (iv 9 1) [iv 5 0, iv 2 7, iv 3 12]
                `shouldBe` Just [iv 2 5, iv 1 9]
          it "gapsWithin (1, 10) [] should be []" $
-             gapsWithin (iv 9 1) [] `shouldBe` Nothing
+             gapsWithin (iv 9 1) ([] :: [Interval a]) `shouldBe` Nothing
          it "more gapsWithin tests" pending
 
    describe "emptyIf tests" $
diff --git a/test/IntervalAlgebraSpec.hs b/test/IntervalAlgebraSpec.hs
--- a/test/IntervalAlgebraSpec.hs
+++ b/test/IntervalAlgebraSpec.hs
@@ -1,8 +1,6 @@
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE TypeApplications #-}
-{-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE MonoLocalBinds #-}
 module IntervalAlgebraSpec (spec) where
 
 import Test.Hspec                 ( hspec, describe, it, Spec, shouldBe, pending )
@@ -103,7 +101,7 @@
    \forall i,j,k,l s.t. (i:j & i:k & l:j) \implies l:k
  \] 
 -}
-prop_IAaxiomM1 :: (Intervallic Interval a) => M1set a -> Property
+prop_IAaxiomM1 :: (Ord a) => M1set a -> Property
 prop_IAaxiomM1 x =
   (i `meets` j && i `meets` k && l `meets` j) ==> (l `meets` k)
   where i = m11 x
@@ -167,7 +165,8 @@
  \] 
 -}
 
-prop_IAaxiomM2 :: (Intervallic Interval a, IntervalSizeable a b) => M2set a -> Property
+prop_IAaxiomM2 :: (IntervalSizeable a b, Show a) => 
+    M2set a -> Property
 prop_IAaxiomM2 x =
   (i `meets` j && k `meets` l) ==>
     (i `meets` l)  `xor`
@@ -197,7 +196,7 @@
  \] 
 -}
 
-prop_IAaxiomML1 :: (Intervallic Interval a) => Interval a -> Property
+prop_IAaxiomML1 :: (Ord a) => Interval a -> Property
 prop_IAaxiomML1 x = not (x `meets` x) === True
 
 prop_IAaxiomML1_Int :: Interval Int -> Property
@@ -217,7 +216,7 @@
 \] 
 -}
 
-prop_IAaxiomML2 :: (Intervallic Interval a)=> M2set a -> Property
+prop_IAaxiomML2 :: (Ord a)=> M2set a -> Property
 prop_IAaxiomML2 x =
   (i `meets` j) ==> not (j `meets` i)
   where i = m21 x
@@ -240,7 +239,7 @@
 \] 
 -}
 
-prop_IAaxiomM3 :: (Intervallic Interval a, IntervalSizeable a b)=>
+prop_IAaxiomM3 :: (IntervalSizeable a b)=>
       b -> Interval a -> Property
 prop_IAaxiomM3 b i =
    (j `meets` i && i `meets` k) === True
@@ -264,7 +263,7 @@
 \] 
 -}
 
-prop_IAaxiomM4 :: (Intervallic Interval a, IntervalSizeable a b)=>
+prop_IAaxiomM4 :: (IntervalSizeable a b)=>
      b -> M2set a -> Property
 prop_IAaxiomM4 b x =
    ((m `meets` i && i `meets` j && j `meets` n) &&
@@ -319,7 +318,7 @@
         ps = end (expandr (makePos b) x) -- creating l by shifting and expanding i
 
 
-prop_IAaxiomM5 :: (Intervallic Interval a, IntervalSizeable a b) => 
+prop_IAaxiomM5 :: (IntervalSizeable a b) => 
     M5set a -> Property
 prop_IAaxiomM5 x =
    ((i `meets` j && j `meets` l) &&
@@ -347,7 +346,7 @@
 \] 
 -}
 
-prop_IAaxiomM4_1 :: (IntervalSizeable a b, IntervalCombinable Interval a)=>
+prop_IAaxiomM4_1 :: (IntervalSizeable a b)=>
                     b -> M2set a -> Property
 prop_IAaxiomM4_1 b x =
    ((m `meets` i && i `meets` j && j `meets` n) &&
@@ -368,10 +367,7 @@
 * Interval Relation property testing 
 -}
 
-class ( Intervallic Interval a
-      , IntervalCombinable Interval a
-      , IntervalSizeable a b
-      ) => IntervalRelationProperties a b where
+class ( IntervalSizeable a b ) => IntervalRelationProperties a b where
 
     prop_IAbefore :: Interval a -> Interval a -> Property
     prop_IAbefore i j =
@@ -413,7 +409,7 @@
 
 instance IntervalRelationProperties Int Int
 
-allIArelations:: Intervallic Interval a => [ComparativePredicateOf1 (Interval a)]
+allIArelations:: (Ord a) => [ComparativePredicateOf1 (Interval a)]
 allIArelations =   [  IA.equals
                     , IA.meets
                     , IA.metBy
@@ -428,14 +424,14 @@
                     , IA.during
                     , IA.contains ]
 
-prop_expandl_end ::(Intervallic Interval a, IntervalSizeable a b)=>
+prop_expandl_end ::(IntervalSizeable a b, Show a)=>
        b
     -> Interval a
     -> Property
 prop_expandl_end d i = end (expandl d i) === end i
 
 
-prop_expandr_begin ::(Intervallic Interval a, IntervalSizeable a b)=>
+prop_expandr_begin ::(IntervalSizeable a b, Show a)=>
        b
     -> Interval a
     -> Property
@@ -443,7 +439,7 @@
 
 -- | The relation between x and z should be an element of the set of the
 --   composed relations between x y and between y z.
-prop_compose :: Intervallic Interval a =>
+prop_compose :: Ord a =>
        Interval a
     -> Interval a
     -> Interval a