diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,16 @@
 The format is based on [Keep a Changelog 1.1](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to the [Haskell Package Versioning Policy](https://pvp.haskell.org/).
 
+## [1.0.0.0] - 2026-04-22
+
+### Added
+
+- support for yaya-1.0.0.0 and yaya-unsafe-1.0.0.0
+
+### Changed
+
+- Types, constructors, and functions no longer have an `F` suffix (for example, `TipF` is now `Tip`). The expectation is that if both this and the `containers` identifiers of the same name are needed in the same module, qualified imports should be used.
+
 ## [0.2.0.0] - 2026-01-18
 
 ### Added
@@ -42,9 +52,10 @@
 
 - initial release of this package
 
-[0.2.0.0]: https://github.com/sellout/no-recursion/compare/v3.2.3...v4.0.0
-[0.1.2.2]: https://github.com/sellout/no-recursion/compare/v3.2.1...v3.2.3
-[0.1.2.1]: https://github.com/sellout/no-recursion/compare/v3.1.0...v3.2.1
-[0.1.2.0]: https://github.com/sellout/no-recursion/compare/v3.0.0...v3.1.0
-[0.1.1.0]: https://github.com/sellout/no-recursion/compare/v1.0.0...v3.0.0
+[1.0.0.0]: https://github.com/sellout/yaya/compare/v4.0.0...v5.0.0
+[0.2.0.0]: https://github.com/sellout/yaya/compare/v3.2.3...v4.0.0
+[0.1.2.2]: https://github.com/sellout/yaya/compare/v3.2.1...v3.2.3
+[0.1.2.1]: https://github.com/sellout/yaya/compare/v3.1.0...v3.2.1
+[0.1.2.0]: https://github.com/sellout/yaya/compare/v3.0.0...v3.1.0
+[0.1.1.0]: https://github.com/sellout/yaya/compare/v1.0.0...v3.0.0
 [0.1.0.2]: https://github.com/sellout/yaya/releases/tag/v1.0.0
diff --git a/Setup.hs b/Setup.hs
--- a/Setup.hs
+++ b/Setup.hs
@@ -1,17 +1,12 @@
 -- __NB__: `custom-setup` doesn’t have any way to specify extensions or options,
 --         so any we want need to be specified here.
-{-# LANGUAGE CPP #-}
 {-# LANGUAGE PackageImports #-}
 {-# LANGUAGE Unsafe #-}
 {-# LANGUAGE NoImplicitPrelude #-}
-#if MIN_VERSION_GLASGOW_HASKELL(8, 0, 0, 0)
 {-# OPTIONS_GHC -Weverything #-}
 -- Warns even when `Unsafe` is explicit, not inferred. See
 -- https://gitlab.haskell.org/ghc/ghc/-/issues/16689
 {-# OPTIONS_GHC -Wno-unsafe #-}
-#else
-{-# OPTIONS_GHC -Wall #-}
-#endif
 
 module Main (main) where
 
diff --git a/docs/license-report.md b/docs/license-report.md
--- a/docs/license-report.md
+++ b/docs/license-report.md
@@ -9,33 +9,32 @@
 | Name | Version | [SPDX](https://spdx.org/licenses/) License Id | Description | Also depended upon by |
 | --- | --- | --- | --- | --- |
 | **`base`** | [`4.20.0.0`](http://hackage.haskell.org/package/base-4.20.0.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/base-4.20.0.0/src/LICENSE) | Core data structures and operations | *(core library)* |
-| **`containers`** | [`0.7`](http://hackage.haskell.org/package/containers-0.7) | [`BSD-3-Clause`](http://hackage.haskell.org/package/containers-0.7/src/LICENSE) | Assorted concrete container types | `adjunctions`, `bifunctors`, `binary`, `comonad`, `free`, `ghc`, `ghc-boot`, `ghc-heap`, `ghci`, `hashable`, `hpc`, `indexed-traversable`, `invariant`, `lens`, `parallel`, `semigroupoids`, `th-abstraction` |
-| `no-recursion` | [`0.4.0.0`](http://hackage.haskell.org/package/no-recursion-0.4.0.0) | [`(AGPL-3.0-only WITH Universal-FOSS-exception-1.0 OR LicenseRef-commercial)`](http://hackage.haskell.org/package/no-recursion-0.4.0.0/src/LICENSE) | A GHC plugin to remove support for recursion | `yaya` |
-| `yaya` | [`0.7.0.0`](http://hackage.haskell.org/package/yaya-0.7.0.0) |  *MISSING* | *MISSING* |  |
+| **`containers`** | [`0.7`](http://hackage.haskell.org/package/containers-0.7) | [`BSD-3-Clause`](http://hackage.haskell.org/package/containers-0.7/src/LICENSE) | Assorted concrete container types | `adjunctions`, `bifunctors`, `binary`, `comonad`, `free`, `ghc`, `ghc-boot`, `ghc-heap`, `ghci`, `hashable`, `hpc`, `indexed-traversable`, `invariant`, `semigroupoids`, `th-abstraction` |
+| `no-recursion` | [`0.4.0.0`](http://hackage.haskell.org/package/no-recursion-0.4.0.0) | [`(AGPL-3.0-only WITH Universal-FOSS-exception-1.0 OR LicenseRef-commercial)`](http://hackage.haskell.org/package/no-recursion-0.4.0.0/src/LICENSE) | A GHC plugin to remove support for recursion | `yaya`, `yaya-unsafe` |
+| `yaya` | [`1.0.0.0`](http://hackage.haskell.org/package/yaya-1.0.0.0) |  *MISSING* | *MISSING* | `yaya-unsafe` |
+| `yaya-unsafe` | [`1.0.0.0`](http://hackage.haskell.org/package/yaya-unsafe-1.0.0.0) |  *MISSING* | *MISSING* |  |
 
 ## Indirect transitive dependencies
 
 | Name | Version | [SPDX](https://spdx.org/licenses/) License Id | Description | Depended upon by |
 | --- | --- | --- | --- | --- |
-| `OneTuple` | [`0.4.2.1`](http://hackage.haskell.org/package/OneTuple-0.4.2.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/OneTuple-0.4.2.1/src/LICENSE) | Singleton Tuple | `indexed-traversable-instances` |
 | `StateVar` | [`1.2.2`](http://hackage.haskell.org/package/StateVar-1.2.2) | [`BSD-3-Clause`](http://hackage.haskell.org/package/StateVar-1.2.2/src/LICENSE) | State variables | `contravariant`, `invariant` |
 | `adjunctions` | [`4.4.4`](http://hackage.haskell.org/package/adjunctions-4.4.4) | [`BSD-2-Clause`](http://hackage.haskell.org/package/adjunctions-4.4.4/src/LICENSE) | Adjunctions and representable functors | `kan-extensions` |
-| **`array`** | [`0.5.7.0`](http://hackage.haskell.org/package/array-0.5.7.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/array-0.5.7.0/src/LICENSE) | Mutable and immutable arrays | `binary`, `containers`, `deepseq`, `ghc`, `ghci`, `indexed-traversable`, `invariant`, `lens`, `parallel`, `stm`, `text` |
-| `assoc` | [`1.1.1`](http://hackage.haskell.org/package/assoc-1.1.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/assoc-1.1.1/src/LICENSE) | swap and assoc: Symmetric and Semigroupy Bifunctors | `bifunctors`, `lens`, `strict`, `these` |
-| `base-orphans` | [`0.9.4`](http://hackage.haskell.org/package/base-orphans-0.9.4) | [`MIT`](http://hackage.haskell.org/package/base-orphans-0.9.4/src/LICENSE) | Backwards-compatible orphan instances for base | `lens`, `profunctors`, `semigroupoids`, `transformers-base` |
-| `bifunctors` | [`5.6.3`](http://hackage.haskell.org/package/bifunctors-5.6.3) | [`BSD-3-Clause`](http://hackage.haskell.org/package/bifunctors-5.6.3/src/LICENSE) | Bifunctors | `either`, `invariant`, `lens`, `profunctors`, `semigroupoids` |
+| **`array`** | [`0.5.7.0`](http://hackage.haskell.org/package/array-0.5.7.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/array-0.5.7.0/src/LICENSE) | Mutable and immutable arrays | `binary`, `containers`, `deepseq`, `ghc`, `ghci`, `indexed-traversable`, `invariant`, `stm`, `text` |
+| `assoc` | [`1.1.1`](http://hackage.haskell.org/package/assoc-1.1.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/assoc-1.1.1/src/LICENSE) | swap and assoc: Symmetric and Semigroupy Bifunctors | `bifunctors`, `strict`, `these` |
+| `base-orphans` | [`0.9.4`](http://hackage.haskell.org/package/base-orphans-0.9.4) | [`MIT`](http://hackage.haskell.org/package/base-orphans-0.9.4/src/LICENSE) | Backwards-compatible orphan instances for base | `profunctors`, `semigroupoids`, `transformers-base` |
+| `bifunctors` | [`5.6.3`](http://hackage.haskell.org/package/bifunctors-5.6.3) | [`BSD-3-Clause`](http://hackage.haskell.org/package/bifunctors-5.6.3/src/LICENSE) | Bifunctors | `either`, `invariant`, `profunctors`, `semigroupoids` |
 | **`binary`** | [`0.8.9.2`](http://hackage.haskell.org/package/binary-0.8.9.2) | [`BSD-3-Clause`](http://hackage.haskell.org/package/binary-0.8.9.2/src/LICENSE) | Binary serialisation for Haskell values using lazy ByteStrings | `ghc`, `ghc-boot`, `ghci`, `strict`, `text`, `these` |
-| **`bytestring`** | [`0.12.1.0`](http://hackage.haskell.org/package/bytestring-0.12.1.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/bytestring-0.12.1.0/src/LICENSE) | Fast, compact, strict and lazy byte strings with a list interface | `binary`, `filepath`, `ghc`, `ghc-boot`, `ghci`, `hashable`, `lens`, `os-string`, `strict`, `text`, `unix` |
-| `call-stack` | [`0.4.0`](http://hackage.haskell.org/package/call-stack-0.4.0) | [`MIT`](http://hackage.haskell.org/package/call-stack-0.4.0/src/LICENSE) | Use GHC call-stacks in a backward compatible way | `lens` |
-| `comonad` | [`5.0.10`](http://hackage.haskell.org/package/comonad-5.0.10) | [`BSD-3-Clause`](http://hackage.haskell.org/package/comonad-5.0.10/src/LICENSE) | Comonads | `adjunctions`, `bifunctors`, `free`, `invariant`, `kan-extensions`, `lens`, `profunctors`, `semigroupoids`, `yaya` |
-| `contravariant` | [`1.5.6`](http://hackage.haskell.org/package/contravariant-1.5.6) | [`BSD-3-Clause`](http://hackage.haskell.org/package/contravariant-1.5.6/src/LICENSE) | Contravariant functors | `invariant`, `kan-extensions`, `lens`, `profunctors`, `semigroupoids` |
-| **`deepseq`** | [`1.5.0.0`](http://hackage.haskell.org/package/deepseq-1.5.0.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/deepseq-1.5.0.0/src/LICENSE) | Deep evaluation of data structures | `bytestring`, `containers`, `filepath`, `ghc`, `ghc-boot`, `ghci`, `hashable`, `hpc`, `os-string`, `parallel`, `pretty`, `primitive`, `process`, `strict`, `tagged`, `text`, `these`, `time`, `unordered-containers`, `vector` |
+| **`bytestring`** | [`0.12.1.0`](http://hackage.haskell.org/package/bytestring-0.12.1.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/bytestring-0.12.1.0/src/LICENSE) | Fast, compact, strict and lazy byte strings with a list interface | `binary`, `filepath`, `ghc`, `ghc-boot`, `ghci`, `hashable`, `os-string`, `strict`, `text`, `unix` |
+| `comonad` | [`5.0.10`](http://hackage.haskell.org/package/comonad-5.0.10) | [`BSD-3-Clause`](http://hackage.haskell.org/package/comonad-5.0.10/src/LICENSE) | Comonads | `adjunctions`, `bifunctors`, `free`, `invariant`, `kan-extensions`, `profunctors`, `semigroupoids`, `yaya`, `yaya-unsafe` |
+| `contravariant` | [`1.5.6`](http://hackage.haskell.org/package/contravariant-1.5.6) | [`BSD-3-Clause`](http://hackage.haskell.org/package/contravariant-1.5.6/src/LICENSE) | Contravariant functors | `invariant`, `kan-extensions`, `profunctors`, `semigroupoids` |
+| **`deepseq`** | [`1.5.0.0`](http://hackage.haskell.org/package/deepseq-1.5.0.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/deepseq-1.5.0.0/src/LICENSE) | Deep evaluation of data structures | `bytestring`, `containers`, `filepath`, `ghc`, `ghc-boot`, `ghci`, `hashable`, `hpc`, `os-string`, `pretty`, `process`, `strict`, `tagged`, `text`, `these`, `time`, `unordered-containers` |
 | **`directory`** | [`1.3.8.3`](http://hackage.haskell.org/package/directory-1.3.8.3) | [`BSD-3-Clause`](http://hackage.haskell.org/package/directory-1.3.8.3/src/LICENSE) | Platform-agnostic library for filesystem operations | `ghc`, `ghc-boot`, `hpc`, `process` |
-| `distributive` | [`0.6.3`](http://hackage.haskell.org/package/distributive-0.6.3) | [`BSD-3-Clause`](http://hackage.haskell.org/package/distributive-0.6.3/src/LICENSE) | Distributive functors -- Dual to Traversable | `adjunctions`, `comonad`, `free`, `kan-extensions`, `lens`, `profunctors` |
+| `distributive` | [`0.6.3`](http://hackage.haskell.org/package/distributive-0.6.3) | [`BSD-3-Clause`](http://hackage.haskell.org/package/distributive-0.6.3/src/LICENSE) | Distributive functors -- Dual to Traversable | `adjunctions`, `comonad`, `free`, `kan-extensions`, `profunctors` |
 | `either` | [`5.0.3`](http://hackage.haskell.org/package/either-5.0.3) | [`BSD-3-Clause`](http://hackage.haskell.org/package/either-5.0.3/src/LICENSE) | Combinators for working with sums | `yaya` |
-| **`exceptions`** | [`0.10.7`](http://hackage.haskell.org/package/exceptions-0.10.7) | [`BSD-3-Clause`](http://hackage.haskell.org/package/exceptions-0.10.7/src/LICENSE) | Extensible optionally-pure exceptions | `filepath`, `free`, `ghc`, `kan-extensions`, `lens`, `os-string`, `semaphore-compat` |
-| **`filepath`** | [`1.5.2.0`](http://hackage.haskell.org/package/filepath-1.5.2.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/filepath-1.5.2.0/src/LICENSE) | Library for manipulating FilePaths in a cross platform way. | `directory`, `ghc`, `ghc-boot`, `ghci`, `hashable`, `hpc`, `lens`, `process`, `unix` |
-| `free` | [`5.2`](http://hackage.haskell.org/package/free-5.2) | [`BSD-3-Clause`](http://hackage.haskell.org/package/free-5.2/src/LICENSE) | Monads for free | `adjunctions`, `kan-extensions`, `lens`, `yaya` |
+| **`exceptions`** | [`0.10.7`](http://hackage.haskell.org/package/exceptions-0.10.7) | [`BSD-3-Clause`](http://hackage.haskell.org/package/exceptions-0.10.7/src/LICENSE) | Extensible optionally-pure exceptions | `filepath`, `free`, `ghc`, `kan-extensions`, `os-string`, `semaphore-compat` |
+| **`filepath`** | [`1.5.2.0`](http://hackage.haskell.org/package/filepath-1.5.2.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/filepath-1.5.2.0/src/LICENSE) | Library for manipulating FilePaths in a cross platform way. | `directory`, `ghc`, `ghc-boot`, `ghci`, `hashable`, `hpc`, `process`, `unix` |
+| `free` | [`5.2`](http://hackage.haskell.org/package/free-5.2) | [`BSD-3-Clause`](http://hackage.haskell.org/package/free-5.2/src/LICENSE) | Monads for free | `adjunctions`, `kan-extensions`, `yaya`, `yaya-unsafe` |
 | **`ghc`** | [`9.10.1`](http://hackage.haskell.org/package/ghc-9.10.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/ghc-9.10.1/src/LICENSE) | The GHC API | `no-recursion` |
 | **`ghc-bignum`** | [`1.3`](http://hackage.haskell.org/package/ghc-bignum-1.3) | [`BSD-3-Clause`](http://hackage.haskell.org/package/ghc-bignum-1.3/src/LICENSE) | GHC BigNum library | `ghc-internal` |
 | **`ghc-boot`** | [`9.10.1`](http://hackage.haskell.org/package/ghc-boot-9.10.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/ghc-boot-9.10.1/src/LICENSE) | Shared functionality between GHC and its boot libraries | `ghc`, `ghci` |
@@ -45,36 +44,29 @@
 | **`ghc-platform`** | [`0.1.0.0`](http://hackage.haskell.org/package/ghc-platform-0.1.0.0) |  *MISSING* | *MISSING* | `ghc-boot` |
 | **`ghc-prim`** | [`0.11.0`](http://hackage.haskell.org/package/ghc-prim-0.11.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/ghc-prim-0.11.0/src/LICENSE) | GHC primitives | *(core library)* |
 | **`ghci`** | [`9.10.1`](http://hackage.haskell.org/package/ghci-9.10.1) |  *MISSING* | *MISSING* | `ghc` |
-| `hashable` | [`1.5.1.0`](http://hackage.haskell.org/package/hashable-1.5.1.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/hashable-1.5.1.0/src/LICENSE) | A class for types that can be converted to a hash value | `lens`, `semigroupoids`, `strict`, `these`, `unordered-containers` |
+| `hashable` | [`1.5.1.0`](http://hackage.haskell.org/package/hashable-1.5.1.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/hashable-1.5.1.0/src/LICENSE) | A class for types that can be converted to a hash value | `semigroupoids`, `strict`, `these`, `unordered-containers` |
 | **`hpc`** | [`0.7.0.1`](http://hackage.haskell.org/package/hpc-0.7.0.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/hpc-0.7.0.1/src/LICENSE) | Code Coverage Library for Haskell | `ghc` |
-| `indexed-traversable` | [`0.1.4`](http://hackage.haskell.org/package/indexed-traversable-0.1.4) | [`BSD-2-Clause`](http://hackage.haskell.org/package/indexed-traversable-0.1.4/src/LICENSE) | FunctorWithIndex, FoldableWithIndex, TraversableWithIndex | `comonad`, `free`, `indexed-traversable-instances`, `lens` |
-| `indexed-traversable-instances` | [`0.1.2`](http://hackage.haskell.org/package/indexed-traversable-instances-0.1.2) | [`BSD-2-Clause`](http://hackage.haskell.org/package/indexed-traversable-instances-0.1.2/src/LICENSE) | More instances of FunctorWithIndex, FoldableWithIndex, TraversableWithIndex | `lens` |
+| `indexed-traversable` | [`0.1.4`](http://hackage.haskell.org/package/indexed-traversable-0.1.4) | [`BSD-2-Clause`](http://hackage.haskell.org/package/indexed-traversable-0.1.4/src/LICENSE) | FunctorWithIndex, FoldableWithIndex, TraversableWithIndex | `comonad`, `free` |
 | `invariant` | [`0.6.5`](http://hackage.haskell.org/package/invariant-0.6.5) | [`BSD-2-Clause`](http://hackage.haskell.org/package/invariant-0.6.5/src/LICENSE) | Haskell98 invariant functors | `kan-extensions` |
-| `kan-extensions` | [`5.2.8`](http://hackage.haskell.org/package/kan-extensions-5.2.8) | [`BSD-3-Clause`](http://hackage.haskell.org/package/kan-extensions-5.2.8/src/LICENSE) | Kan extensions, Kan lifts, the Yoneda lemma, and (co)density (co)monads | `lens`, `yaya` |
-| `lens` | [`5.3.6`](http://hackage.haskell.org/package/lens-5.3.6) | [`BSD-2-Clause`](http://hackage.haskell.org/package/lens-5.3.6/src/LICENSE) | Lenses, Folds and Traversals | `yaya` |
-| **`mtl`** | [`2.3.1`](http://hackage.haskell.org/package/mtl-2.3.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/mtl-2.3.1/src/LICENSE) | Monad classes for transformers, using functional dependencies | `adjunctions`, `either`, `exceptions`, `free`, `kan-extensions`, `lens` |
+| `kan-extensions` | [`5.2.8`](http://hackage.haskell.org/package/kan-extensions-5.2.8) | [`BSD-3-Clause`](http://hackage.haskell.org/package/kan-extensions-5.2.8/src/LICENSE) | Kan extensions, Kan lifts, the Yoneda lemma, and (co)density (co)monads | `yaya` |
+| **`mtl`** | [`2.3.1`](http://hackage.haskell.org/package/mtl-2.3.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/mtl-2.3.1/src/LICENSE) | Monad classes for transformers, using functional dependencies | `adjunctions`, `either`, `exceptions`, `free`, `kan-extensions` |
 | **`os-string`** | [`2.0.2`](http://hackage.haskell.org/package/os-string-2.0.2) | [`BSD-3-Clause`](http://hackage.haskell.org/package/os-string-2.0.2/src/LICENSE) | Library for manipulating Operating system strings. | `directory`, `filepath`, `hashable`, `unix` |
-| `parallel` | [`3.3.0.0`](http://hackage.haskell.org/package/parallel-3.3.0.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/parallel-3.3.0.0/src/LICENSE) | Parallel programming library | `lens` |
 | **`pretty`** | [`1.1.3.6`](http://hackage.haskell.org/package/pretty-1.1.3.6) | [`BSD-3-Clause`](http://hackage.haskell.org/package/pretty-1.1.3.6/src/LICENSE) | Pretty-printing library | `template-haskell` |
-| `primitive` | [`0.9.1.0`](http://hackage.haskell.org/package/primitive-0.9.1.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/primitive-0.9.1.0/src/LICENSE) | Primitive memory-related operations | `vector` |
 | **`process`** | [`1.6.19.0`](http://hackage.haskell.org/package/process-1.6.19.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/process-1.6.19.0/src/LICENSE) | Process libraries | `ghc` |
-| `profunctors` | [`5.6.3`](http://hackage.haskell.org/package/profunctors-5.6.3) | [`BSD-3-Clause`](http://hackage.haskell.org/package/profunctors-5.6.3/src/LICENSE) | Profunctors | `adjunctions`, `either`, `free`, `invariant`, `kan-extensions`, `lens`, `yaya` |
-| `reflection` | [`2.1.9`](http://hackage.haskell.org/package/reflection-2.1.9) | [`BSD-3-Clause`](http://hackage.haskell.org/package/reflection-2.1.9/src/LICENSE) | Reifies arbitrary terms into types that can be reflected back into terms | `lens` |
+| `profunctors` | [`5.6.3`](http://hackage.haskell.org/package/profunctors-5.6.3) | [`BSD-3-Clause`](http://hackage.haskell.org/package/profunctors-5.6.3/src/LICENSE) | Profunctors | `adjunctions`, `either`, `free`, `invariant`, `kan-extensions`, `yaya` |
 | **`semaphore-compat`** | [`1.0.0`](http://hackage.haskell.org/package/semaphore-compat-1.0.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/semaphore-compat-1.0.0) | Cross-platform abstraction for system semaphores | `ghc` |
-| `semigroupoids` | [`6.0.2`](http://hackage.haskell.org/package/semigroupoids-6.0.2) | [`BSD-2-Clause`](http://hackage.haskell.org/package/semigroupoids-6.0.2/src/LICENSE) | Semigroupoids: Category sans id | `adjunctions`, `either`, `free`, `kan-extensions`, `lens` |
+| `semigroupoids` | [`6.0.2`](http://hackage.haskell.org/package/semigroupoids-6.0.2) | [`BSD-2-Clause`](http://hackage.haskell.org/package/semigroupoids-6.0.2/src/LICENSE) | Semigroupoids: Category sans id | `adjunctions`, `either`, `free`, `kan-extensions` |
 | **`stm`** | [`2.5.3.1`](http://hackage.haskell.org/package/stm-2.5.3.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/stm-2.5.3.1/src/LICENSE) | Software Transactional Memory | `StateVar`, `exceptions`, `ghc`, `invariant`, `transformers-base` |
-| `strict` | [`0.5.1`](http://hackage.haskell.org/package/strict-0.5.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/strict-0.5.1/src/LICENSE) | Strict data types and String IO. | `lens`, `yaya` |
-| `tagged` | [`0.8.10`](http://hackage.haskell.org/package/tagged-0.8.10) | [`BSD-3-Clause`](http://hackage.haskell.org/package/tagged-0.8.10/src/LICENSE) | Haskell 98 phantom types to avoid unsafely passing dummy arguments | `adjunctions`, `bifunctors`, `comonad`, `distributive`, `indexed-traversable-instances`, `invariant`, `lens`, `profunctors`, `semigroupoids` |
-| **`template-haskell`** | [`2.22.0.0`](http://hackage.haskell.org/package/template-haskell-2.22.0.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/template-haskell-2.22.0.0/src/LICENSE) | Support library for Template Haskell | `OneTuple`, `bifunctors`, `bytestring`, `containers`, `exceptions`, `filepath`, `free`, `ghc`, `ghci`, `invariant`, `lens`, `os-string`, `primitive`, `reflection`, `semigroupoids`, `tagged`, `text`, `th-abstraction`, `unordered-containers`, `yaya` |
-| **`text`** | [`2.1.1`](http://hackage.haskell.org/package/text-2.1.1) | [`BSD-2-Clause`](http://hackage.haskell.org/package/text-2.1.1/src/LICENSE) | An efficient packed Unicode text type. | `hashable`, `lens`, `strict` |
-| `th-abstraction` | [`0.7.2.0`](http://hackage.haskell.org/package/th-abstraction-0.7.2.0) | [`ISC`](http://hackage.haskell.org/package/th-abstraction-0.7.2.0/src/LICENSE) | Nicer interface for reified information about data types | `bifunctors`, `free`, `invariant`, `lens`, `yaya` |
-| `these` | [`1.2.1`](http://hackage.haskell.org/package/these-1.2.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/these-1.2.1/src/LICENSE) | An either-or-both data type. | `lens`, `strict` |
+| `strict` | [`0.5.1`](http://hackage.haskell.org/package/strict-0.5.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/strict-0.5.1/src/LICENSE) | Strict data types and String IO. | `yaya` |
+| `tagged` | [`0.8.10`](http://hackage.haskell.org/package/tagged-0.8.10) | [`BSD-3-Clause`](http://hackage.haskell.org/package/tagged-0.8.10/src/LICENSE) | Haskell 98 phantom types to avoid unsafely passing dummy arguments | `adjunctions`, `bifunctors`, `comonad`, `distributive`, `invariant`, `profunctors`, `semigroupoids` |
+| **`template-haskell`** | [`2.22.0.0`](http://hackage.haskell.org/package/template-haskell-2.22.0.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/template-haskell-2.22.0.0/src/LICENSE) | Support library for Template Haskell | `bifunctors`, `bytestring`, `containers`, `exceptions`, `filepath`, `free`, `ghc`, `ghci`, `invariant`, `os-string`, `semigroupoids`, `tagged`, `text`, `th-abstraction`, `unordered-containers`, `yaya` |
+| **`text`** | [`2.1.1`](http://hackage.haskell.org/package/text-2.1.1) | [`BSD-2-Clause`](http://hackage.haskell.org/package/text-2.1.1/src/LICENSE) | An efficient packed Unicode text type. | `hashable`, `strict` |
+| `th-abstraction` | [`0.7.2.0`](http://hackage.haskell.org/package/th-abstraction-0.7.2.0) | [`ISC`](http://hackage.haskell.org/package/th-abstraction-0.7.2.0/src/LICENSE) | Nicer interface for reified information about data types | `bifunctors`, `free`, `invariant`, `yaya` |
+| `these` | [`1.2.1`](http://hackage.haskell.org/package/these-1.2.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/these-1.2.1/src/LICENSE) | An either-or-both data type. | `strict` |
 | **`time`** | [`1.12.2`](http://hackage.haskell.org/package/time-1.12.2) | [`BSD-2-Clause`](http://hackage.haskell.org/package/time-1.12.2/src/LICENSE) | A time library | `directory`, `ghc`, `hpc`, `unix` |
-| **`transformers`** | [`0.6.1.1`](http://hackage.haskell.org/package/transformers-0.6.1.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/transformers-0.6.1.1/src/LICENSE) | Concrete functor and monad transformers | `StateVar`, `adjunctions`, `comonad`, `contravariant`, `distributive`, `exceptions`, `free`, `ghc`, `ghci`, `indexed-traversable`, `invariant`, `kan-extensions`, `lens`, `mtl`, `primitive`, `profunctors`, `semigroupoids`, `strict`, `transformers-base`, `transformers-compat`, `yaya` |
-| `transformers-base` | [`0.4.6`](http://hackage.haskell.org/package/transformers-base-0.4.6) | [`BSD-3-Clause`](http://hackage.haskell.org/package/transformers-base-0.4.6/src/LICENSE) | Lift computations from the bottom of a transformer stack | `free` |
+| **`transformers`** | [`0.6.1.1`](http://hackage.haskell.org/package/transformers-0.6.1.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/transformers-0.6.1.1/src/LICENSE) | Concrete functor and monad transformers | `StateVar`, `adjunctions`, `comonad`, `contravariant`, `distributive`, `exceptions`, `free`, `ghc`, `ghci`, `indexed-traversable`, `invariant`, `kan-extensions`, `mtl`, `profunctors`, `semigroupoids`, `strict`, `transformers-base`, `transformers-compat`, `yaya` |
+| `transformers-base` | [`0.4.6.1`](http://hackage.haskell.org/package/transformers-base-0.4.6.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/transformers-base-0.4.6.1/src/LICENSE) | Lift computations from the bottom of a transformer stack | `free` |
 | `transformers-compat` | [`0.7.2`](http://hackage.haskell.org/package/transformers-compat-0.7.2) | [`BSD-3-Clause`](http://hackage.haskell.org/package/transformers-compat-0.7.2/src/LICENSE) | A small compatibility shim for the transformers library | `semigroupoids`, `transformers-base` |
 | **`unix`** | [`2.8.5.1`](http://hackage.haskell.org/package/unix-2.8.5.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/unix-2.8.5.1/src/LICENSE) | POSIX functionality | `directory`, `ghc`, `ghc-boot`, `ghci`, `process`, `semaphore-compat` |
-| `unordered-containers` | [`0.2.21`](http://hackage.haskell.org/package/unordered-containers-0.2.21) | [`BSD-3-Clause`](http://hackage.haskell.org/package/unordered-containers-0.2.21/src/LICENSE) | Efficient hashing-based container types | `indexed-traversable-instances`, `invariant`, `lens`, `semigroupoids` |
-| `vector` | [`0.13.2.0`](http://hackage.haskell.org/package/vector-0.13.2.0) | [`BSD-3-Clause`](http://hackage.haskell.org/package/vector-0.13.2.0/src/LICENSE) | Efficient Arrays | `indexed-traversable-instances`, `lens` |
-| `vector-stream` | [`0.1.0.1`](http://hackage.haskell.org/package/vector-stream-0.1.0.1) | [`BSD-3-Clause`](http://hackage.haskell.org/package/vector-stream-0.1.0.1/src/LICENSE) | Efficient Streams | `vector` |
+| `unordered-containers` | [`0.2.21`](http://hackage.haskell.org/package/unordered-containers-0.2.21) | [`BSD-3-Clause`](http://hackage.haskell.org/package/unordered-containers-0.2.21/src/LICENSE) | Efficient hashing-based container types | `invariant`, `semigroupoids` |
 
diff --git a/src/Yaya/Containers/Pattern/IntMap.hs b/src/Yaya/Containers/Pattern/IntMap.hs
--- a/src/Yaya/Containers/Pattern/IntMap.hs
+++ b/src/Yaya/Containers/Pattern/IntMap.hs
@@ -3,52 +3,66 @@
 {-# OPTIONS_GHC -Wno-orphans #-}
 
 module Yaya.Containers.Pattern.IntMap
-  ( IntMapF (BinF, NilF, TipF),
+  ( IntMap (Bin, Nil, Tip),
   )
 where
 
-import "base" Control.Applicative (Alternative ((<|>)), Applicative ((<*>)), (*>))
-import "base" Control.Category (Category ((.)))
+import "base" Control.Applicative ((*>), (<*>), (<|>))
+import "base" Control.Category ((.))
 import "base" Data.Bool (Bool (False, True), (&&))
-import "base" Data.Eq (Eq ((==)))
+import "base" Data.Eq (Eq, (==))
 import "base" Data.Foldable (Foldable)
 import "base" Data.Function (($))
-import "base" Data.Functor (Functor (fmap), (<$), (<$>))
+import "base" Data.Functor (Functor, (<$), (<$>))
 import "base" Data.Functor.Classes
-  ( Eq1 (liftEq),
-    Eq2 (liftEq2),
-    Ord1 (liftCompare),
-    Ord2 (liftCompare2),
-    Read1 (liftReadPrec),
-    Read2 (liftReadPrec2),
-    Show1 (liftShowsPrec),
-    Show2 (liftShowsPrec2),
+  ( Eq1,
+    Eq2,
+    Ord1,
+    Ord2,
+    Read1,
+    Read2,
+    Show1,
+    Show2,
+    liftCompare,
+    liftCompare2,
+    liftEq,
+    liftEq2,
+    liftReadPrec,
+    liftReadPrec2,
+    liftShowsPrec,
+    liftShowsPrec2,
   )
-import "base" Data.Ord (Ord (compare, (<=)), Ordering (EQ, GT, LT))
+import "base" Data.Ord (Ord, Ordering (EQ, GT, LT), compare, (<=))
 import "base" Data.Semigroup ((<>))
 import "base" Data.Traversable (Traversable)
 import qualified "base" Data.Tuple as Tuple
 import "base" GHC.Generics (Generic, Generic1)
-import "base" GHC.Read (Read (readListPrec, readPrec), expectP, parens)
+import "base" GHC.Read (Read, expectP, parens, readListPrec, readPrec)
 import "base" Text.ParserCombinators.ReadPrec (prec, step)
 import qualified "base" Text.Read.Lex as Lex
-import "base" Text.Show (Show (showList, showsPrec), showParen, showString)
+import "base" Text.Show (Show, showList, showParen, showString, showsPrec)
 import qualified "containers" Data.IntMap.Internal as IntMap
 import "yaya" Yaya.Fold
-  ( Projectable (project),
-    Recursive (cata),
-    Steppable (embed),
+  ( Projectable,
+    Recursive,
+    Steppable,
+    cata,
+    embed,
+    project,
   )
-import "base" Prelude (Num ((+)))
+import qualified "yaya-unsafe" Yaya.Unsafe.Fold as Unsafe
+import "base" Prelude ((+))
 #if MIN_VERSION_containers(0, 8, 0)
 import qualified "containers" Data.IntSet.Internal.IntTreeCommons as IntMap
   ( Prefix (Prefix),
   )
+#endif
 
-data IntMapF a r
-  = NilF
-  | TipF IntMap.Key a
-  | BinF IntMap.Prefix r r
+data IntMap a r
+  = Nil
+  | Tip IntMap.Key a
+#if MIN_VERSION_containers(0, 8, 0)
+  | Bin IntMap.Prefix r r
   deriving stock
     ( Eq,
       Generic,
@@ -58,10 +72,7 @@
       Traversable
     )
 #else
-data IntMapF a r
-  = NilF
-  | TipF IntMap.Key a
-  | BinF IntMap.Prefix IntMap.Mask r r
+  | Bin IntMap.Prefix IntMap.Mask r r
   deriving stock
     ( Eq,
       Generic,
@@ -72,96 +83,98 @@
     )
 #endif
 
-instance Projectable (->) (IntMap.IntMap a) (IntMapF a) where
-  project IntMap.Nil = NilF
-  project (IntMap.Tip key a) = TipF key a
+instance Projectable (->) (IntMap.IntMap a) (IntMap a) where
+  project = \case
+    IntMap.Nil -> Nil
+    IntMap.Tip key a -> Tip key a
 #if MIN_VERSION_containers(0, 8, 0)
-  project (IntMap.Bin prefix l r) = BinF prefix l r
+    IntMap.Bin prefix l r -> Bin prefix l r
 #else
-  project (IntMap.Bin prefix mask l r) = BinF prefix mask l r
+    IntMap.Bin prefix mask l r -> Bin prefix mask l r
 #endif
 
-instance Recursive (->) (IntMap.IntMap a) (IntMapF a) where
-  cata φ = φ . fmap (cata φ) . project
+instance Recursive (->) (IntMap.IntMap a) (IntMap a) where
+  cata = Unsafe.unsafeCata
 
-instance Steppable (->) (IntMap.IntMap a) (IntMapF a) where
-  embed NilF = IntMap.Nil
-  embed (TipF key a) = IntMap.Tip key a
+instance Steppable (->) (IntMap.IntMap a) (IntMap a) where
+  embed = \case
+    Nil -> IntMap.Nil
+    Tip key a -> IntMap.Tip key a
 #if MIN_VERSION_containers(0, 8, 0)
-  embed (BinF prefix l r) = IntMap.Bin prefix l r
+    Bin prefix l r -> IntMap.Bin prefix l r
 #else
-  embed (BinF prefix mask l r) = IntMap.Bin prefix mask l r
+    Bin prefix mask l r -> IntMap.Bin prefix mask l r
 #endif
 
-instance (Eq a) => Eq1 (IntMapF a) where
+instance (Eq a) => Eq1 (IntMap a) where
   liftEq = liftEq2 (==)
 
-instance Eq2 IntMapF where
+instance Eq2 IntMap where
   liftEq2 f g = Tuple.curry $ \case
-    (NilF, NilF) -> True
-    (NilF, _) -> False
-    (_, NilF) -> False
-    (TipF key a, TipF key' a') -> key == key' && f a a'
-    (TipF {}, _) -> False
-    (_, TipF {}) -> False
+    (Nil, Nil) -> True
+    (Nil, _) -> False
+    (_, Nil) -> False
+    (Tip key a, Tip key' a') -> key == key' && f a a'
+    (Tip {}, _) -> False
+    (_, Tip {}) -> False
 #if MIN_VERSION_containers(0, 8, 0)
-    (BinF prefix l r, BinF prefix' l' r') ->
+    (Bin prefix l r, Bin prefix' l' r') ->
       prefix == prefix' && g l l' && g r r'
 #else
-    (BinF prefix mask l r, BinF prefix' mask' l' r') ->
+    (Bin prefix mask l r, Bin prefix' mask' l' r') ->
       prefix == prefix' && mask == mask' && g l l' && g r r'
 #endif
 
-instance (Ord a, Ord r) => Ord (IntMapF a r) where
+instance (Ord a, Ord r) => Ord (IntMap a r) where
   compare = liftCompare compare
 
-instance (Ord a) => Ord1 (IntMapF a) where
+instance (Ord a) => Ord1 (IntMap a) where
   liftCompare = liftCompare2 compare
 
-instance Ord2 IntMapF where
+instance Ord2 IntMap where
   liftCompare2 f g = Tuple.curry $ \case
-    (NilF, NilF) -> EQ
-    (NilF, _) -> LT
-    (TipF {}, NilF) -> GT
-    (TipF key a, TipF key' a') -> compare key key' <> f a a'
-    (TipF {}, BinF {}) -> LT
-    (BinF {}, NilF) -> GT
-    (BinF {}, TipF {}) -> GT
+    (Nil, Nil) -> EQ
+    (Nil, _) -> LT
+    (Tip {}, Nil) -> GT
+    (Tip key a, Tip key' a') -> compare key key' <> f a a'
+    (Tip {}, Bin {}) -> LT
+    (Bin {}, Nil) -> GT
+    (Bin {}, Tip {}) -> GT
 #if MIN_VERSION_containers(0, 8, 0)
-    (BinF (IntMap.Prefix prefix) l r, BinF (IntMap.Prefix prefix') l' r') ->
+    (Bin (IntMap.Prefix prefix) l r, Bin (IntMap.Prefix prefix') l' r') ->
       compare prefix prefix' <> g l l' <> g r r'
 #else
-    (BinF prefix mask l r, BinF prefix' mask' l' r') ->
+    (Bin prefix mask l r, Bin prefix' mask' l' r') ->
       compare prefix prefix' <> compare mask mask' <> g l l' <> g r r'
 #endif
 
 -- | @since 0.1.2.0
-instance (Read a, Read r) => Read (IntMapF a r) where
+instance (Read a, Read r) => Read (IntMap a r) where
   readPrec = liftReadPrec readPrec readListPrec
 
 -- | @since 0.1.2.0
-instance (Read a) => Read1 (IntMapF a) where
+instance (Read a) => Read1 (IntMap a) where
   liftReadPrec = liftReadPrec2 readPrec readListPrec
 
 -- | @since 0.1.2.0
-instance Read2 IntMapF where
+instance Read2 IntMap where
   liftReadPrec2 readPrecA _ readPrecR _ =
     let appPrec = 10
      in parens . prec appPrec $
-          NilF
-            <$ expectP (Lex.Ident "NilF")
+          Nil
+            <$ expectP (Lex.Ident "Nil")
             <|> expectP (Lex.Ident "TipF")
-              *> (TipF <$> step readPrec <*> step readPrecA)
+              *> (Tip <$> step readPrec <*> step readPrecA)
 #if MIN_VERSION_containers(0, 8, 0)
-            <|> expectP (Lex.Ident "BinF")
-              *> ( BinF . IntMap.Prefix
+            <|> expectP (Lex.Ident "Bin")
+              *> ( Bin . IntMap.Prefix
                      <$> step readPrec
                      <*> step readPrecR
                      <*> step readPrecR
                  )
 #else
-            <|> expectP (Lex.Ident "BinF")
-              *> ( BinF
+            <|> expectP (Lex.Ident "Bin")
+              *> ( Bin
                      <$> step readPrec
                      <*> step readPrec
                      <*> step readPrecR
@@ -169,37 +182,37 @@
                  )
 #endif
 
-instance (Show a, Show r) => Show (IntMapF a r) where
+instance (Show a, Show r) => Show (IntMap a r) where
   showsPrec = liftShowsPrec showsPrec showList
 
-instance (Show a) => Show1 (IntMapF a) where
+instance (Show a) => Show1 (IntMap a) where
   liftShowsPrec = liftShowsPrec2 showsPrec showList
 
-instance Show2 IntMapF where
+instance Show2 IntMap where
   liftShowsPrec2 showsPrecA _ showsPrecR _ p =
     let appPrec = 10
         nextPrec = appPrec + 1
      in \case
-          NilF -> showString "NilF"
-          TipF key a ->
+          Nil -> showString "Nil"
+          Tip key a ->
             showParen (nextPrec <= p) $
-              showString "TipF "
+              showString "Tip "
                 . showsPrec nextPrec key
                 . showString " "
                 . showsPrecA nextPrec a
 #if MIN_VERSION_containers(0, 8, 0)
-          BinF (IntMap.Prefix prefix) l r ->
+          Bin (IntMap.Prefix prefix) l r ->
             showParen (nextPrec <= p) $
-              showString "BinF "
+              showString "Bin "
                 . showsPrec nextPrec prefix
                 . showString " "
                 . showsPrecR nextPrec l
                 . showString " "
                 . showsPrecR nextPrec r
 #else
-          BinF prefix mask l r ->
+          Bin prefix mask l r ->
             showParen (nextPrec <= p) $
-              showString "BinF "
+              showString "Bin "
                 . showsPrec nextPrec prefix
                 . showString " "
                 . showsPrec nextPrec mask
diff --git a/src/Yaya/Containers/Pattern/IntSet.hs b/src/Yaya/Containers/Pattern/IntSet.hs
--- a/src/Yaya/Containers/Pattern/IntSet.hs
+++ b/src/Yaya/Containers/Pattern/IntSet.hs
@@ -3,53 +3,59 @@
 {-# OPTIONS_GHC -Wno-orphans #-}
 
 module Yaya.Containers.Pattern.IntSet
-  ( IntSetF (BinF, NilF, TipF),
+  ( IntSet (Bin, Nil, Tip),
   )
 where
 
-import "base" Control.Applicative
-  ( Alternative ((<|>)),
-    Applicative ((<*>)),
-    (*>),
-  )
-import "base" Control.Category (Category ((.)))
+import "base" Control.Applicative ((*>), (<*>), (<|>))
+import "base" Control.Category ((.))
 import "base" Data.Bool (Bool (False, True), (&&))
-import "base" Data.Eq (Eq ((==)))
+import "base" Data.Eq (Eq, (==))
 import "base" Data.Foldable (Foldable)
 import "base" Data.Function (($))
-import "base" Data.Functor (Functor (fmap), (<$), (<$>))
+import "base" Data.Functor (Functor, (<$), (<$>))
 import "base" Data.Functor.Classes
-  ( Eq1 (liftEq),
-    Ord1 (liftCompare),
-    Read1 (liftReadPrec),
-    Show1 (liftShowsPrec),
+  ( Eq1,
+    Ord1,
+    Read1,
+    Show1,
+    liftCompare,
+    liftEq,
+    liftReadPrec,
+    liftShowsPrec,
   )
 import "base" Data.Int (Int)
-import "base" Data.Ord (Ord (compare, (<=)), Ordering (EQ, GT, LT))
+import "base" Data.Ord (Ord, Ordering (EQ, GT, LT), compare, (<=))
 import "base" Data.Semigroup ((<>))
 import "base" Data.Traversable (Traversable)
 import qualified "base" Data.Tuple as Tuple
 import "base" GHC.Generics (Generic, Generic1)
-import "base" GHC.Read (Read (readPrec), expectP, parens, readListPrec)
+import "base" GHC.Read (Read, expectP, parens, readListPrec, readPrec)
 import "base" Text.ParserCombinators.ReadPrec (prec, step)
 import qualified "base" Text.Read.Lex as Lex
-import "base" Text.Show (Show (showsPrec), showList, showParen, showString)
+import "base" Text.Show (Show, showList, showParen, showString, showsPrec)
 import qualified "containers" Data.IntSet.Internal as IntSet
 import "yaya" Yaya.Fold
-  ( Projectable (project),
-    Recursive (cata),
-    Steppable (embed),
+  ( Projectable,
+    Recursive,
+    Steppable,
+    cata,
+    embed,
+    project,
   )
-import "base" Prelude (Num ((+)))
+import qualified "yaya-unsafe" Yaya.Unsafe.Fold as Unsafe
+import "base" Prelude ((+))
 #if MIN_VERSION_containers(0, 8, 0)
 import qualified "containers" Data.IntSet.Internal.IntTreeCommons as IntSet
   ( Prefix (Prefix),
   )
+#endif
 
-data IntSetF r
-  = NilF
-  | TipF Int IntSet.BitMap
-  | BinF IntSet.Prefix r r
+data IntSet r
+  = Nil
+  | Tip Int IntSet.BitMap
+#if MIN_VERSION_containers(0, 8, 0)
+  | Bin IntSet.Prefix r r
   deriving stock
     ( Eq,
       Generic,
@@ -59,10 +65,7 @@
       Traversable
     )
 #else
-data IntSetF r
-  = NilF
-  | TipF Int IntSet.BitMap
-  | BinF IntSet.Prefix IntSet.Mask r r
+  | Bin IntSet.Prefix IntSet.Mask r r
   deriving stock
     ( Eq,
       Generic,
@@ -73,87 +76,89 @@
     )
 #endif
 
-instance Projectable (->) IntSet.IntSet IntSetF where
-  project IntSet.Nil = NilF
-  project (IntSet.Tip prefix bm) = TipF prefix bm
+instance Projectable (->) IntSet.IntSet IntSet where
+  project = \case
+    IntSet.Nil -> Nil
+    IntSet.Tip prefix bm -> Tip prefix bm
 #if MIN_VERSION_containers(0, 8, 0)
-  project (IntSet.Bin prefix l r) = BinF prefix l r
+    IntSet.Bin prefix l r -> Bin prefix l r
 #else
-  project (IntSet.Bin prefix mask l r) = BinF prefix mask l r
+    IntSet.Bin prefix mask l r -> Bin prefix mask l r
 #endif
 
-instance Recursive (->) IntSet.IntSet IntSetF where
-  cata φ = φ . fmap (cata φ) . project
+instance Recursive (->) IntSet.IntSet IntSet where
+  cata = Unsafe.unsafeCata
 
-instance Steppable (->) IntSet.IntSet IntSetF where
-  embed NilF = IntSet.Nil
-  embed (TipF prefix bm) = IntSet.Tip prefix bm
+instance Steppable (->) IntSet.IntSet IntSet where
+  embed = \case
+    Nil -> IntSet.Nil
+    Tip prefix bm -> IntSet.Tip prefix bm
 #if MIN_VERSION_containers(0, 8, 0)
-  embed (BinF prefix l r) = IntSet.Bin prefix l r
+    Bin prefix l r -> IntSet.Bin prefix l r
 #else
-  embed (BinF prefix mask l r) = IntSet.Bin prefix mask l r
+    Bin prefix mask l r -> IntSet.Bin prefix mask l r
 #endif
 
-instance Eq1 IntSetF where
+instance Eq1 IntSet where
   liftEq f = Tuple.curry $ \case
-    (NilF, NilF) -> True
-    (NilF, _) -> False
-    (_, NilF) -> False
-    (TipF prefix bm, TipF prefix' bm') -> prefix == prefix' && bm == bm'
-    (TipF {}, _) -> False
-    (_, TipF {}) -> False
+    (Nil, Nil) -> True
+    (Nil, _) -> False
+    (_, Nil) -> False
+    (Tip prefix bm, Tip prefix' bm') -> prefix == prefix' && bm == bm'
+    (Tip {}, _) -> False
+    (_, Tip {}) -> False
 #if MIN_VERSION_containers(0, 8, 0)
-    (BinF prefix l r, BinF prefix' l' r') ->
+    (Bin prefix l r, Bin prefix' l' r') ->
       prefix == prefix' && f l l' && f r r'
 #else
-    (BinF prefix mask l r, BinF prefix' mask' l' r') ->
+    (Bin prefix mask l r, Bin prefix' mask' l' r') ->
       prefix == prefix' && mask == mask' && f l l' && f r r'
 #endif
 
-instance (Ord r) => Ord (IntSetF r) where
+instance (Ord r) => Ord (IntSet r) where
   compare = liftCompare compare
 
-instance Ord1 IntSetF where
+instance Ord1 IntSet where
   liftCompare f = Tuple.curry $ \case
-    (NilF, NilF) -> EQ
-    (NilF, _) -> LT
-    (TipF {}, NilF) -> GT
-    (TipF prefix bm, TipF prefix' bm') ->
+    (Nil, Nil) -> EQ
+    (Nil, _) -> LT
+    (Tip {}, Nil) -> GT
+    (Tip prefix bm, Tip prefix' bm') ->
       compare prefix prefix' <> compare bm bm'
-    (TipF {}, BinF {}) -> LT
-    (BinF {}, NilF) -> GT
-    (BinF {}, TipF {}) -> GT
+    (Tip {}, Bin {}) -> LT
+    (Bin {}, Nil) -> GT
+    (Bin {}, Tip {}) -> GT
 #if MIN_VERSION_containers(0, 8, 0)
-    (BinF (IntSet.Prefix prefix) l r, BinF (IntSet.Prefix prefix') l' r') ->
+    (Bin (IntSet.Prefix prefix) l r, Bin (IntSet.Prefix prefix') l' r') ->
       compare prefix prefix' <> f l l' <> f r r'
 #else
-    (BinF prefix mask l r, BinF prefix' mask' l' r') ->
+    (Bin prefix mask l r, Bin prefix' mask' l' r') ->
       compare prefix prefix' <> compare mask mask' <> f l l' <> f r r'
 #endif
 
 -- | @since 0.1.2.0
-instance (Read r) => Read (IntSetF r) where
+instance (Read r) => Read (IntSet r) where
   readPrec = liftReadPrec readPrec readListPrec
 
 -- | @since 0.1.2.0
-instance Read1 IntSetF where
+instance Read1 IntSet where
   liftReadPrec readPrecR _ =
     let appPrec = 10
      in parens . prec appPrec $
-          NilF
-            <$ expectP (Lex.Ident "NilF")
-            <|> expectP (Lex.Ident "TipF")
-              *> (TipF <$> step readPrec <*> step readPrec)
+          Nil
+            <$ expectP (Lex.Ident "Nil")
+            <|> expectP (Lex.Ident "Tip")
+              *> (Tip <$> step readPrec <*> step readPrec)
 #if MIN_VERSION_containers(0, 8, 0)
-            <|> expectP (Lex.Ident "BinF")
-              *> ( BinF . IntSet.Prefix
+            <|> expectP (Lex.Ident "Bin")
+              *> ( Bin . IntSet.Prefix
                      <$> step readPrec
                      <*> step readPrecR
                      <*> step readPrecR
                  )
 #else
-            <|> expectP (Lex.Ident "BinF")
-              *> ( BinF
+            <|> expectP (Lex.Ident "Bin")
+              *> ( Bin
                      <$> step readPrec
                      <*> step readPrec
                      <*> step readPrecR
@@ -161,34 +166,34 @@
                  )
 #endif
 
-instance (Show r) => Show (IntSetF r) where
+instance (Show r) => Show (IntSet r) where
   showsPrec = liftShowsPrec showsPrec showList
 
-instance Show1 IntSetF where
+instance Show1 IntSet where
   liftShowsPrec showsPrecR _ p =
     let appPrec = 10
         nextPrec = appPrec + 1
      in \case
-          NilF -> showString "NilF"
-          TipF prefix bm ->
+          Nil -> showString "Nil"
+          Tip prefix bm ->
             showParen (nextPrec <= p) $
-              showString "TipF "
+              showString "Tip "
                 . showsPrec nextPrec prefix
                 . showString " "
                 . showsPrec nextPrec bm
 #if MIN_VERSION_containers(0, 8, 0)
-          BinF (IntSet.Prefix prefix) l r ->
+          Bin (IntSet.Prefix prefix) l r ->
             showParen (nextPrec <= p) $
-              showString "BinF "
+              showString "Bin "
                 . showsPrec nextPrec prefix
                 . showString " "
                 . showsPrecR nextPrec l
                 . showString " "
                 . showsPrecR nextPrec r
 #else
-          BinF prefix mask l r ->
+          Bin prefix mask l r ->
             showParen (nextPrec <= p) $
-              showString "BinF "
+              showString "Bin "
                 . showsPrec nextPrec prefix
                 . showString " "
                 . showsPrec nextPrec mask
diff --git a/src/Yaya/Containers/Pattern/Map.hs b/src/Yaya/Containers/Pattern/Map.hs
--- a/src/Yaya/Containers/Pattern/Map.hs
+++ b/src/Yaya/Containers/Pattern/Map.hs
@@ -2,69 +2,81 @@
 {-# OPTIONS_GHC -Wno-orphans #-}
 
 module Yaya.Containers.Pattern.Map
-  ( MapF (BinF, TipF),
+  ( Map (Bin, Tip),
     -- | @since 0.1.2.0
-    eqMapF,
+    eqMap,
     -- | @since 0.1.2.0
-    compareMapF,
+    compareMap,
     -- | @since 0.1.2.0
-    readMapFPrec,
+    readMapPrec,
     -- | @since 0.1.2.0
-    showsMapFPrec,
+    showsMapPrec,
   )
 where
 
-import "base" Control.Applicative
-  ( Alternative ((<|>)),
-    Applicative ((<*>)),
-    (*>),
-  )
-import "base" Control.Category (Category ((.)))
+import "base" Control.Applicative ((*>), (<*>), (<|>))
+import "base" Control.Category ((.))
 import "base" Data.Bool (Bool (False, True), (&&))
-import "base" Data.Eq (Eq ((==)))
+import "base" Data.Eq (Eq, (==))
 import "base" Data.Foldable (Foldable)
 import "base" Data.Function (($))
-import "base" Data.Functor (Functor (fmap), (<$), (<$>))
+import "base" Data.Functor (Functor, (<$), (<$>))
 import "base" Data.Functor.Classes
-  ( Eq1 (liftEq),
-    Eq2 (liftEq2),
-    Ord1 (liftCompare),
-    Ord2 (liftCompare2),
-    Read1 (liftReadPrec),
-    Read2 (liftReadPrec2),
-    Show1 (liftShowsPrec),
-    Show2 (liftShowsPrec2),
+  ( Eq1,
+    Eq2,
+    Ord1,
+    Ord2,
+    Read1,
+    Read2,
+    Show1,
+    Show2,
+    liftCompare,
+    liftCompare2,
+    liftEq,
+    liftEq2,
+    liftReadPrec,
+    liftReadPrec2,
+    liftShowsPrec,
+    liftShowsPrec2,
   )
 import "base" Data.Int (Int)
-import "base" Data.Ord (Ord (compare, (<=)), Ordering (EQ, GT, LT))
+import "base" Data.Ord (Ord, Ordering (EQ, GT, LT), compare, (<=))
 import "base" Data.Semigroup ((<>))
 import "base" Data.Traversable (Traversable)
 import qualified "base" Data.Tuple as Tuple
 import "base" GHC.Generics (Generic, Generic1)
 import "base" GHC.Read (expectP)
 import "base" Text.Read
-  ( Read (readListPrec, readPrec),
+  ( Read,
     ReadPrec,
     parens,
     prec,
+    readListPrec,
+    readPrec,
     step,
   )
 import qualified "base" Text.Read.Lex as Lex
 import "base" Text.Show
-  ( Show (showList, showsPrec),
+  ( Show,
     ShowS,
+    showList,
     showParen,
     showString,
+    showsPrec,
   )
 import qualified "containers" Data.Map.Internal as Map
 import "yaya" Yaya.Fold
-  ( Projectable (project),
-    Recursive (cata),
-    Steppable (embed),
+  ( Projectable,
+    Recursive,
+    Steppable,
+    cata,
+    embed,
+    project,
   )
-import "base" Prelude (Num ((+)))
+import qualified "yaya-unsafe" Yaya.Unsafe.Fold as Unsafe
+import "base" Prelude ((+))
 
-data MapF k v r = TipF | BinF Map.Size k ~v r r
+data Map k v r = Tip | Bin Map.Size k ~v r r
   deriving stock
     ( Eq,
       Ord,
@@ -78,56 +90,56 @@
       Traversable
     )
 
-instance Projectable (->) (Map.Map k v) (MapF k v) where
-  project Map.Tip = TipF
-  project (Map.Bin size k v l r) = BinF size k v l r
+instance Projectable (->) (Map.Map k v) (Map k v) where
+  project Map.Tip = Tip
+  project (Map.Bin size k v l r) = Bin size k v l r
 
-instance Recursive (->) (Map.Map k v) (MapF k v) where
-  cata φ = φ . fmap (cata φ) . project
+instance Recursive (->) (Map.Map k v) (Map k v) where
+  cata = Unsafe.unsafeCata
 
-instance Steppable (->) (Map.Map k v) (MapF k v) where
-  embed TipF = Map.Tip
-  embed (BinF size k v l r) = Map.Bin size k v l r
+instance Steppable (->) (Map.Map k v) (Map k v) where
+  embed Tip = Map.Tip
+  embed (Bin size k v l r) = Map.Bin size k v l r
 
-eqMapF ::
+eqMap ::
   (k -> k' -> Bool) ->
   (v -> v' -> Bool) ->
   (r -> r' -> Bool) ->
-  MapF k v r ->
-  MapF k' v' r' ->
+  Map k v r ->
+  Map k' v' r' ->
   Bool
-eqMapF eqK eqV eqR = Tuple.curry $ \case
-  (TipF, TipF) -> True
-  (BinF size k v l r, BinF size' k' v' l' r') ->
+eqMap eqK eqV eqR = Tuple.curry $ \case
+  (Tip, Tip) -> True
+  (Bin size k v l r, Bin size' k' v' l' r') ->
     size == size' && eqK k k' && eqV v v' && eqR l l' && eqR r r'
   (_, _) -> False
 
-compareMapF ::
+compareMap ::
   (k -> k' -> Ordering) ->
   (v -> v' -> Ordering) ->
   (r -> r' -> Ordering) ->
-  MapF k v r ->
-  MapF k' v' r' ->
+  Map k v r ->
+  Map k' v' r' ->
   Ordering
-compareMapF compareK compareV compareR = Tuple.curry $ \case
-  (TipF, TipF) -> EQ
-  (TipF, BinF {}) -> LT
-  (BinF {}, TipF) -> GT
-  (BinF size k v l r, BinF size' k' v' l' r') ->
+compareMap compareK compareV compareR = Tuple.curry $ \case
+  (Tip, Tip) -> EQ
+  (Tip, Bin {}) -> LT
+  (Bin {}, Tip) -> GT
+  (Bin size k v l r, Bin size' k' v' l' r') ->
     compare size size'
       <> compareK k k'
       <> compareV v v'
       <> compareR l l'
       <> compareR r r'
 
-readMapFPrec :: ReadPrec k -> ReadPrec v -> ReadPrec r -> ReadPrec (MapF k v r)
-readMapFPrec readPrecK readPrecV readPrecR =
+readMapPrec :: ReadPrec k -> ReadPrec v -> ReadPrec r -> ReadPrec (Map k v r)
+readMapPrec readPrecK readPrecV readPrecR =
   let appPrec = 10
    in parens . prec appPrec $
-        TipF
-          <$ expectP (Lex.Ident "TipF")
-          <|> expectP (Lex.Ident "BinF")
-            *> ( BinF
+        Tip
+          <$ expectP (Lex.Ident "Tip")
+          <|> expectP (Lex.Ident "Bin")
+            *> ( Bin
                    <$> step readPrec
                    <*> step readPrecK
                    <*> step readPrecV
@@ -135,21 +147,21 @@
                    <*> step readPrecR
                )
 
-showsMapFPrec ::
+showsMapPrec ::
   (Int -> k -> ShowS) ->
   (Int -> v -> ShowS) ->
   (Int -> r -> ShowS) ->
   Int ->
-  MapF k v r ->
+  Map k v r ->
   ShowS
-showsMapFPrec showsPrecK showsPrecV showsPrecR p =
+showsMapPrec showsPrecK showsPrecV showsPrecR p =
   let appPrec = 10
       nextPrec = appPrec + 1
    in \case
-        TipF -> showString "TipF"
-        BinF size k v l r ->
+        Tip -> showString "Tip"
+        Bin size k v l r ->
           showParen (nextPrec <= p) $
-            showString "BinF "
+            showString "Bin "
               . showsPrec nextPrec size
               . showString " "
               . showsPrecK nextPrec k
@@ -160,30 +172,30 @@
               . showString " "
               . showsPrecR nextPrec r
 
-instance (Eq k, Eq v) => Eq1 (MapF k v) where
+instance (Eq k, Eq v) => Eq1 (Map k v) where
   liftEq = liftEq2 (==)
 
-instance (Eq k) => Eq2 (MapF k) where
-  liftEq2 = eqMapF (==)
+instance (Eq k) => Eq2 (Map k) where
+  liftEq2 = eqMap (==)
 
-instance (Ord k, Ord v) => Ord1 (MapF k v) where
+instance (Ord k, Ord v) => Ord1 (Map k v) where
   liftCompare = liftCompare2 compare
 
-instance (Ord k) => Ord2 (MapF k) where
-  liftCompare2 = compareMapF compare
+instance (Ord k) => Ord2 (Map k) where
+  liftCompare2 = compareMap compare
 
 -- | @since 0.1.2.0
-instance (Read k, Read v) => Read1 (MapF k v) where
+instance (Read k, Read v) => Read1 (Map k v) where
   liftReadPrec = liftReadPrec2 readPrec readListPrec
 
 -- | @since 0.1.2.0
-instance (Read k) => Read2 (MapF k) where
+instance (Read k) => Read2 (Map k) where
   liftReadPrec2 readPrecV _ readPrecR _ =
-    readMapFPrec readPrec readPrecV readPrecR
+    readMapPrec readPrec readPrecV readPrecR
 
-instance (Show k, Show v) => Show1 (MapF k v) where
+instance (Show k, Show v) => Show1 (Map k v) where
   liftShowsPrec = liftShowsPrec2 showsPrec showList
 
-instance (Show k) => Show2 (MapF k) where
+instance (Show k) => Show2 (Map k) where
   liftShowsPrec2 showsPrecV _ showsPrecR _ =
-    showsMapFPrec showsPrec showsPrecV showsPrecR
+    showsMapPrec showsPrec showsPrecV showsPrecR
diff --git a/src/Yaya/Containers/Pattern/Set.hs b/src/Yaya/Containers/Pattern/Set.hs
--- a/src/Yaya/Containers/Pattern/Set.hs
+++ b/src/Yaya/Containers/Pattern/Set.hs
@@ -2,49 +2,57 @@
 {-# OPTIONS_GHC -Wno-orphans #-}
 
 module Yaya.Containers.Pattern.Set
-  ( SetF (BinF, TipF),
+  ( Set (Bin, Tip),
   )
 where
 
-import "base" Control.Applicative
-  ( Alternative ((<|>)),
-    Applicative ((<*>)),
-    (*>),
-  )
-import "base" Control.Category (Category ((.)))
+import "base" Control.Applicative ((*>), (<*>), (<|>))
+import "base" Control.Category ((.))
 import "base" Data.Bool (Bool (False, True), (&&))
-import "base" Data.Eq (Eq ((==)))
+import "base" Data.Eq (Eq, (==))
 import "base" Data.Foldable (Foldable)
 import "base" Data.Function (($))
-import "base" Data.Functor (Functor (fmap), (<$), (<$>))
+import "base" Data.Functor (Functor, (<$), (<$>))
 import "base" Data.Functor.Classes
-  ( Eq1 (liftEq),
-    Eq2 (liftEq2),
-    Ord1 (liftCompare),
-    Ord2 (liftCompare2),
-    Read1 (liftReadPrec),
-    Read2 (liftReadPrec2),
-    Show1 (liftShowsPrec),
-    Show2 (liftShowsPrec2),
+  ( Eq1,
+    Eq2,
+    Ord1,
+    Ord2,
+    Read1,
+    Read2,
+    Show1,
+    Show2,
+    liftCompare,
+    liftCompare2,
+    liftEq,
+    liftEq2,
+    liftReadPrec,
+    liftReadPrec2,
+    liftShowsPrec,
+    liftShowsPrec2,
   )
-import "base" Data.Ord (Ord (compare, (<=)), Ordering (EQ, GT, LT))
+import "base" Data.Ord (Ord, Ordering (EQ, GT, LT), compare, (<=))
 import "base" Data.Semigroup ((<>))
 import "base" Data.Traversable (Traversable)
 import qualified "base" Data.Tuple as Tuple
 import "base" GHC.Generics (Generic, Generic1)
-import "base" GHC.Read (Read (readListPrec, readPrec), expectP, parens)
+import "base" GHC.Read (Read, expectP, parens, readListPrec, readPrec)
 import "base" Text.ParserCombinators.ReadPrec (prec, step)
 import qualified "base" Text.Read.Lex as Lex
-import "base" Text.Show (Show (showList, showsPrec), showParen, showString)
+import "base" Text.Show (Show, showList, showParen, showString, showsPrec)
 import qualified "containers" Data.Set.Internal as Set
 import "yaya" Yaya.Fold
-  ( Projectable (project),
-    Recursive (cata),
-    Steppable (embed),
+  ( Projectable,
+    Recursive,
+    Steppable,
+    cata,
+    embed,
+    project,
   )
-import "base" Prelude (Num ((+)))
+import qualified "yaya-unsafe" Yaya.Unsafe.Fold as Unsafe
+import "base" Prelude ((+))
 
-data SetF a r = TipF | BinF Set.Size a r r
+data Set a r = Tip | Bin Set.Size a r r
   deriving stock
     ( Eq,
       Ord,
@@ -58,69 +66,69 @@
       Traversable
     )
 
-instance Projectable (->) (Set.Set a) (SetF a) where
-  project Set.Tip = TipF
-  project (Set.Bin size a l r) = BinF size a l r
+instance Projectable (->) (Set.Set a) (Set a) where
+  project Set.Tip = Tip
+  project (Set.Bin size a l r) = Bin size a l r
 
-instance Recursive (->) (Set.Set a) (SetF a) where
-  cata φ = φ . fmap (cata φ) . project
+instance Recursive (->) (Set.Set a) (Set a) where
+  cata = Unsafe.unsafeCata
 
-instance Steppable (->) (Set.Set a) (SetF a) where
-  embed TipF = Set.Tip
-  embed (BinF size a l r) = Set.Bin size a l r
+instance Steppable (->) (Set.Set a) (Set a) where
+  embed Tip = Set.Tip
+  embed (Bin size a l r) = Set.Bin size a l r
 
-instance (Eq a) => Eq1 (SetF a) where
+instance (Eq a) => Eq1 (Set a) where
   liftEq = liftEq2 (==)
 
-instance Eq2 SetF where
+instance Eq2 Set where
   liftEq2 f g = Tuple.curry $ \case
-    (TipF, TipF) -> True
-    (BinF size a l r, BinF size' a' l' r') ->
+    (Tip, Tip) -> True
+    (Bin size a l r, Bin size' a' l' r') ->
       size == size' && f a a' && g l l' && g r r'
     (_, _) -> False
 
-instance (Ord a) => Ord1 (SetF a) where
+instance (Ord a) => Ord1 (Set a) where
   liftCompare = liftCompare2 compare
 
-instance Ord2 SetF where
+instance Ord2 Set where
   liftCompare2 f g = Tuple.curry $ \case
-    (TipF, TipF) -> EQ
-    (TipF, BinF {}) -> LT
-    (BinF {}, TipF) -> GT
-    (BinF size a l r, BinF size' a' l' r') ->
+    (Tip, Tip) -> EQ
+    (Tip, Bin {}) -> LT
+    (Bin {}, Tip) -> GT
+    (Bin size a l r, Bin size' a' l' r') ->
       compare size size' <> f a a' <> g l l' <> g r r'
 
 -- | @since 0.1.2.0
-instance (Read a) => Read1 (SetF a) where
+instance (Read a) => Read1 (Set a) where
   liftReadPrec = liftReadPrec2 readPrec readListPrec
 
 -- | @since 0.1.2.0
-instance Read2 SetF where
+instance Read2 Set where
   liftReadPrec2 readPrecA _ readPrecR _ =
     let appPrec = 10
      in parens . prec appPrec $
-          TipF
-            <$ expectP (Lex.Ident "TipF")
-            <|> expectP (Lex.Ident "BinF")
-              *> ( BinF
+          Tip
+            <$ expectP (Lex.Ident "Tip")
+            <|> expectP (Lex.Ident "Bin")
+              *> ( Bin
                      <$> step readPrec
                      <*> step readPrecA
                      <*> step readPrecR
                      <*> step readPrecR
                  )
 
-instance (Show a) => Show1 (SetF a) where
+instance (Show a) => Show1 (Set a) where
   liftShowsPrec = liftShowsPrec2 showsPrec showList
 
-instance Show2 SetF where
+instance Show2 Set where
   liftShowsPrec2 showsPrecA _ showsPrecR _ p =
     let appPrec = 10
         nextPrec = appPrec + 1
      in \case
-          TipF -> showString "TipF"
-          BinF size a l r ->
+          Tip -> showString "Tip"
+          Bin size a l r ->
             showParen (nextPrec <= p) $
-              showString "BinF "
+              showString "Bin "
                 . showsPrec nextPrec size
                 . showString " "
                 . showsPrecA nextPrec a
diff --git a/yaya-containers.cabal b/yaya-containers.cabal
--- a/yaya-containers.cabal
+++ b/yaya-containers.cabal
@@ -3,7 +3,7 @@
 --   exception.
 
 name: yaya-containers
-version: 0.2.0.0
+version: 1.0.0.0
 synopsis: Pattern functors and instances for types in the containers package.
 maintainer: Greg Pfeil <greg@technomadic.org>
 author: Greg Pfeil <greg@technomadic.org>
@@ -47,7 +47,7 @@
   location: https://github.com/sellout/yaya.git
   subdir: containers
   -- NB: This is the repo version, which is distinct from the package version.
-  tag: v4.0.0
+  tag: v5.0.0
 
 custom-setup
   setup-depends:
@@ -141,8 +141,6 @@
     base ^>= {4.13.0, 4.14.0, 4.15.0, 4.16.0, 4.17.0, 4.18.0, 4.19.0, 4.20.0, 4.21.0, 4.22.0},
   ghc-options:
     -Weverything
-    -- This one just reports unfixable things, AFAICT.
-    -Wno-all-missed-specialisations
     -- Type inference good.
     -Wno-missing-local-signatures
     -- Warns even when `Unsafe` is explicit, not inferred. See
@@ -169,6 +167,12 @@
       -Wno-missing-poly-kind-signatures
       -- Inference good.
       -Wno-missing-role-annotations
+  -- remove if the oldest supported version is GHC 9.14.1+
+  if impl(ghc >= 9.14.1)
+    ghc-options:
+      -- See
+      -- https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0581-namespace-specified-imports.rst#deprecate-use-of-pattern-in-import-export-lists
+      -Wno-pattern-namespace-specifier
   default-extensions:
     BlockArguments
     DefaultSignatures
@@ -206,7 +210,8 @@
     src
   build-depends:
     containers ^>= {0.6.2, 0.7, 0.8},
-    yaya ^>= {0.5.1, 0.6.0, 0.7.0},
+    yaya ^>= {0.5.1, 0.6.0, 0.7.0, 1.0.0},
+    yaya-unsafe ^>= {0.5.0, 1.0.0},
   exposed-modules:
     Yaya.Containers.Pattern.IntMap
     Yaya.Containers.Pattern.IntSet