diff --git a/changelog.md b/changelog.md
new file mode 100644
--- /dev/null
+++ b/changelog.md
@@ -0,0 +1,7 @@
+### 1.0.1.1 (2023-01-02)
+
+Support GHC 9.4
+
+### 1.0.1.0 (2022-03-22)
+
+Start of changelog
diff --git a/d10.cabal b/d10.cabal
--- a/d10.cabal
+++ b/d10.cabal
@@ -1,58 +1,16 @@
 cabal-version: 3.0
 
 name: d10
-version: 1.0.1.0
+version: 1.0.1.1
 category: Data
 synopsis: Digits 0-9
 
 description:
     Data types representing the digits zero through nine.
 
-    == Modules
-
     Each of the following modules defines a different type named
     @D10@, all of which are different representations of the same
-    concept:
-
-    * "D10.Char" - Defines a @D10@ type as a newtype for @Char@,
-      where the values are restricted to characters between
-      @'0'@ and @'9'@
-    * "D10.Num" - Defines a @D10@ type as a newtype for any
-      type with an instance of the @Num@ class, where the values
-      are restricted to numbers between @fromInteger 0@ and
-      @fromInteger 9@
-    * "D10.Safe" - Defines a @D10@ type as @D0 | D1 | D2 | ... | D9@
-
-    The @Arithmetic@ modules provide infix operators (@+@), (@-@), (@*@)
-    for modular arithmetic:
-
-    * "D10.Char.Arithmetic"
-    * "D10.Num.Arithmetic"
-    * "D10.Safe.Arithmetic"
-
-    The following modules export constructors that can be used
-    incorrectly:
-
-    * "D10.Char.Unsafe"
-    * "D10.Num.Unsafe"
-
-    Functions to test whether values of various types represent
-    digits in the range 0 to 9:
-
-    * "D10.Predicate"
-
-    == Quasi-quoters
-
-    * The "D10.Char" and "D10.Num" modules include quasi-quoters
-      named @d10@ used to express single digits. For example, 7
-      can be written as @[d10|7|]@. This is an important feature
-      because the @D10@ types defined in these modules have
-      unsafe constructors, and the quasi-quoters provide
-      compile-time assurance that we never construct a @D10@
-      that represents a value outside the range 0 to 9.
-    * "D10.Char", "D10.Num", and "D10.Safe" include quasi-quoters
-      named @d10list@ to express lists of digits. For example,
-      [4, 5, 6] can be written as @[d10list|456|]@.
+    concept "D10.Char", "D10.Num", "D10.Safe".
 
 homepage:    https://github.com/typeclasses/d10
 bug-reports: https://github.com/typeclasses/d10/issues
@@ -64,7 +22,7 @@
 license: MIT
 license-file: license.txt
 
-build-type: Simple
+extra-source-files: *.md
 
 source-repository head
     type: git
@@ -80,12 +38,9 @@
 
 common library-dependencies
     build-depends:
-        base ^>= 4.13 || ^>= 4.14 || ^>= 4.15
-          || ^>= 4.16
-      , hashable ^>= 1.3 || ^>= 1.4
-      , template-haskell
-             ^>= 2.15 || ^>= 2.16 || ^>= 2.17
-          || ^>= 2.18
+        base ^>= 4.14 || ^>= 4.15 || ^>= 4.16 || ^>= 4.17
+      , hashable ^>= 1.3.5 || ^>= 1.4
+      , template-haskell ^>= 2.16 || ^>= 2.17 || ^>= 2.18 || ^>= 2.19
 
 common test-language
     import: language
@@ -97,7 +52,7 @@
     import: library-dependencies
     build-depends:
         d10
-      , hedgehog ^>= 1.0.1 || ^>= 1.1
+      , hedgehog ^>= 1.0.5 || ^>= 1.1 || ^>= 1.2
 
 common test
     import: test-language
@@ -112,26 +67,26 @@
     hs-source-dirs: src
     exposed-modules:
         D10.Char
-          , D10.Char.Arithmetic
-          , D10.Char.Conversions
-          , D10.Char.Quotes
-          , D10.Char.Splices
-          , D10.Char.Type
-          , D10.Char.Unsafe
-      , D10.Num
-          , D10.Num.Arithmetic
-          , D10.Num.Conversions
-          , D10.Num.Quotes
-          , D10.Num.Splices
-          , D10.Num.Type
-          , D10.Num.Unsafe
-      , D10.Safe
-          , D10.Safe.Arithmetic
-          , D10.Safe.Conversions
-          , D10.Safe.Quotes
-          , D10.Safe.Splices
-          , D10.Safe.Type
-      , D10.Predicate
+            D10.Char.Arithmetic
+            D10.Char.Conversions
+            D10.Char.Quotes
+            D10.Char.Splices
+            D10.Char.Type
+            D10.Char.Unsafe
+        D10.Num
+            D10.Num.Arithmetic
+            D10.Num.Conversions
+            D10.Num.Quotes
+            D10.Num.Splices
+            D10.Num.Type
+            D10.Num.Unsafe
+        D10.Safe
+            D10.Safe.Arithmetic
+            D10.Safe.Conversions
+            D10.Safe.Quotes
+            D10.Safe.Splices
+            D10.Safe.Type
+        D10.Predicate
 
 library d10-test
     import: test-language
@@ -139,7 +94,7 @@
     hs-source-dirs: library/d10-test
     exposed-modules:
         AssertQFails
-      , Fallible
+        Fallible
 
 test-suite char
     import: test
diff --git a/readme.md b/readme.md
new file mode 100644
--- /dev/null
+++ b/readme.md
@@ -0,0 +1,42 @@
+Data types representing the digits zero through nine.
+
+## Modules
+
+Each of the following modules defines a different type named `D10`, all of which
+are different representations of the same concept:
+
+* `D10.Char` - Defines a `D10` type as a newtype for `Char`, where the values
+  are restricted to characters between `'0'` and `'9'`.
+
+* `D10.Num` - Defines a `D10` type as a newtype for any type with an instance of
+  the `Num` class, where the values are restricted to numbers between `fromInteger
+  0` and `fromInteger 9`.
+
+* `D10.Safe` - Defines a `D10` type as `D0 | D1 | D2 | ... | D9`.
+
+The `Arithmetic` modules provide infix operators `(+)`, `(-)`, `(*)` for modular
+arithmetic:
+
+* `D10.Char.Arithmetic`
+* `D10.Num.Arithmetic`
+* `D10.Safe.Arithmetic`
+
+The following modules export constructors that can be used incorrectly:
+
+* `D10.Char.Unsafe`
+* `D10.Num.Unsafe`
+
+Functions to test whether values of various types represent digits in the range
+0 to 9:
+
+* `D10.Predicate`
+
+## Quasi-quoters
+
+Each module that defines a `D10` type also defines quasi-quoters for it. With
+the `QuasiQuotes` GHC extension enabled, a single digit like *7* can be written
+as `[d10|7|]`, and a list of digits like *[4,5,6]* can be written as
+`[d10|456|]`. For `D10.Char` and `D10.Num`, the quasi-quoters are an important
+feature, because the `D10` types defined in these modules have unsafe
+constructors, and the quasi-quoters provide compile-time assurance that we never
+construct a `D10` that represents a value outside the range *0* to *9*.
