Create Utils module for (|>) operator

For the past 3-4 Haskell projects on which I've worked, I've tried to habituate
the usage of the (&) operator, but I find that -- as petty as it may sound -- I
don't like the way that it looks, and I end up avoiding using it as a result.

This time around, I'm aliasing it to (|>) (i.e. Elixir style), and I'm hoping to
use it more.

src/Accounts.hs

@@ -2,7 +2,6 @@
 --------------------------------------------------------------------------------
 module Accounts where
 --------------------------------------------------------------------------------
-import Data.Function ((&))
 import Database.SQLite.Simple
 
 import qualified Types as T

src/App.hs

@@ -7,12 +7,12 @@ module App where
 --------------------------------------------------------------------------------
 import Control.Exception (throwIO)
 import Control.Monad.IO.Class (liftIO)
-import Data.Function ((&))
 import Data.String.Conversions (cs)
 import Data.Text (Text)
 import Network.Wai.Handler.Warp as Warp
 import Servant
 import API
+import Utils
 
 import qualified Crypto.KDF.BCrypt as BC
 import qualified Data.Text.Encoding as TE

src/Sessions.hs

@@ -3,7 +3,6 @@
 --------------------------------------------------------------------------------
 module Sessions where
 --------------------------------------------------------------------------------
-import Data.Function ((&))
 import Database.SQLite.Simple
 
 import qualified Data.Time.Clock as Clock

src/Trips.hs

@@ -2,8 +2,8 @@
 --------------------------------------------------------------------------------
 module Trips where
 --------------------------------------------------------------------------------
-import Data.Function ((&))
 import Database.SQLite.Simple
+import Utils
 
 import qualified Types as T
 --------------------------------------------------------------------------------
@@ -12,14 +12,14 @@ import qualified Types as T
 create :: FilePath -> T.Trip -> IO ()
 create dbFile trip = withConnection dbFile $ \conn ->
   execute conn "INSERT INTO Trips (username,destination,startDate,endDate,comment) VALUES (?,?,?,?,?)"
-    (trip & T.tripFields)
+    (trip |> T.tripFields)
 
 -- | Delete a trip from `dbFile` using its `tripPK` Primary Key.
 delete :: FilePath -> T.TripPK -> IO ()
 delete dbFile tripPK =
   withConnection dbFile $ \conn -> do
     execute conn "DELETE FROM Trips WHERE username = ? AND destination = ? and startDate = ?"
-      (tripPK & T.tripPKFields)
+      (tripPK |> T.tripPKFields)
 
 -- | Return a list of all of the trips in `dbFile`.
 list :: FilePath -> IO [T.Trip]

src/Types.hs

@@ -6,7 +6,7 @@
 module Types where
 --------------------------------------------------------------------------------
 import Data.Aeson
-import Data.Function ((&))
+import Utils
 import Data.Text
 import Data.Typeable
 import Database.SQLite.Simple
@@ -52,7 +52,7 @@ instance ToField HashedPassword where
 instance FromField HashedPassword where
   fromField field =
     case fieldData field of
-      (SQLText x) -> x & TE.encodeUtf8 & HashedPassword & Ok
+      (SQLText x) -> x |> TE.encodeUtf8 |> HashedPassword |> Ok
       _ -> returnError ConversionFailed field ""
 
 newtype ClearTextPassword = ClearTextPassword Text
@@ -314,10 +314,10 @@ instance FromJSON AccountCredentials where
                            }
 
 
--- -- | Hash password `x`.
+-- | Hash password `x`.
 hashPassword :: (MonadRandom m) => ClearTextPassword -> m HashedPassword
 hashPassword (ClearTextPassword x) = do
-  hashed <- BC.hashPassword 12 (x & unpack & B.pack)
+  hashed <- BC.hashPassword 12 (x |> unpack |> B.pack)
   pure $ HashedPassword hashed
 
 data CreateAccountRequest = CreateAccountRequest

src/Utils.hs

@@ -0,0 +1,8 @@
+--------------------------------------------------------------------------------
+module Utils where
+--------------------------------------------------------------------------------
+import Data.Function ((&))
+--------------------------------------------------------------------------------
+
+-- | Prefer this operator to the ampersand for stylistic reasons.
+(|>) = (&)