flow 1.0.23 → 2.0.0.0

raw patch · 8 files changed

+329/−297 lines, 8 filesdep ~basePVP ok

version bump matches the API change (PVP)

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• CHANGELOG.markdown +4/−0
• LICENSE.markdown +1/−1
• README.markdown +2/−2
• flow.cabal +34/−11
• source/library/Flow.hs +247/−0
• source/test-suite/Main.hs +41/−0
• src/lib/Flow.hs +0/−247
• src/test/Main.hs +0/−36

@@ -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).

@@ -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

@@ -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

@@ -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

@@ -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)

@@ -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

@@ -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)

@@ -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