diff --git a/compactable.cabal b/compactable.cabal
--- a/compactable.cabal
+++ b/compactable.cabal
@@ -1,5 +1,5 @@
 name:                compactable
-version:             0.1.0.0
+version:             0.1.0.1
 synopsis:            A generalization for containers that can be stripped of Nothings.
 description:         Sometimes you have a collection of Maybes,
                      and you want to extract the values. Actually that happens a whole lot.
diff --git a/src/Control/Compactable.hs b/src/Control/Compactable.hs
--- a/src/Control/Compactable.hs
+++ b/src/Control/Compactable.hs
@@ -134,6 +134,10 @@
     traverseMaybe f = fmap compact . traverse f
     {-# INLINABLE traverseMaybe #-}
 
+    filter :: Functor f => (a -> Bool) -> f a -> f a
+    filter f = fmapMaybe $ \a -> if f a then Just a else Nothing
+    {-# INLINABLE filter #-}
+
 instance Compactable Maybe where
     compact = join
     {-# INLINABLE compact #-}
@@ -148,6 +152,7 @@
     fmapMaybe f (h:t) =
         maybe (fmapMaybe f t) (: fmapMaybe f t) (f h)
     {-# INLINABLE fmapMaybe #-}
+    filter = Prelude.filter
 
 instance Compactable IO
 
@@ -183,22 +188,34 @@
     {-# INLINABLE compact #-}
     fmapMaybe = IntMap.mapMaybe
     {-# INLINABLE fmapMaybe #-}
+    filter = IntMap.filter
+    {-# INLINABLE filter #-}
 
 instance Compactable (Map.Map k) where
     compact = Map.mapMaybe id
     {-# INLINABLE compact #-}
     fmapMaybe = Map.mapMaybe
     {-# INLINABLE fmapMaybe #-}
+    filter = Map.filter
+    {-# INLINABLE filter #-}
 
 instance Compactable Seq.Seq where
     compact = fmap fromJust . Seq.filter isJust
     {-# INLINABLE compact #-}
+    filter = Seq.filter
+    {-# INLINABLE filter #-}
 
 instance Compactable Vector
 
 instance Compactable (Const r) where
     compact (Const r) = Const r
     {-# INLINABLE compact #-}
+    fmapMaybe _ (Const r) = Const r
+    {-# INLINABLE fmapMaybe #-}
+    bindMaybe (Const r) _ = Const r
+    {-# INLINABLE bindMaybe #-}
+    filter _ (Const r) = Const r
+    {-# INLINABLE filter #-}
 
 instance Monoid m => Compactable (Either m) where
     compact (Right (Just x)) = Right x
@@ -209,10 +226,6 @@
 
 fforMaybe :: (Compactable f, Functor f) => f a -> (a -> Maybe b) -> f b
 fforMaybe = flip fmapMaybe
-
-
-filter :: (Compactable f, Functor f) => (a -> Bool) -> f a -> f a
-filter f = fmapMaybe $ \a -> if f a then Just a else Nothing
 
 
 fmapMaybeM :: (Compactable f, Monad f) => (a -> MaybeT f b) -> f a -> f b