diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,9 @@
 # ChangeLog
 
+## 0.7.5
+
+* Now only depends on `fail` shim for `ghc < 8`.
+
 ## 0.7.4
 
 * Fix for compilation with `ghc-8.10` in `0.7.3` did not use enough
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,45 +1,48 @@
 # store
 
-The 'store' package provides efficient binary serialization. There are a couple
-features that particularly distinguish it from most prior Haskell serialization
-libraries:
+The 'store' package provides efficient binary serialization. There are
+a couple features that particularly distinguish it from most prior
+Haskell serialization libraries:
 
-* Its primary goal is speed. By default, direct machine representations are used
-  for things like numeric values (`Int`, `Double`, `Word32`, etc) and buffers
-  (`Text`, `ByteString`, `Vector`, etc). This means that much of serialization
-  uses the equivalent of `memcpy`.
+* Its primary goal is speed. By default, direct machine
+  representations are used for things like numeric values (`Int`,
+  `Double`, `Word32`, etc) and buffers (`Text`, `ByteString`,
+  `Vector`, etc). This means that much of serialization uses the
+  equivalent of `memcpy`.
 
-  We have plans for supporting architecture independent serialization - see
-  [#36](https://github.com/fpco/store/issues/36) and
-  [#31](https://github.com/fpco/store/issues/31). This plan makes little endian
-  the default, so that the most common endianness has no overhead.
+  We have plans for supporting architecture independent
+  serialization - see [#36](https://github.com/fpco/store/issues/36)
+  and [#31](https://github.com/fpco/store/issues/31). This plan makes
+  little endian the default, so that the most common endianness has no
+  overhead.
 
   - Another way that the serialization behavior can vary is if
     integer-simple is used instead of GHC's default of using
     GMP. `Integer` serialized with the `integer-simple` flag enabled
     are not compatible with those serialized without the flag enabled.
 
-* Instead of implementing lazy serialization / deserialization involving
-  multiple input / output buffers, `peek` and `poke` always work with a single
-  buffer. This buffer is allocated by asking the value for its size before
-  encoding. This simplifies the encoding logic, and allows for highly optimized
-  tight loops.
+* Instead of implementing lazy serialization / deserialization
+  involving multiple input / output buffers, `peek` and `poke` always
+  work with a single buffer. This buffer is allocated by asking the
+  value for its size before encoding. This simplifies the encoding
+  logic, and allows for highly optimized tight loops.
 
-* `store` can optimize size computations by knowing when some types always
-  use the same number of bytes.  This allows us to compute the byte size of a
-  `Vector Int32` by just doing `length v * 4`.
+* `store` can optimize size computations by knowing when some types
+  always use the same number of bytes.  This allows us to compute the
+  byte size of a `Vector Int32` by just doing `length v * 4`.
 
 It also features:
 
 * Optimized serialization instances for many types from base, vector,
   bytestring, text, containers, time, template-haskell, and more.
 
-* TH and GHC Generics based generation of Store instances for datatypes
+* TH and GHC Generics based generation of Store instances for
+  datatypes.
 
 * TH generation of testcases.
 
-* Utilities for streaming encoding / decoding of Store encoded messages, via the
-  `store-streaming` package.
+* Utilities for streaming encoding / decoding of Store encoded
+  messages, via the `store-streaming` package.
 
 ## Gotchas
 
@@ -51,10 +54,10 @@
   machine endianness.
 
 * Store's builtin instances trust the data when deserializing. For
-  example, the deserialization of `Vector` will read the vector's link
-  from the first 8 bytes. It will then allocate enough memory to store
-  all the elements. Malicious or malformed input could cause
-  allocation of large amounts of memory.  See [issue #122][]
+  example, the deserialization of `Vector` will read the vector's
+  length from the first 8 bytes. It will then allocate enough memory
+  to store all the elements. Malicious or malformed input could cause
+  allocation of large amounts of memory.  See [issue #122][].
 
 [issue #122]: https://github.com/fpco/store/issues/122
 
diff --git a/store.cabal b/store.cabal
--- a/store.cabal
+++ b/store.cabal
@@ -1,13 +1,13 @@
 cabal-version: 1.12
 
--- This file has been generated from package.yaml by hpack version 0.31.1.
+-- This file has been generated from package.yaml by hpack version 0.33.0.
 --
 -- see: https://github.com/sol/hpack
 --
--- hash: b63dca2860ccf2f472bd33ec03365cee58303ec3d90dd34d9d62ecf1a7c3edcc
+-- hash: cec195878a84e3e73cf795dd6ee94ffbb3ce638c7c13e0fb6c6cbc40fadc24c2
 
 name:           store
-version:        0.7.4
+version:        0.7.5
 synopsis:       Fast binary serialization
 category:       Serialization, Data
 homepage:       https://github.com/fpco/store#readme