Use index-monad's qualified do module; delete Middleware.QualifiedDo

examples/Authentication.purs

@@ -2,7 +2,7 @@ module Examples.Authentication where
 
 import Prelude
 
-import Control.Monad.Indexed ((:>>=), (:*>))
+import Control.Monad.Indexed.Qualified as Ix
 import Effect.Aff (Aff)
 import Effect (Effect)
 import Data.Maybe (Maybe(Just, Nothing))
@@ -29,17 +29,17 @@ userFromBasicAuth =
 main :: Effect Unit
 main =
   let
-    myProfilePage =
-      getConn :>>= \conn ->
+    myProfilePage = Ix.do
+      conn <- getConn
       case conn.components.authentication of
-        User name → do
+        User name → Ix.do
           writeStatus statusOK
-          :*> contentType textHTML
-          :*> closeHeaders
-          :*> respond (render (p (text ("You are authenticated as " <> name <> "."))))
+          contentType textHTML
+          closeHeaders
+          respond (render (p (text ("You are authenticated as " <> name <> "."))))
 
-    app = do
+    app = Ix.do
       BasicAuth.withAuthentication userFromBasicAuth
-      :*> BasicAuth.authenticated "Authentication Example" myProfilePage
+      BasicAuth.authenticated "Authentication Example" myProfilePage
     components = { authentication: unit }
   in runServer defaultOptionsWithLogging components app

examples/AuthenticationAndAuthorization.purs

@@ -9,7 +9,8 @@ module Examples.AuthenticationAndAuthorization where
 
 import Prelude
 
-import Control.Monad.Indexed ((:>>=), (:*>))
+import Control.Monad.Indexed.Qualified as Ix
+import Control.Monad.Indexed ((:>>=))
 import Effect.Aff.Class (class MonadAff)
 import Effect (Effect)
 import Data.Either (Either(..))
@@ -45,11 +46,11 @@ htmlWithStatus
      (Conn req (res StatusLineOpen) c)
      (Conn req (res ResponseEnded) c)
      Unit
-htmlWithStatus status x =
+htmlWithStatus status x = Ix.do
   writeStatus status
-  :*> contentType textHTML
-  :*> closeHeaders
-  :*> respond (render x)
+  contentType textHTML
+  closeHeaders
+  respond (render x)
 
 
 -- Users have user names.
@@ -76,11 +77,11 @@ profileHandler
      (Conn req (res StatusLineOpen) { authentication :: Maybe User | c })
      (Conn req (res ResponseEnded) { authentication :: Maybe User | c })
      Unit
-profileHandler =
-  getConn :>>= \conn →
+profileHandler = Ix.do
+  conn <- getConn
   htmlWithStatus
-  statusOK
-  (view conn.components.authentication)
+    statusOK
+    (view conn.components.authentication)
   where
     view =
       case _ of
@@ -183,8 +184,8 @@ app = BasicAuth.withAuthentication userFromBasicAuth :>>= \_ → router
             li (a ! A.href "/profile" $ text "Profile")
             li (a ! A.href "/admin" $ text "Administration")
 
-      router =
-        getRequestData :>>= \{ method, url } →
+      router = Ix.do
+        { method, url } <- getRequestData
         case method, url of
           Left GET, "/" ->
             htmlWithStatus statusOK homeView

examples/Cookies.purs

@@ -1,7 +1,7 @@
 module Examples.Cookies where
 
 import Prelude
-import Control.Monad.Indexed ((:*>))
+import Control.Monad.Indexed.Qualified as Ix
 import Effect (Effect)
 import Hyper.Cookies (cookies)
 import Hyper.Node.Server (defaultOptionsWithLogging, runServer)
@@ -10,8 +10,9 @@ import Hyper.Status (statusOK)
 
 main :: Effect Unit
 main =
-  let app = cookies
-            :*> writeStatus statusOK
-            :*> closeHeaders
-            :*> respond "Hello, Hyper!"
+  let app = Ix.do
+        cookies
+        writeStatus statusOK
+        closeHeaders
+        respond "Hello, Hyper!"
   in runServer defaultOptionsWithLogging { cookies: unit } app

examples/FileServer.purs

@@ -2,7 +2,7 @@ module Examples.FileServer where
 
 import Prelude
 
-import Control.Monad.Indexed ((:*>))
+import Control.Monad.Indexed.Qualified as Ix
 import Effect (Effect)
 import Data.Tuple (Tuple(Tuple))
 import Hyper.Node.FileServer (fileServer)
@@ -14,9 +14,9 @@ import Node.Encoding (Encoding(UTF8))
 main :: Effect Unit
 main =
   let
-    notFound =
+    notFound = Ix.do
       writeStatus statusNotFound
-      :*> headers []
-      :*> respond (Tuple "<h1>Not Found</h1>" UTF8)
+      headers []
+      respond (Tuple "<h1>Not Found</h1>" UTF8)
     app = fileServer "examples/FileServer" notFound
   in runServer defaultOptionsWithLogging {} app

examples/FormParser.purs

@@ -2,6 +2,7 @@ module Examples.FormParser where
 
 import Prelude
 import Text.Smolder.HTML.Attributes as A
+import Control.Monad.Indexed.Qualified as Ix
 import Control.Monad.Indexed ((:>>=), (:*>))
 import Effect (Effect)
 import Effect.Class (liftEffect)
@@ -39,11 +40,11 @@ main =
             Just s -> p ! A.style "color: red;" $ text s
             Nothing -> pure unit
 
-    htmlWithStatus status x =
+    htmlWithStatus status x = Ix.do
       writeStatus status
-      :*> contentType textHTML
-      :*> closeHeaders
-      :*> respond (render x)
+      contentType textHTML
+      closeHeaders
+      respond (render x)
 
     handlePost =
       parseForm :>>=

examples/HelloHyper.purs

@@ -1,15 +1,16 @@
 module Examples.HelloHyper where
 
 import Prelude
-import Control.Monad.Indexed ((:*>))
+import Control.Monad.Indexed.Qualified as Ix
 import Effect (Effect)
 import Hyper.Node.Server (defaultOptionsWithLogging, runServer)
 import Hyper.Response (closeHeaders, respond, writeStatus)
 import Hyper.Status (statusOK)
 
 main :: Effect Unit
 main =
-  let app = writeStatus statusOK
-            :*> closeHeaders
-            :*> respond "Hello, Hyper!"
+  let app = Ix.do
+        writeStatus statusOK
+        closeHeaders
+        respond "Hello, Hyper!"
   in runServer defaultOptionsWithLogging {} app

examples/NodeStreamRequest.purs

@@ -14,7 +14,8 @@ module Examples.NodeStreamRequest where
 import Prelude
 import Node.Buffer as Buffer
 import Node.Stream as Stream
-import Control.Monad.Indexed (ibind, (:>>=))
+import Control.Monad.Indexed.Qualified as Ix
+import Control.Monad.Indexed ((:>>=))
 import Effect (Effect)
 import Effect.Class (class MonadEffect, liftEffect)
 import Effect.Console (log)
@@ -44,20 +45,17 @@ main =
       case _ of
 
         -- Only handle POST requests:
-        { method: Left POST } -> do
+        { method: Left POST } -> Ix.do
             body <- streamBody
             logRequestBodyChunks body
             writeStatus statusOK
             closeHeaders
             respond "OK"
 
         -- Non-POST requests are not allowed:
-        { method } -> do
+        { method } -> Ix.do
           writeStatus statusMethodNotAllowed
           closeHeaders
           respond ("Method not allowed: " <> either show show method)
 
-        where
-            bind = ibind
-            discard = ibind
   in runServer defaultOptionsWithLogging {} app

examples/NodeStreamResponse.purs

@@ -5,6 +5,7 @@
 module Examples.NodeStreamResponse where
 
 import Prelude
+import Control.Monad.Indexed.Qualified as Ix
 import Control.Monad.Indexed ((:*>))
 import Effect.Aff as Aff
 import Effect.Aff.Class (class MonadAff, liftAff)
@@ -35,9 +36,9 @@ main =
       , Tuple 500 "Hyper\n"
       ]
 
-    app = do
+    app = Ix.do
       writeStatus statusOK
-      :*> closeHeaders
-      :*> streamMessages
-      :*> end
+      closeHeaders
+      streamMessages
+      end
   in runServer defaultOptions {} app

examples/QualifiedDo.purs

@@ -2,13 +2,13 @@ module Examples.QualifiedDo where
 
 import Prelude
 import Effect (Effect)
-import Hyper.Middleware as Middleware
+import Control.Monad.Indexed.Qualified as Ix
 import Hyper.Node.Server (defaultOptionsWithLogging, runServer)
 import Hyper.Response (closeHeaders, respond, writeStatus)
 import Hyper.Status (statusOK)
 
 main :: Effect Unit
-main = runServer defaultOptionsWithLogging {} Middleware.do
+main = runServer defaultOptionsWithLogging {} Ix.do
   writeStatus statusOK
   closeHeaders
   respond "Hello, Hyper!"

examples/Sessions.purs

@@ -1,7 +1,8 @@
 module Examples.Sessions where
 
 import Prelude
-import Control.Monad.Indexed ((:*>), (:>>=))
+import Control.Monad.Indexed.Qualified as Ix
+import Control.Monad.Indexed ((:>>=))
 import Effect.Aff (launchAff)
 import Effect (Effect)
 import Effect.Class (liftEffect)
@@ -31,38 +32,38 @@ main = void $ launchAff do
       , cookies: unit
       }
 
-    home =
+    home = Ix.do
       writeStatus statusOK
-      :*> contentType textHTML
-      :*> closeHeaders
-      :*> getSession :>>=
+      contentType textHTML
+      closeHeaders
+      getSession :>>=
           case _ of
-            Just (MySession { userId }) ->
-              lift' (log "Session") :*>
+            Just (MySession { userId }) -> Ix.do
+              lift' (log "Session")
               respond ("You are logged in as user " <> show userId <> ". "
                       <> "<a href=\"/logout\">Logout</a> if you're anxious.")
-            Nothing ->
-              lift' (log "No Session") :*>
+            Nothing -> Ix.do
+              lift' (log "No Session")
               respond "<a href=\"/login\">Login</a> to start a session."
 
-    login =
+    login = Ix.do
       redirect "/"
-      :*> saveSession (MySession { userId: 1 })
-      :*> contentType textHTML
-      :*> closeHeaders
-      :*> end
+      saveSession (MySession { userId: 1 })
+      contentType textHTML
+      closeHeaders
+      end
 
-    logout =
+    logout = Ix.do
       redirect "/"
-      :*> deleteSession
-      :*> closeHeaders
-      :*> end
+      deleteSession
+      closeHeaders
+      end
 
-    notFound =
+    notFound = Ix.do
       writeStatus statusNotFound
-      :*> contentType textHTML
-      :*> closeHeaders
-      :*> respond "Not Found"
+      contentType textHTML
+      closeHeaders
+      respond "Not Found"
 
     -- Simple router for this example.
     router =
@@ -73,6 +74,6 @@ main = void $ launchAff do
         "/logout" -> logout
         _ -> notFound
 
-    app =
+    app = Ix.do
       cookies
-      :*> router
+      router

examples/StateT.purs

@@ -1,7 +1,7 @@
 module Examples.StateT where
 
 import Prelude
-import Control.Monad.Indexed (ibind, (:*>))
+import Control.Monad.Indexed.Qualified as Ix
 import Effect.Aff (Aff)
 import Effect (Effect)
 import Control.Monad.State (evalStateT, get, modify)
@@ -22,16 +22,14 @@ main =
   let
       -- Our application just appends to the state in between
       -- some operations, then responds with the built up state...
-      app = do
-        _ <- lift' (modify (flip append ["I"]))
-          :*> writeStatus statusOK
-          :*> lift' (modify (flip append ["have"]))
-          :*> closeHeaders
-          :*> lift' (modify (flip append ["state."]))
+      app = Ix.do
+        void $ lift' (modify (flip append ["I"]))
+        writeStatus statusOK
+        void $ lift' (modify (flip append ["have"]))
+        closeHeaders
+        void $ lift' (modify (flip append ["state."]))
 
         msgs ← lift' get
         respond (joinWith " " msgs)
 
-        where bind = ibind
-
   in runServer' defaultOptionsWithLogging {} runAppM app

src/Hyper/Authorization.purs

@@ -1,6 +1,6 @@
 module Hyper.Authorization where
 
-import Control.Monad.Indexed (ibind)
+import Control.Monad.Indexed.Qualified as Ix
 import Control.Monad (class Monad)
 import Data.Maybe (Maybe(Nothing, Just))
 import Data.Unit (unit, Unit)
@@ -33,16 +33,15 @@ authorized :: forall a m req res b c
      (Conn req (res StatusLineOpen) { authorization :: Unit | c })
      (Conn req (res ResponseEnded) { authorization :: Unit | c })
      Unit
-authorized authorizer mw = do
+authorized authorizer mw = Ix.do
   conn ← getConn
   auth ← lift' (authorizer conn)
   case auth of
-    Just a -> do
-      _ <- modifyConn (withAuthorization a)
-      _ <- mw
+    Just a -> Ix.do
+      modifyConn (withAuthorization a)
+      mw
       modifyConn (withAuthorization unit)
-    Nothing -> do
-      _ <- writeStatus statusForbidden
-      _ <- headers []
+    Nothing -> Ix.do
+      writeStatus statusForbidden
+      headers []
       respond "You are not authorized."
-  where bind = ibind