diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
new file mode 100644
--- /dev/null
+++ b/CHANGELOG.markdown
@@ -0,0 +1,4 @@
+# Change log
+
+Flow follows the [Package Versioning Policy](https://pvp.haskell.org).
+You can find release notes [on GitHub](https://github.com/tfausak/flow/releases).
diff --git a/LICENSE.markdown b/LICENSE.markdown
--- a/LICENSE.markdown
+++ b/LICENSE.markdown
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Taylor Fausak
+Copyright (c) 2022 Taylor Fausak
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/README.markdown b/README.markdown
--- a/README.markdown
+++ b/README.markdown
@@ -19,14 +19,14 @@
 
 Flow requires a Haskell compiler. It is tested with recent versions of GHC, but
 older or different compilers should be acceptable. For installation with Cabal,
-Flow requires at least Cabal 1.8.
+Flow requires at least Cabal 2.2.
 
 ## Installation
 
 To add Flow as a dependency to your package, add it to your Cabal file.
 
 ```
-build-depends: flow ==1.0.*
+build-depends: flow ==2.0.*
 ```
 
 ## Usage
diff --git a/flow.cabal b/flow.cabal
--- a/flow.cabal
+++ b/flow.cabal
@@ -1,14 +1,14 @@
-cabal-version: >= 1.10
+cabal-version: 2.2
 
 name: flow
-version: 1.0.23
+version: 2.0.0.0
 
 synopsis: Write more understandable Haskell.
 description: Flow provides operators for writing more understandable Haskell.
 
 build-type: Simple
 category: Combinators, Functions, Utility
-extra-source-files: README.markdown
+extra-source-files: CHANGELOG.markdown README.markdown
 license-file: LICENSE.markdown
 license: MIT
 maintainer: Taylor Fausak
@@ -17,27 +17,50 @@
   location: https://github.com/tfausak/flow
   type: git
 
-library
+flag pedantic
+  default: False
+  description: Enables @-Werror@, which turns warnings into errors.
+  manual: True
+
+common library
   build-depends:
-    base >= 4.13.0 && < 4.17
+    , base >= 4.13.0 && < 4.17
   default-language: Haskell2010
-  exposed-modules: Flow
   ghc-options:
     -Weverything
+    -Wno-all-missed-specialisations
+    -Wno-implicit-prelude
     -Wno-missing-exported-signatures
     -Wno-safe
-  hs-source-dirs: src/lib
 
+  if flag(pedantic)
+    ghc-options: -Werror
+
   if impl(ghc >= 8.10)
     ghc-options:
       -Wno-missing-safe-haskell-mode
+      -Wno-prepositive-qualified-module
 
+common executable
+  import: library
+
+  build-depends: flow
+  ghc-options:
+    -rtsopts
+    -threaded
+    -Wno-unused-packages
+
+library
+  import: library
+
+  exposed-modules: Flow
+  hs-source-dirs: source/library
+
 test-suite test
+  import: executable
+
   build-depends:
-    base -any
-    , flow -any
     , HUnit >= 1.6.1 && < 1.7
-  default-language: Haskell2010
-  hs-source-dirs: src/test
+  hs-source-dirs: source/test-suite
   main-is: Main.hs
   type: exitcode-stdio-1.0
diff --git a/source/library/Flow.hs b/source/library/Flow.hs
new file mode 100644
--- /dev/null
+++ b/source/library/Flow.hs
@@ -0,0 +1,247 @@
+-- | Flow provides operators for writing more understandable Haskell. It is an
+-- alternative to some common idioms like ('Prelude.$') for function
+-- application and ('Prelude..') for function composition.
+--
+-- Flow is designed to be imported unqualified. It does not export anything
+-- that conflicts with the base package.
+--
+-- >>> import Flow
+--
+-- == Rationale
+--
+-- I think that Haskell can be hard to read. It has two operators for applying
+-- functions. Both are not really necessary and only serve to reduce
+-- parentheses. But they make code hard to read. People who do not already
+-- know Haskell have no chance of guessing what @foo $ bar@ or @baz & qux@
+-- mean.
+--
+-- Those that do know Haskell are forced to read lines forwards and backwards
+-- at the same time, thanks to function composition. Even something simple,
+-- like finding the minimum element, bounces around: @f = head . sort@.
+--
+-- I think we can do better. By using directional operators, we can allow
+-- readers to move their eye in only one direction, be that left-to-right or
+-- right-to-left. And by using idioms common in other programming languages,
+-- we can allow people who aren't familiar with Haskell to guess at the
+-- meaning.
+--
+-- So instead of ('Prelude.$'), I propose ('<|'). It is a pipe, which anyone
+-- who has touched a Unix system should be familiar with. And it points in the
+-- direction it sends arguments along. Similarly, replace ('Prelude.&') with
+-- ('|>'). And for composition, ('<.') replaces ('Prelude..'). I would have
+-- preferred @<<@, but its counterpart @>>@ is taken by Haskell's syntax.
+-- So-called "backwards" composition is normally expressed with
+-- ('Control.Category.>>>'), which Flow provides as ('.>').
+module Flow (
+    -- * Function application
+    (|>), (<|), apply,
+    -- * Function composition
+    (.>), (<.), compose,
+    -- * Strict function application
+    (!>), (<!), apply',
+) where
+
+import Prelude (seq)
+
+-- | Left-associative 'apply' operator. Read as "apply forward" or "pipe into".
+-- Use this to create long chains of computation that suggest which direction
+-- things move in.
+--
+-- >>> 3 |> succ |> recip |> negate
+-- -0.25
+--
+-- Or use it anywhere you would use ('Prelude.&').
+--
+-- prop> \ x -> (x |> f) == f x
+--
+-- prop> \ x -> (x |> f |> g) == g (f x)
+infixl 0 |>
+(|>) :: a -> (a -> b) -> b
+x |> f = apply x f
+
+-- | Right-associative 'apply' operator. Read as "apply backward" or "pipe
+-- from". Use this to create long chains of computation that suggest which
+-- direction things move in. You may prefer this operator over ('|>') for
+-- 'Prelude.IO' actions since it puts the last function first.
+--
+-- >>> print <| negate <| recip <| succ <| 3
+-- -0.25
+--
+-- Or use it anywhere you would use ('Prelude.$').
+--
+-- Note that ('<|') and ('|>') have the same precedence, so they cannot be used
+-- together.
+--
+-- >>> -- This doesn't work!
+-- >>> -- print <| 3 |> succ |> recip |> negate
+--
+-- prop> \ x -> (f <| x) == f x
+--
+-- prop> \ x -> (g <| f <| x) == g (f x)
+infixr 0 <|
+(<|) :: (a -> b) -> a -> b
+f <| x = apply x f
+
+-- | Function application. This function usually isn't necessary, but it can be
+-- more readable than some alternatives when used with higher-order functions
+-- like 'Prelude.map'.
+--
+-- >>> map (apply 2) [succ, recip, negate]
+-- [3.0,0.5,-2.0]
+--
+-- In general you should prefer using an explicit lambda or operator section.
+--
+-- >>> map (\ f -> 2 |> f) [succ, recip, negate]
+-- [3.0,0.5,-2.0]
+-- >>> map (2 |>) [succ, recip, negate]
+-- [3.0,0.5,-2.0]
+-- >>> map (<| 2) [succ, recip, negate]
+-- [3.0,0.5,-2.0]
+--
+-- prop> \ x -> apply x f == f x
+apply :: a -> (a -> b) -> b
+apply x f = f x
+
+-- | Left-associative 'compose' operator. Read as "compose forward" or "and
+-- then". Use this to create long chains of computation that suggest which
+-- direction things move in.
+--
+-- >>> let f = succ .> recip .> negate
+-- >>> f 3
+-- -0.25
+--
+-- Or use it anywhere you would use ('Control.Category.>>>').
+--
+-- prop> \ x -> (f .> g) x == g (f x)
+--
+-- prop> \ x -> (f .> g .> h) x == h (g (f x))
+infixl 9 .>
+(.>) :: (a -> b) -> (b -> c) -> (a -> c)
+f .> g = compose f g
+
+-- | Right-associative 'compose' operator. Read as "compose backward" or "but
+-- first". Use this to create long chains of computation that suggest which
+-- direction things move in. You may prefer this operator over ('.>') for
+-- 'Prelude.IO' actions since it puts the last function first.
+--
+-- >>> let f = print <. negate <. recip <. succ
+-- >>> f 3
+-- -0.25
+--
+-- Or use it anywhere you would use ('Prelude..').
+--
+-- Note that ('<.') and ('.>') have the same precedence, so they cannot be used
+-- together.
+--
+-- >>> -- This doesn't work!
+-- >>> -- print <. succ .> recip .> negate
+--
+-- prop> \ x -> (g <. f) x == g (f x)
+--
+-- prop> \ x -> (h <. g <. f) x == h (g (f x))
+infixr 9 <.
+(<.) :: (b -> c) -> (a -> b) -> (a -> c)
+g <. f = compose f g
+
+-- | Function composition. This function usually isn't necessary, but it can be
+-- more readable than some alternatives when used with higher-order functions
+-- like 'Prelude.map'.
+--
+-- >>> let fs = map (compose succ) [recip, negate]
+-- >>> map (apply 3) fs
+-- [0.25,-4.0]
+--
+-- In general you should prefer using an explicit lambda or operator section.
+--
+-- >>> map (\ f -> f 3) (map (\ f -> succ .> f) [recip, negate])
+-- [0.25,-4.0]
+-- >>> map (\ f -> f 3) (map (succ .>) [recip, negate])
+-- [0.25,-4.0]
+-- >>> map (\ f -> f 3) (map (<. succ) [recip, negate])
+-- [0.25,-4.0]
+--
+-- prop> \ x -> compose f g x == g (f x)
+compose :: (a -> b) -> (b -> c) -> (a -> c)
+compose f g x = g (f x)
+
+-- | Left-associative 'apply'' operator. Read as "strict apply forward" or
+-- "strict pipe into". Use this to create long chains of computation that
+-- suggest which direction things move in.
+--
+-- >>> 3 !> succ !> recip !> negate
+-- -0.25
+--
+-- The difference between this and ('|>') is that this evaluates its argument
+-- before passing it to the function.
+--
+-- >>> undefined |> const True
+-- True
+-- >>> undefined !> const True
+-- *** Exception: Prelude.undefined
+-- ...
+--
+-- prop> \ x -> (x !> f) == seq x (f x)
+--
+-- prop> \ x -> (x !> f !> g) == let y = seq x (f x) in seq y (g y)
+infixl 0 !>
+(!>) :: a -> (a -> b) -> b
+x !> f = apply' x f
+
+-- | Right-associative 'apply'' operator. Read as "strict apply backward" or
+-- "strict pipe from". Use this to create long chains of computation that
+-- suggest which direction things move in. You may prefer this operator over
+-- ('!>') for 'Prelude.IO' actions since it puts the last function first.
+--
+-- >>> print <! negate <! recip <! succ <! 3
+-- -0.25
+--
+-- The difference between this and ('<|') is that this evaluates its argument
+-- before passing it to the function.
+--
+-- >>> const True <| undefined
+-- True
+-- >>> const True <! undefined
+-- *** Exception: Prelude.undefined
+-- ...
+--
+-- Note that ('<!') and ('!>') have the same precedence, so they cannot be used
+-- together.
+--
+-- >>> -- This doesn't work!
+-- >>> -- print <! 3 !> succ !> recip !> negate
+--
+-- prop> \ x -> (f <! x) == seq x (f x)
+--
+-- prop> \ x -> (g <! f <! x) == let y = seq x (f x) in seq y (g y)
+infixr 0 <!
+(<!) :: (a -> b) -> a -> b
+f <! x = apply' x f
+
+-- | Strict function application. This function usually isn't necessary, but it
+-- can be more readable than some alternatives when used with higher-order
+-- functions like 'Prelude.map'.
+--
+-- >>> map (apply' 2) [succ, recip, negate]
+-- [3.0,0.5,-2.0]
+--
+-- The different between this and 'apply' is that this evaluates its argument
+-- before passing it to the function.
+--
+-- >>> apply undefined (const True)
+-- True
+-- >>> apply' undefined (const True)
+-- *** Exception: Prelude.undefined
+-- ...
+--
+-- In general you should prefer using an explicit lambda or operator section.
+--
+-- >>> map (\ f -> 2 !> f) [succ, recip, negate]
+-- [3.0,0.5,-2.0]
+-- >>> map (2 !>) [succ, recip, negate]
+-- [3.0,0.5,-2.0]
+-- >>> map (<! 2) [succ, recip, negate]
+-- [3.0,0.5,-2.0]
+--
+-- prop> \ x -> apply' x f == seq x (f x)
+apply' :: a -> (a -> b) -> b
+apply' x f = seq x (apply x f)
diff --git a/source/test-suite/Main.hs b/source/test-suite/Main.hs
new file mode 100644
--- /dev/null
+++ b/source/test-suite/Main.hs
@@ -0,0 +1,41 @@
+import qualified Control.Monad as Monad
+import qualified Flow
+import qualified System.Exit as Exit
+import qualified Test.HUnit as Test
+
+main :: IO ()
+main = do
+  counts <- Test.runTestTT $ Test.TestList
+    [ True Test.~?= True
+    , (3 Flow.|> succ Flow.|> recip Flow.|> negate) Test.~?= (-0.25 :: Double)
+    , (negate Flow.<| recip Flow.<| succ Flow.<| 3) Test.~?= (-0.25 :: Double)
+    , fmap (Flow.apply 2) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
+    , fmap (2 Flow.|>) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
+    , fmap (2 Flow.|>) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
+    , fmap (Flow.<| 2) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
+    , fmap (Flow.apply 3 . Flow.compose succ) [recip, negate]
+      Test.~?= [0.25, -4 :: Double]
+    , (succ Flow..> recip Flow..> negate) 3 Test.~?= (-0.25 :: Double)
+    , (negate Flow.<. recip Flow.<. succ) 3 Test.~?= (-0.25 :: Double)
+    , fmap ((\f -> f 3) . (succ Flow..>)) [recip, negate]
+      Test.~?= [0.25, -4 :: Double]
+    , fmap ((\f -> f 3) . (succ Flow..>)) [recip, negate]
+      Test.~?= [0.25, -4 :: Double]
+    , fmap ((\f -> f 3) . (Flow.<. succ)) [recip, negate]
+      Test.~?= [0.25, -4 :: Double]
+    , (3 Flow.!> succ Flow.!> recip Flow.!> negate) Test.~?= (-0.25 :: Double)
+    , (undefined Flow.|> const True) Test.~?= True
+    , (negate Flow.<! recip Flow.<! succ Flow.<! 3) Test.~?= (-0.25 :: Double)
+    , (const True Flow.<| undefined) Test.~?= True
+    , fmap (Flow.apply' 2) [succ, recip, negate]
+      Test.~?= [3, 0.5, -2 :: Double]
+    , Flow.apply undefined (const True) Test.~?= True
+    , fmap (2 Flow.!>) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
+    , fmap (2 Flow.!>) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
+    , fmap (Flow.<! 2) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
+    ]
+
+  let
+    hasErrors = Test.errors counts /= 0
+    hasFailures = Test.failures counts /= 0
+  Monad.when (hasErrors || hasFailures) Exit.exitFailure
diff --git a/src/lib/Flow.hs b/src/lib/Flow.hs
deleted file mode 100644
--- a/src/lib/Flow.hs
+++ /dev/null
@@ -1,247 +0,0 @@
--- | Flow provides operators for writing more understandable Haskell. It is an
--- alternative to some common idioms like ('Prelude.$') for function
--- application and ('Prelude..') for function composition.
---
--- Flow is designed to be imported unqualified. It does not export anything
--- that conflicts with the base package.
---
--- >>> import Flow
---
--- == Rationale
---
--- I think that Haskell can be hard to read. It has two operators for applying
--- functions. Both are not really necessary and only serve to reduce
--- parentheses. But they make code hard to read. People who do not already
--- know Haskell have no chance of guessing what @foo $ bar@ or @baz & qux@
--- mean.
---
--- Those that do know Haskell are forced to read lines forwards and backwards
--- at the same time, thanks to function composition. Even something simple,
--- like finding the minimum element, bounces around: @f = head . sort@.
---
--- I think we can do better. By using directional operators, we can allow
--- readers to move their eye in only one direction, be that left-to-right or
--- right-to-left. And by using idioms common in other programming languages,
--- we can allow people who aren't familiar with Haskell to guess at the
--- meaning.
---
--- So instead of ('Prelude.$'), I propose ('<|'). It is a pipe, which anyone
--- who has touched a Unix system should be familiar with. And it points in the
--- direction it sends arguments along. Similarly, replace ('Prelude.&') with
--- ('|>'). And for composition, ('<.') replaces ('Prelude..'). I would have
--- preferred @<<@, but its counterpart @>>@ is taken by Haskell's syntax.
--- So-called "backwards" composition is normally expressed with
--- ('Control.Category.>>>'), which Flow provides as ('.>').
-module Flow (
-    -- * Function application
-    (|>), (<|), apply,
-    -- * Function composition
-    (.>), (<.), compose,
-    -- * Strict function application
-    (!>), (<!), apply',
-) where
-
-import Prelude (seq)
-
--- | Left-associative 'apply' operator. Read as "apply forward" or "pipe into".
--- Use this to create long chains of computation that suggest which direction
--- things move in.
---
--- >>> 3 |> succ |> recip |> negate
--- -0.25
---
--- Or use it anywhere you would use ('Prelude.&').
---
--- prop> \ x -> (x |> f) == f x
---
--- prop> \ x -> (x |> f |> g) == g (f x)
-infixl 0 |>
-(|>) :: a -> (a -> b) -> b
-x |> f = apply x f
-
--- | Right-associative 'apply' operator. Read as "apply backward" or "pipe
--- from". Use this to create long chains of computation that suggest which
--- direction things move in. You may prefer this operator over ('|>') for
--- 'Prelude.IO' actions since it puts the last function first.
---
--- >>> print <| negate <| recip <| succ <| 3
--- -0.25
---
--- Or use it anywhere you would use ('Prelude.$').
---
--- Note that ('<|') and ('|>') have the same precedence, so they cannot be used
--- together.
---
--- >>> -- This doesn't work!
--- >>> -- print <| 3 |> succ |> recip |> negate
---
--- prop> \ x -> (f <| x) == f x
---
--- prop> \ x -> (g <| f <| x) == g (f x)
-infixr 0 <|
-(<|) :: (a -> b) -> a -> b
-f <| x = apply x f
-
--- | Function application. This function usually isn't necessary, but it can be
--- more readable than some alternatives when used with higher-order functions
--- like 'Prelude.map'.
---
--- >>> map (apply 2) [succ, recip, negate]
--- [3.0,0.5,-2.0]
---
--- In general you should prefer using an explicit lambda or operator section.
---
--- >>> map (\ f -> 2 |> f) [succ, recip, negate]
--- [3.0,0.5,-2.0]
--- >>> map (2 |>) [succ, recip, negate]
--- [3.0,0.5,-2.0]
--- >>> map (<| 2) [succ, recip, negate]
--- [3.0,0.5,-2.0]
---
--- prop> \ x -> apply x f == f x
-apply :: a -> (a -> b) -> b
-apply x f = f x
-
--- | Left-associative 'compose' operator. Read as "compose forward" or "and
--- then". Use this to create long chains of computation that suggest which
--- direction things move in.
---
--- >>> let f = succ .> recip .> negate
--- >>> f 3
--- -0.25
---
--- Or use it anywhere you would use ('Control.Category.>>>').
---
--- prop> \ x -> (f .> g) x == g (f x)
---
--- prop> \ x -> (f .> g .> h) x == h (g (f x))
-infixl 9 .>
-(.>) :: (a -> b) -> (b -> c) -> (a -> c)
-f .> g = compose f g
-
--- | Right-associative 'compose' operator. Read as "compose backward" or "but
--- first". Use this to create long chains of computation that suggest which
--- direction things move in. You may prefer this operator over ('.>') for
--- 'Prelude.IO' actions since it puts the last function first.
---
--- >>> let f = print <. negate <. recip <. succ
--- >>> f 3
--- -0.25
---
--- Or use it anywhere you would use ('Prelude..').
---
--- Note that ('<.') and ('.>') have the same precedence, so they cannot be used
--- together.
---
--- >>> -- This doesn't work!
--- >>> -- print <. succ .> recip .> negate
---
--- prop> \ x -> (g <. f) x == g (f x)
---
--- prop> \ x -> (h <. g <. f) x == h (g (f x))
-infixr 9 <.
-(<.) :: (b -> c) -> (a -> b) -> (a -> c)
-g <. f = compose f g
-
--- | Function composition. This function usually isn't necessary, but it can be
--- more readable than some alternatives when used with higher-order functions
--- like 'Prelude.map'.
---
--- >>> let fs = map (compose succ) [recip, negate]
--- >>> map (apply 3) fs
--- [0.25,-4.0]
---
--- In general you should prefer using an explicit lambda or operator section.
---
--- >>> map (\ f -> f 3) (map (\ f -> succ .> f) [recip, negate])
--- [0.25,-4.0]
--- >>> map (\ f -> f 3) (map (succ .>) [recip, negate])
--- [0.25,-4.0]
--- >>> map (\ f -> f 3) (map (<. succ) [recip, negate])
--- [0.25,-4.0]
---
--- prop> \ x -> compose f g x == g (f x)
-compose :: (a -> b) -> (b -> c) -> (a -> c)
-compose f g = \ x -> g (f x)
-
--- | Left-associative 'apply'' operator. Read as "strict apply forward" or
--- "strict pipe into". Use this to create long chains of computation that
--- suggest which direction things move in.
---
--- >>> 3 !> succ !> recip !> negate
--- -0.25
---
--- The difference between this and ('|>') is that this evaluates its argument
--- before passing it to the function.
---
--- >>> undefined |> const True
--- True
--- >>> undefined !> const True
--- *** Exception: Prelude.undefined
--- ...
---
--- prop> \ x -> (x !> f) == seq x (f x)
---
--- prop> \ x -> (x !> f !> g) == let y = seq x (f x) in seq y (g y)
-infixl 0 !>
-(!>) :: a -> (a -> b) -> b
-x !> f = apply' x f
-
--- | Right-associative 'apply'' operator. Read as "strict apply backward" or
--- "strict pipe from". Use this to create long chains of computation that
--- suggest which direction things move in. You may prefer this operator over
--- ('!>') for 'Prelude.IO' actions since it puts the last function first.
---
--- >>> print <! negate <! recip <! succ <! 3
--- -0.25
---
--- The difference between this and ('<|') is that this evaluates its argument
--- before passing it to the function.
---
--- >>> const True <| undefined
--- True
--- >>> const True <! undefined
--- *** Exception: Prelude.undefined
--- ...
---
--- Note that ('<!') and ('!>') have the same precedence, so they cannot be used
--- together.
---
--- >>> -- This doesn't work!
--- >>> -- print <! 3 !> succ !> recip !> negate
---
--- prop> \ x -> (f <! x) == seq x (f x)
---
--- prop> \ x -> (g <! f <! x) == let y = seq x (f x) in seq y (g y)
-infixr 0 <!
-(<!) :: (a -> b) -> a -> b
-f <! x = apply' x f
-
--- | Strict function application. This function usually isn't necessary, but it
--- can be more readable than some alternatives when used with higher-order
--- functions like 'Prelude.map'.
---
--- >>> map (apply' 2) [succ, recip, negate]
--- [3.0,0.5,-2.0]
---
--- The different between this and 'apply' is that this evaluates its argument
--- before passing it to the function.
---
--- >>> apply undefined (const True)
--- True
--- >>> apply' undefined (const True)
--- *** Exception: Prelude.undefined
--- ...
---
--- In general you should prefer using an explicit lambda or operator section.
---
--- >>> map (\ f -> 2 !> f) [succ, recip, negate]
--- [3.0,0.5,-2.0]
--- >>> map (2 !>) [succ, recip, negate]
--- [3.0,0.5,-2.0]
--- >>> map (<! 2) [succ, recip, negate]
--- [3.0,0.5,-2.0]
---
--- prop> \ x -> apply' x f == seq x (f x)
-apply' :: a -> (a -> b) -> b
-apply' x f = seq x (apply x f)
diff --git a/src/test/Main.hs b/src/test/Main.hs
deleted file mode 100644
--- a/src/test/Main.hs
+++ /dev/null
@@ -1,36 +0,0 @@
-import qualified Control.Monad as Monad
-import qualified Flow
-import qualified System.Exit as Exit
-import qualified Test.HUnit as Test
-
-main :: IO ()
-main = do
-  counts <- Test.runTestTT $ Test.TestList
-    [ True Test.~?= True
-    , (3 Flow.|> succ Flow.|> recip Flow.|> negate) Test.~?= (-0.25 :: Double)
-    , (negate Flow.<| recip Flow.<| succ Flow.<| 3) Test.~?= (-0.25 :: Double)
-    , map (Flow.apply 2) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
-    , map (\ f -> 2 Flow.|> f) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
-    , map (2 Flow.|>) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
-    , map (Flow.<| 2) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
-    , map (Flow.apply 3) (map (Flow.compose succ) [recip, negate]) Test.~?= [0.25, -4 :: Double]
-    , (succ Flow..> recip Flow..> negate) 3 Test.~?= (-0.25 :: Double)
-    , (negate Flow.<. recip Flow.<. succ) 3 Test.~?= (-0.25 :: Double)
-    , map (\ f -> f 3) (map (\ f -> succ Flow..> f) [recip, negate]) Test.~?= [0.25, -4 :: Double]
-    , map (\ f -> f 3) (map (succ Flow..>) [recip, negate]) Test.~?= [0.25, -4 :: Double]
-    , map (\ f -> f 3) (map (Flow.<. succ) [recip, negate]) Test.~?= [0.25, -4 :: Double]
-    , (3 Flow.!> succ Flow.!> recip Flow.!> negate) Test.~?= (-0.25 :: Double)
-    , (undefined Flow.|> const True) Test.~?= True
-    , (negate Flow.<! recip Flow.<! succ Flow.<! 3) Test.~?= (-0.25 :: Double)
-    , (const True Flow.<| undefined) Test.~?= True
-    , map (Flow.apply' 2) [succ, recip, negate]  Test.~?= [3, 0.5, -2 :: Double]
-    , Flow.apply undefined (const True) Test.~?= True
-    , map (\ f -> 2 Flow.!> f) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
-    , map (2 Flow.!>) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
-    , map (Flow.<! 2) [succ, recip, negate] Test.~?= [3, 0.5, -2 :: Double]
-    ]
-
-  let
-    hasErrors = Test.errors counts /= 0
-    hasFailures = Test.failures counts /= 0
-  Monad.when (hasErrors || hasFailures) Exit.exitFailure