diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,3 +1,7 @@
+## 0.3
+
+* Fixed a corner case where `conquer` would lie and return an empty equivalence class when fed no inputs.
+
 ## 0.2.1
 
 * `promises` 0.3 support
diff --git a/discrimination.cabal b/discrimination.cabal
--- a/discrimination.cabal
+++ b/discrimination.cabal
@@ -1,8 +1,8 @@
 name:          discrimination
 category:      Data, Sorting
-version:       0.2.1
+version:       0.3
 license:       BSD3
-cabal-version: >= 1.22
+cabal-version: >= 1.10
 license-file:  LICENSE
 author:        Edward A. Kmett
 maintainer:    Edward A. Kmett <ekmett@gmail.com>
@@ -11,7 +11,7 @@
 bug-reports:   http://github.com/ekmett/discrimination/issues
 copyright:     Copyright (C) 2014-2015 Edward A. Kmett
 build-type:    Simple
-tested-with:   GHC == 7.10.1
+tested-with:   GHC == 7.10.3, GHC == 8.0.2, GHC == 8.2.1
 synopsis:      Fast generic linear-time sorting, joins and container construction.
 description:
   This package provides fast, generic, linear-time discrimination and sorting.
@@ -44,7 +44,7 @@
 
   build-depends:
     array         >= 0.5    && < 0.6,
-    base          >= 4.7    && < 5,
+    base          >= 4.8    && < 5,
     containers    >= 0.4    && < 0.6,
     contravariant >= 1.3.1  && < 2,
     deepseq       >= 1.3    && < 1.5,
@@ -56,7 +56,7 @@
     semigroups    >= 0.16.2 && < 1,
     transformers  >= 0.2    && < 0.6,
     transformers-compat >= 0.3 && < 1,
-    vector        >= 0.10   && < 0.12,
+    vector        >= 0.10   && < 0.13,
     void          >= 0.5    && < 1
 
 benchmark wordmap
@@ -66,7 +66,7 @@
   hs-source-dirs:   benchmarks
   default-language: Haskell2010
   build-depends:
-    base >= 4.8,
+    base >= 4.9,
     containers,
     criterion,
     deepseq,
diff --git a/src/Data/Discrimination/Grouping.hs b/src/Data/Discrimination/Grouping.hs
--- a/src/Data/Discrimination/Grouping.hs
+++ b/src/Data/Discrimination/Grouping.hs
@@ -154,8 +154,14 @@
 instance (Grouping a, Grouping b) => Grouping (Either a b)
 instance Grouping a => Grouping (Complex a) where
   grouping = divide (\(a :+ b) -> (a, b)) grouping grouping
+
+#if __GLASGOW_HASKELL__ >= 800
+instance Grouping a => Grouping (Ratio a) where
+#else
 instance (Grouping a, Integral a) => Grouping (Ratio a) where
+#endif
   grouping = divide (\r -> (numerator r, denominator r)) grouping grouping
+
 instance (Grouping1 f, Grouping1 g, Grouping a) => Grouping (Compose f g a) where
   grouping = getCompose `contramap` grouping1 (grouping1 grouping)
 
diff --git a/src/Data/Discrimination/Sorting.hs b/src/Data/Discrimination/Sorting.hs
--- a/src/Data/Discrimination/Sorting.hs
+++ b/src/Data/Discrimination/Sorting.hs
@@ -69,6 +69,12 @@
 newtype Sort a = Sort { runSort :: forall b. [(a,b)] -> [[b]] }
   deriving Typeable
 
+mkSort :: (forall b. [(a, b)] -> [[b]]) -> Sort a
+mkSort f = Sort $ \xs -> case xs of
+  []       -> []
+  [(_, v)] -> [[v]]
+  _        -> f xs
+
 #ifndef HLINT
 type role Sort representational
 #endif
@@ -77,13 +83,13 @@
   contramap f (Sort g) = Sort $ g . fmap (first f)
 
 instance Divisible Sort where
-  conquer = Sort $ return . fmap snd
+  conquer = mkSort $ return . fmap snd
   divide k (Sort l) (Sort r) = Sort $ \xs ->
     l [ (b, (c, d)) | (a,d) <- xs, let (b, c) = k a] >>= r
 
 instance Decidable Sort where
   lose k = Sort $ fmap (absurd.k.fst)
-  choose f (Sort l) (Sort r) = Sort $ \xs -> let
+  choose f (Sort l) (Sort r) = mkSort $ \xs -> let
       ys = fmap (first f) xs
     in l [ (k,v) | (Left k, v) <- ys]
     ++ r [ (k,v) | (Right k, v) <- ys]
@@ -196,7 +202,7 @@
 --------------------------------------------------------------------------------
 
 sortingNat :: Int -> Sort Int
-sortingNat n = Sort $ \xs -> List.filter (not . List.null) (bdiscNat n upd xs) where
+sortingNat n = mkSort $ \xs -> List.filter (not . List.null) (bdiscNat n upd xs) where
   upd vs v = v : vs
 {-# INLINE sortingNat #-}