diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,10 @@
 # Version history for bin
 
+## 0.1.1
+
+- Explicitly mark all modules as Safe or Trustworthy.
+- `fin-0.2` support.
+
 ## 0.1
 
 - First version. Released on an unsuspecting world.
diff --git a/bin.cabal b/bin.cabal
--- a/bin.cabal
+++ b/bin.cabal
@@ -1,6 +1,6 @@
 cabal-version:      2.2
 name:               bin
-version:            0.1
+version:            0.1.1
 synopsis:           Bin: binary natural numbers.
 category:           Data, Dependent Types, Singletons, Math
 description:
@@ -30,7 +30,7 @@
 license-file:       LICENSE
 author:             Oleg Grenrus <oleg.grenrus@iki.fi>
 maintainer:         Oleg.Grenrus <oleg.grenrus@iki.fi>
-copyright:          (c) 2019 Oleg Grenrus
+copyright:          (c) 2019-2021 Oleg Grenrus
 build-type:         Simple
 extra-source-files: ChangeLog.md
 tested-with:
@@ -40,7 +40,9 @@
    || ==8.2.2
    || ==8.4.4
    || ==8.6.5
-   || ==8.8.1
+   || ==8.8.4
+   || ==8.10.4
+   || ==9.0.1
 
 source-repository head
   type:     git
@@ -60,16 +62,22 @@
     Data.Type.BinP
     Data.Wrd
 
+  other-modules:    TrustworthyCompat
   build-depends:
-    , base        >=4.7     && <4.14
+    , base        >=4.7     && <4.16
     , dec         ^>=0.0.3
     , deepseq     >=1.3.0.2 && <1.5
-    , fin         ^>=0.1.1
+    , fin         ^>=0.2
     , hashable    >=1.2.7.0 && <1.4
-    , QuickCheck  ^>=2.13.2
+    , QuickCheck  ^>=2.14.2
 
   if !impl(ghc >=7.10)
     build-depends: nats ^>=1.1.2
+
+  if impl(ghc >= 9.0)
+    -- these flags may abort compilation with GHC-8.10
+    -- https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3295
+    ghc-options: -Winferred-safe-imports -Wmissing-safe-haskell-mode
 
 -- dump-core
 -- if impl(ghc >= 8.0)
diff --git a/src/Data/Bin.hs b/src/Data/Bin.hs
--- a/src/Data/Bin.hs
+++ b/src/Data/Bin.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE CPP                #-}
 {-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE Safe               #-}
 
 #if __GLASGOW_HASKELL__ < 710
 {-# LANGUAGE DataKinds          #-}
@@ -36,6 +37,7 @@
     ) where
 
 import Control.DeepSeq (NFData (..))
+import Data.BinP       (BinP (..))
 import Data.Bits       (Bits (..))
 import Data.Data       (Data)
 import Data.Hashable   (Hashable (..))
@@ -43,11 +45,13 @@
 import Data.Typeable   (Typeable)
 import GHC.Exception   (ArithException (..), throw)
 import Numeric.Natural (Natural)
-import Data.BinP (BinP (..))
 
+import qualified Data.BinP       as BP
 import qualified Data.Nat        as N
 import qualified Test.QuickCheck as QC
-import qualified Data.BinP as BP
+
+-- $setup
+-- >>> import qualified Data.Nat as N
 
 -------------------------------------------------------------------------------
 -- Bin
diff --git a/src/Data/Bin/Pos.hs b/src/Data/Bin/Pos.hs
--- a/src/Data/Bin/Pos.hs
+++ b/src/Data/Bin/Pos.hs
@@ -6,6 +6,7 @@
 {-# LANGUAGE FunctionalDependencies #-}
 {-# LANGUAGE GADTs                  #-}
 {-# LANGUAGE KindSignatures         #-}
+{-# LANGUAGE Safe                   #-}
 {-# LANGUAGE ScopedTypeVariables    #-}
 {-# LANGUAGE StandaloneDeriving     #-}
 {-# LANGUAGE UndecidableInstances   #-}
@@ -38,14 +39,15 @@
 
 import qualified Data.BinP.PosP  as PP
 import qualified Data.Type.Bin   as B
-import qualified Data.Type.BinP   as BP
+import qualified Data.Type.BinP  as BP
 import qualified Test.QuickCheck as QC
 
 import Data.Type.Bin
 
 -- $setup
--- >>> import Prelude (map, putStrLn)
+-- >>> import Prelude (map, putStrLn, Ord (..), Bounded (..), ($), (.))
 -- >>> import Data.Foldable (traverse_)
+-- >>> import Data.Type.Bin
 
 -------------------------------------------------------------------------------
 -- Data
@@ -53,7 +55,7 @@
 
 -- | 'Pos' is to 'Bin' is what 'Fin' is to 'Nat'.
 --
--- The name is picked, as sthe lack of beter alternatives.
+-- The name is picked, as the lack of better alternatives.
 --
 data Pos (b :: Bin) where
     Pos :: PosP b -> Pos ('BP b)
diff --git a/src/Data/BinP.hs b/src/Data/BinP.hs
--- a/src/Data/BinP.hs
+++ b/src/Data/BinP.hs
@@ -1,6 +1,7 @@
 {-# LANGUAGE BangPatterns       #-}
 {-# LANGUAGE CPP                #-}
 {-# LANGUAGE DeriveDataTypeable #-}
+{-# LANGUAGE Safe               #-}
 
 #if __GLASGOW_HASKELL__ < 710
 {-# LANGUAGE DataKinds          #-}
@@ -66,17 +67,26 @@
 deriving instance Typeable 'B1
 #endif
 
--- | >>> sort [1 .. 9 :: BinP]
+-- |
+--
+-- >>> sort [ 1 .. 9 :: BinP ]
 -- [1,2,3,4,5,6,7,8,9]
 --
+-- >>> sort $ reverse [ 1 .. 9 :: BinP ]
+-- [1,2,3,4,5,6,7,8,9]
+--
+-- >>> sort $ [ 1 .. 9 ] ++ [ 1 .. 9 :: BinP ]
+-- [1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9]
+--
 instance Ord BinP where
-    compare BE     BE     = EQ
-    compare BE     _      = LT
-    compare _      BE     = GT
-    compare (B0 a) (B0 b) = compare a b
-    compare (B1 a) (B1 b) = compare a b
-    compare (B0 a) (B1 b) = compare a b `mappend` LT
-    compare (B1 a) (B0 b) = compare a b `mappend` GT
+    compare = go EQ where
+        go  acc BE     BE     = acc
+        go _acc BE     _      = LT
+        go _acc _      BE     = GT
+        go  acc (B0 a) (B0 b) = go acc a b
+        go  acc (B1 a) (B1 b) = go acc a b
+        go _acc (B0 a) (B1 b) = go LT  a b
+        go _acc (B1 a) (B0 b) = go GT  a b
 
 instance Show BinP where
     showsPrec d = showsPrec d . toNatural
diff --git a/src/Data/BinP/PosP.hs b/src/Data/BinP/PosP.hs
--- a/src/Data/BinP/PosP.hs
+++ b/src/Data/BinP/PosP.hs
@@ -6,6 +6,7 @@
 {-# LANGUAGE FunctionalDependencies #-}
 {-# LANGUAGE GADTs                  #-}
 {-# LANGUAGE KindSignatures         #-}
+{-# LANGUAGE Safe                   #-}
 {-# LANGUAGE ScopedTypeVariables    #-}
 {-# LANGUAGE StandaloneDeriving     #-}
 {-# LANGUAGE UndecidableInstances   #-}
@@ -31,8 +32,8 @@
 
 import Prelude
        (Bounded (..), Either (..), Eq, Int, Integer, Num, Ord (..),
-       Ordering (..), Show (..), ShowS, String, either, fmap, fromIntegral,
-       map, showParen, showString, ($), (*), (+), (++), (.))
+       Ordering (..), Show (..), ShowS, String, either, fmap, fromIntegral, map,
+       showParen, showString, ($), (*), (+), (++), (.))
 
 import Data.Bin        (BinP (..))
 import Data.Nat        (Nat (..))
@@ -53,6 +54,8 @@
 -- $setup
 -- >>> import Prelude (map, putStrLn)
 -- >>> import Data.Foldable (traverse_)
+-- >>> import qualified Data.Type.Nat as N
+-- >>> import Data.Type.BinP
 
 -------------------------------------------------------------------------------
 -- Data
diff --git a/src/Data/Type/Bin.hs b/src/Data/Type/Bin.hs
--- a/src/Data/Type/Bin.hs
+++ b/src/Data/Type/Bin.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP                  #-}
 {-# LANGUAGE DataKinds            #-}
 {-# LANGUAGE DeriveDataTypeable   #-}
 {-# LANGUAGE FlexibleContexts     #-}
@@ -8,6 +9,11 @@
 {-# LANGUAGE TypeFamilies         #-}
 {-# LANGUAGE TypeOperators        #-}
 {-# LANGUAGE UndecidableInstances #-}
+#if MIN_VERSION_base(4,8,0)
+{-# LANGUAGE Safe                 #-}
+#else
+{-# LANGUAGE Trustworthy          #-}
+#endif
 -- | Binary natural numbers. @DataKinds@ stuff.
 module Data.Type.Bin (
     -- * Singleton
@@ -43,22 +49,27 @@
     Bin0, Bin1, Bin2, Bin3, Bin4, Bin5, Bin6, Bin7, Bin8, Bin9,
     ) where
 
-import Data.Bin           (Bin (..), BinP (..))
-import Data.Nat           (Nat (..))
-import Data.Proxy         (Proxy (..))
-import Data.Type.Equality ((:~:) (..), TestEquality (..))
-import Data.Typeable      (Typeable)
-import Numeric.Natural    (Natural)
-import Data.Type.BinP (SBinP (..), SBinPI (..))
+import Data.Bin        (Bin (..), BinP (..))
+import Data.Nat        (Nat (..))
+import Data.Proxy      (Proxy (..))
+import Data.Type.BinP  (SBinP (..), SBinPI (..))
+import Data.Typeable   (Typeable)
+import Numeric.Natural (Natural)
 
-import qualified Data.Type.Nat as N
-import qualified GHC.TypeLits  as GHC
 import qualified Data.Type.BinP as BP
+import qualified Data.Type.Nat  as N
+import qualified GHC.TypeLits   as GHC
 
+import TrustworthyCompat
+
 -- $setup
 -- >>> :set -XDataKinds
 -- >>> import Data.Bin
 -- >>> import Data.Type.BinP (BinP2, BinP3)
+-- >>> import Data.Nat (Nat (..))
+-- >>> import qualified Data.Type.BinP as BP
+-- >>> import qualified Data.Type.Nat as N
+-- >>> import qualified GHC.TypeLits as GHC
 
 -------------------------------------------------------------------------------
 -- Singletons
@@ -288,7 +299,7 @@
 -- >>> :kind! Succ Bin5
 -- Succ Bin5 :: Bin
 -- = 'BP ('B0 ('B1 'BE))
--- 
+--
 -- @
 -- `Succ`   :: 'Bin' -> 'Bin'
 -- `Succ'`  :: 'Bin' -> 'BinP'
diff --git a/src/Data/Type/BinP.hs b/src/Data/Type/BinP.hs
--- a/src/Data/Type/BinP.hs
+++ b/src/Data/Type/BinP.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE CPP                  #-}
 {-# LANGUAGE DataKinds            #-}
 {-# LANGUAGE DeriveDataTypeable   #-}
 {-# LANGUAGE FlexibleContexts     #-}
@@ -8,6 +9,11 @@
 {-# LANGUAGE TypeFamilies         #-}
 {-# LANGUAGE TypeOperators        #-}
 {-# LANGUAGE UndecidableInstances #-}
+#if MIN_VERSION_base(4,8,0)
+{-# LANGUAGE Safe                 #-}
+#else
+{-# LANGUAGE Trustworthy          #-}
+#endif
 -- | Positive binary natural numbers. @DataKinds@ stuff.
 module Data.Type.BinP (
     -- * Singleton
@@ -39,16 +45,16 @@
     BinP1, BinP2, BinP3, BinP4, BinP5, BinP6, BinP7, BinP8, BinP9,
     ) where
 
-import Data.BinP           (BinP (..))
-import Data.Coerce        (coerce)
-import Data.Nat           (Nat (..))
-import Data.Proxy         (Proxy (..))
-import Data.Type.Equality ((:~:) (..), TestEquality (..))
-import Data.Typeable      (Typeable)
-import Numeric.Natural    (Natural)
+import Data.BinP       (BinP (..))
+import Data.Nat        (Nat (..))
+import Data.Proxy      (Proxy (..))
+import Data.Typeable   (Typeable)
+import Numeric.Natural (Natural)
 
 import qualified Data.Type.Nat as N
 import qualified GHC.TypeLits  as GHC
+
+import TrustworthyCompat
 
 -- $setup
 -- >>> :set -XDataKinds
diff --git a/src/Data/Wrd.hs b/src/Data/Wrd.hs
--- a/src/Data/Wrd.hs
+++ b/src/Data/Wrd.hs
@@ -4,6 +4,7 @@
 {-# LANGUAGE DeriveDataTypeable  #-}
 {-# LANGUAGE GADTs               #-}
 {-# LANGUAGE KindSignatures      #-}
+{-# LANGUAGE Safe                #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE StandaloneDeriving  #-}
 -- | Fixed-'Wrd'th (unsigned) integers.
@@ -55,6 +56,8 @@
 
 -- $setup
 -- >>> :set -XDataKinds
+-- >>> import Data.Nat (Nat(..))
+-- >>> import qualified Data.Type.Nat as N
 
 -------------------------------------------------------------------------------
 -- Data
@@ -154,7 +157,7 @@
         go True  (W1 WE) = W1 WE
         go False (W1 WE) = W1 WE
         go b     (W0 w)  = W0 (go b w)
-        go _     (W1 w)  = W0 (go True w) 
+        go _     (W1 w)  = W0 (go True w)
 
 -------------------------------------------------------------------------------
 -- Bits & FiniteBits
@@ -489,7 +492,7 @@
     go :: forall m. N.SNatI m => s -> (s, Wrd m)
     go s = case N.snat :: N.SNat m of
         N.SZ -> (s, WE)
-        N.SS -> 
+        N.SS ->
             let (s'', b)  = g s'
                 (s' , w') = go s
             in (s'', if b then W1 w' else W0 w')
@@ -506,7 +509,7 @@
         let (s'', b)  = g s' True
             (s' , w') = go s w
         in (s'', if b then W1 w' else W0 w')
-    
+
 wrdScanl2 :: forall s n. (s -> Bool -> Bool -> (s, Bool)) -> s ->  Wrd n -> Wrd n -> (s, Wrd n)
 wrdScanl2 g = go where
     go :: s -> Wrd m -> Wrd m -> (s, Wrd m)
diff --git a/src/TrustworthyCompat.hs b/src/TrustworthyCompat.hs
new file mode 100644
--- /dev/null
+++ b/src/TrustworthyCompat.hs
@@ -0,0 +1,9 @@
+{-# LANGUAGE Trustworthy #-}
+module TrustworthyCompat (
+    (:~:) (..),
+    TestEquality (..),
+    coerce,
+) where
+
+import Data.Coerce        (coerce)
+import Data.Type.Equality (TestEquality (..), (:~:) (..))