Migrate docs and examples to ps-0.12.0

paluh · paluh · commit a1dd17b1ae32 · 2018-07-16T15:32:36.000+02:00
diff --git a/docs/src/topic-guides/FormSerialization.purs b/docs/src/topic-guides/FormSerialization.purs
@@ -3,10 +3,7 @@ module FormSerialization where
 import Prelude
 import Data.Int as Int
 import Control.IxMonad ((:>>=), (:*>))
-import Control.Monad.Aff.AVar (AVAR)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE)
-import Control.Monad.Eff.Exception (EXCEPTION)
+import Effect (Effect)
 import Control.Monad.Error.Class (throwError)
 import Data.Either (Either(..))
 import Data.Generic.Rep (class Generic)
@@ -21,8 +18,6 @@ import Hyper.Node.Server (defaultOptionsWithLogging, runServer)
 import Hyper.Request (class ReadableBody, class Request, getRequestData)
 import Hyper.Response (class Response, class ResponseWritable, ResponseEnded, StatusLineOpen, closeHeaders, respond, writeStatus)
 import Hyper.Status (statusBadRequest, statusMethodNotAllowed)
-import Node.Buffer (BUFFER)
-import Node.HTTP (HTTP)
 
 -- start snippet datatypes
 data MealType = Vegan | Vegetarian | Omnivore | Carnivore
@@ -89,7 +84,7 @@ onPost =
                      <> show beers <> " beers coming up!\n")
 -- end snippet onPost
 
-main :: forall e. Eff (http :: HTTP, console :: CONSOLE, exception :: EXCEPTION, avar :: AVAR, buffer :: BUFFER | e) Unit
+main :: Effect Unit
 main =
   let
     router =
diff --git a/docs/src/topic-guides/NodeReaderT.purs b/docs/src/topic-guides/NodeReaderT.purs
@@ -2,26 +2,24 @@ module NodeReaderT where
 
 import Prelude
 import Control.IxMonad ((:>>=), (:*>))
-import Control.Monad.Aff (Aff)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE)
+import Effect.Aff (Aff)
+import Effect (Effect)
 import Control.Monad.Reader (ReaderT, ask, runReaderT)
 import Hyper.Middleware (lift')
 import Hyper.Node.Server (defaultOptionsWithLogging, runServer')
 import Hyper.Response (closeHeaders, respond, writeStatus)
 import Hyper.Status (statusOK)
-import Node.HTTP (HTTP)
 
 -- start snippet main
 type MyConfig = { thingToSay :: String }
 
 runAppM
-  :: forall e a.
-    ReaderT MyConfig (Aff e) a
-  -> Aff e a
+  :: forall a.
+    ReaderT MyConfig Aff a
+  -> Aff a
 runAppM = flip runReaderT { thingToSay: "Hello, ReaderT!" }
 
-main :: forall e. Eff (console :: CONSOLE, http :: HTTP | e) Unit
+main :: Effect Unit
 main =
   let app =
         lift' ask :>>= \config ->
diff --git a/docs/src/topic-guides/ReadBody.purs b/docs/src/topic-guides/ReadBody.purs
@@ -2,10 +2,7 @@ module ReadBody where
 
 import Prelude
 import Control.IxMonad ((:>>=), (:*>))
-import Control.Monad.Aff.AVar (AVAR)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE)
-import Control.Monad.Eff.Exception (EXCEPTION)
+import Effect (Effect)
 import Data.Either (Either(..))
 import Data.HTTP.Method (Method(..))
 import Hyper.Conn (Conn)
@@ -14,8 +11,6 @@ import Hyper.Node.Server (defaultOptionsWithLogging, runServer)
 import Hyper.Request (class ReadableBody, getRequestData, readBody)
 import Hyper.Response (class Response, class ResponseWritable, ResponseEnded, StatusLineOpen, closeHeaders, respond, writeStatus)
 import Hyper.Status (statusBadRequest, statusMethodNotAllowed)
-import Node.Buffer (BUFFER)
-import Node.HTTP (HTTP)
 
 onPost
   :: forall m b req res c
@@ -42,7 +37,7 @@ onPost =
       :*> respond ("You said: " <> msg)
 -- end snippet onPost
 
-main :: forall e. Eff (http :: HTTP, console :: CONSOLE, exception :: EXCEPTION, avar :: AVAR, buffer :: BUFFER | e) Unit
+main :: Effect Unit
 main =
   let
     router =
diff --git a/examples/Authentication.purs b/examples/Authentication.purs
@@ -3,9 +3,8 @@ module Examples.Authentication where
 import Prelude
 
 import Control.IxMonad ((:>>=), (:*>))
-import Control.Monad.Aff (Aff)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE)
+import Effect.Aff (Aff)
+import Effect (Effect)
 import Data.Maybe (Maybe(Just, Nothing))
 import Data.MediaType.Common (textHTML)
 import Data.Tuple (Tuple(Tuple))
@@ -14,22 +13,20 @@ import Hyper.Node.BasicAuth as BasicAuth
 import Hyper.Node.Server (defaultOptionsWithLogging, runServer)
 import Hyper.Response (closeHeaders, contentType, respond, writeStatus)
 import Hyper.Status (statusOK)
-import Node.Buffer (BUFFER)
-import Node.HTTP (HTTP)
 import Text.Smolder.HTML (p)
 import Text.Smolder.Markup (text)
 import Text.Smolder.Renderer.String (render)
 
 data User = User String
 
 -- This could be a function checking the username/password in a database.
-userFromBasicAuth :: forall e. Tuple String String -> Aff e (Maybe User)
+userFromBasicAuth :: Tuple String String -> Aff (Maybe User)
 userFromBasicAuth =
   case _ of
     Tuple "admin" "admin" -> pure (Just (User "Administrator"))
     _ -> pure Nothing
 
-main :: forall e. Eff (console :: CONSOLE, http ∷ HTTP, buffer :: BUFFER | e) Unit
+main :: Effect Unit
 main =
   let
     myProfilePage =
diff --git a/examples/AuthenticationAndAuthorization.purs b/examples/AuthenticationAndAuthorization.purs
@@ -10,11 +10,8 @@ module Examples.AuthenticationAndAuthorization where
 import Prelude
 
 import Control.IxMonad ((:>>=), (:*>))
-import Control.Monad.Aff.AVar (AVAR)
-import Control.Monad.Aff.Class (class MonadAff)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE)
-import Control.Monad.Eff.Exception (EXCEPTION)
+import Effect.Aff.Class (class MonadAff)
+import Effect (Effect)
 import Data.Either (Either(..))
 import Data.HTTP.Method (Method(GET))
 import Data.Maybe (Maybe(Nothing, Just))
@@ -29,8 +26,6 @@ import Hyper.Node.Server (defaultOptionsWithLogging, runServer)
 import Hyper.Request (class Request, getRequestData)
 import Hyper.Response (class Response, class ResponseWritable, ResponseEnded, StatusLineOpen, closeHeaders, contentType, respond, writeStatus)
 import Hyper.Status (Status, statusNotFound, statusOK)
-import Node.Buffer (BUFFER)
-import Node.HTTP (HTTP)
 import Text.Smolder.HTML (a, h1, li, p, section, ul)
 import Text.Smolder.HTML.Attributes as A
 import Text.Smolder.Markup (Markup, text, (!))
@@ -130,7 +125,7 @@ adminHandler =
 -- This could be a function checking the username/password in a database
 -- in your application.
 userFromBasicAuth
-  :: forall m e. MonadAff e m =>
+  :: forall m. MonadAff m =>
      Tuple String String
   -> m (Maybe User)
 userFromBasicAuth =
@@ -155,8 +150,8 @@ getAdminRole conn =
     _ -> pure Nothing
 
 
-app :: forall m e req res b c
-    .  MonadAff (buffer :: BUFFER | e) m
+app :: forall m req res b c
+    .  MonadAff m
     => Request req m
     => Response res m b
     => ResponseWritable b m String
@@ -204,7 +199,7 @@ app = BasicAuth.withAuthentication userFromBasicAuth :>>= \_ → router
           _, _ ->
             notFound
 
-main :: forall e. Eff (http :: HTTP, console :: CONSOLE, exception :: EXCEPTION, avar :: AVAR, buffer :: BUFFER | e) Unit
+main :: Effect Unit
 main =
   let
     components = { authentication: unit
diff --git a/examples/Cookies.purs b/examples/Cookies.purs
@@ -2,15 +2,13 @@ module Examples.Cookies where
 
 import Prelude
 import Control.IxMonad ((:*>))
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE)
+import Effect (Effect)
 import Hyper.Cookies (cookies)
 import Hyper.Node.Server (defaultOptionsWithLogging, runServer)
 import Hyper.Response (closeHeaders, respond, writeStatus)
 import Hyper.Status (statusOK)
-import Node.HTTP (HTTP)
 
-main :: forall e. Eff (console :: CONSOLE, http :: HTTP | e) Unit
+main :: Effect Unit
 main =
   let app = cookies
             :*> writeStatus statusOK
diff --git a/examples/FileServer.purs b/examples/FileServer.purs
@@ -3,19 +3,15 @@ module Examples.FileServer where
 import Prelude
 
 import Control.IxMonad ((:*>))
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE)
+import Effect (Effect)
 import Data.Tuple (Tuple(Tuple))
 import Hyper.Node.FileServer (fileServer)
 import Hyper.Node.Server (defaultOptionsWithLogging, runServer)
 import Hyper.Response (headers, respond, writeStatus)
 import Hyper.Status (statusNotFound)
-import Node.Buffer (BUFFER)
 import Node.Encoding (Encoding(UTF8))
-import Node.FS (FS)
-import Node.HTTP (HTTP)
 
-main :: forall e. Eff (console :: CONSOLE, http ∷ HTTP, fs :: FS, buffer :: BUFFER | e) Unit
+main :: Effect Unit
 main =
   let
     notFound =
diff --git a/examples/FormParser.purs b/examples/FormParser.purs
@@ -3,11 +3,9 @@ module Examples.FormParser where
 import Prelude
 import Text.Smolder.HTML.Attributes as A
 import Control.IxMonad ((:>>=), (:*>))
-import Control.Monad.Aff.AVar (AVAR)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Class (liftEff)
-import Control.Monad.Eff.Console (log, CONSOLE)
-import Control.Monad.Eff.Exception (EXCEPTION)
+import Effect (Effect)
+import Effect.Class (liftEffect)
+import Effect.Console (log)
 import Data.Either (Either(Right, Left))
 import Data.HTTP.Method (Method(..))
 import Data.Maybe (Maybe(Nothing, Just))
@@ -18,13 +16,11 @@ import Hyper.Node.Server (defaultOptionsWithLogging, runServer)
 import Hyper.Request (getRequestData)
 import Hyper.Response (closeHeaders, contentType, respond, writeStatus)
 import Hyper.Status (statusBadRequest, statusMethodNotAllowed, statusOK)
-import Node.Buffer (BUFFER)
-import Node.HTTP (HTTP)
 import Text.Smolder.HTML (button, form, input, label, p)
 import Text.Smolder.Markup (text, (!))
 import Text.Smolder.Renderer.String (render)
 
-main :: forall e. Eff (http :: HTTP, console :: CONSOLE, exception :: EXCEPTION, avar :: AVAR, buffer :: BUFFER | e) Unit
+main :: Effect Unit
 main =
   let
     -- A view function that renders the name form.
@@ -53,7 +49,7 @@ main =
       parseForm :>>=
       case _ of
         Left err -> do
-          liftEff (log err)
+          liftEffect (log err)
           :*> htmlWithStatus
               statusBadRequest
               (p (text "Bad request, invalid form."))
diff --git a/examples/HelloHyper.purs b/examples/HelloHyper.purs
@@ -2,14 +2,12 @@ module Examples.HelloHyper where
 
 import Prelude
 import Control.IxMonad ((:*>))
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE)
+import Effect (Effect)
 import Hyper.Node.Server (defaultOptionsWithLogging, runServer)
 import Hyper.Response (closeHeaders, respond, writeStatus)
 import Hyper.Status (statusOK)
-import Node.HTTP (HTTP)
 
-main :: forall e. Eff (console :: CONSOLE, http :: HTTP | e) Unit
+main :: Effect Unit
 main =
   let app = writeStatus statusOK
             :*> closeHeaders
diff --git a/examples/NodeStreamRequest.purs b/examples/NodeStreamRequest.purs
@@ -15,32 +15,28 @@ import Prelude
 import Node.Buffer as Buffer
 import Node.Stream as Stream
 import Control.IxMonad (ibind, (:>>=))
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Class (class MonadEff, liftEff)
-import Control.Monad.Eff.Console (CONSOLE, log)
-import Control.Monad.Eff.Exception (EXCEPTION, catchException, message)
+import Effect (Effect)
+import Effect.Class (class MonadEffect, liftEffect)
+import Effect.Console (log)
+import Effect.Exception (catchException, message)
 import Data.Either (Either(..), either)
 import Data.HTTP.Method (Method(..))
 import Hyper.Node.Server (defaultOptionsWithLogging, runServer)
 import Hyper.Request (getRequestData, streamBody)
 import Hyper.Response (closeHeaders, respond, writeStatus)
 import Hyper.Status (statusMethodNotAllowed, statusOK)
-import Node.Buffer (BUFFER)
-import Node.HTTP (HTTP)
-
-type ExampleEffects e = (http :: HTTP, console :: CONSOLE, buffer :: BUFFER | e)
 
 logRequestBodyChunks
-  :: forall m e
-   . MonadEff (ExampleEffects e) m
-  => Stream.Readable () (ExampleEffects (exception :: EXCEPTION | e))
+  :: forall m
+   . MonadEffect m
+  => Stream.Readable ()
   -> m Unit
 logRequestBodyChunks body =
   Stream.onData body (Buffer.size >=> (log <<< ("Got chunk of size: " <> _) <<< show))
   # catchException (log <<< ("Error: " <> _) <<< message)
-  # liftEff
+  # liftEffect
 
-main :: forall e. Eff (ExampleEffects e) Unit
+main :: Effect Unit
 main =
   let
     app =
diff --git a/examples/NodeStreamResponse.purs b/examples/NodeStreamResponse.purs
@@ -5,11 +5,10 @@
 module Examples.NodeStreamResponse where
 
 import Prelude
-import Control.Monad.Aff as Aff
 import Control.IxMonad ((:*>))
-import Control.Monad.Aff.Class (class MonadAff, liftAff)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE)
+import Effect.Aff as Aff
+import Effect.Aff.Class (class MonadAff, liftAff)
+import Effect (Effect)
 import Data.Int (toNumber)
 import Data.Newtype (wrap)
 import Data.Traversable (traverse_)
@@ -19,12 +18,11 @@ import Hyper.Node.Server (defaultOptions, runServer, writeString)
 import Hyper.Response (closeHeaders, end, send, writeStatus)
 import Hyper.Status (statusOK)
 import Node.Encoding (Encoding(..))
-import Node.HTTP (HTTP)
 
-delay :: forall m e c. MonadAff e m => Int -> Middleware m c c Unit
+delay :: forall m c. MonadAff m => Int -> Middleware m c c Unit
 delay n = lift' (liftAff (Aff.delay (wrap <<< toNumber $ n) *> pure unit))
 
-main :: forall e. Eff (console :: CONSOLE, http :: HTTP | e) Unit
+main :: Effect Unit
 main =
   let
     -- These messages are streamed one at a time, regardless of their individual
diff --git a/examples/Sessions.purs b/examples/Sessions.purs
@@ -2,14 +2,10 @@ module Examples.Sessions where
 
 import Prelude
 import Control.IxMonad ((:*>), (:>>=))
-import Control.Monad.Aff (launchAff)
-import Control.Monad.Aff.Console (log)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Class (liftEff)
-import Control.Monad.Eff.Console (CONSOLE)
-import Control.Monad.Eff.Exception (EXCEPTION)
-import Control.Monad.Eff.Random (RANDOM)
-import Control.Monad.Eff.Ref (REF)
+import Effect.Aff (launchAff)
+import Effect (Effect)
+import Effect.Class (liftEffect)
+import Effect.Class.Console (log)
 import Data.Maybe (Maybe(..))
 import Data.MediaType.Common (textHTML)
 import Hyper.Cookies (cookies)
@@ -20,14 +16,13 @@ import Hyper.Request (getRequestData)
 import Hyper.Response (closeHeaders, contentType, end, redirect, respond, writeStatus)
 import Hyper.Session (deleteSession, getSession, saveSession)
 import Hyper.Status (statusNotFound, statusOK)
-import Node.HTTP (HTTP)
 
 newtype MySession = MySession { userId :: Int }
 
-main :: forall e. Eff (exception :: EXCEPTION, ref :: REF, console :: CONSOLE, http :: HTTP, random ::RANDOM | e) Unit
+main :: forall e. Effect Unit
 main = void $ launchAff do
-  store <- liftEff newInMemorySessionStore
-  liftEff (runServer defaultOptionsWithLogging (components store) app)
+  store <- liftEffect newInMemorySessionStore
+  liftEffect (runServer defaultOptionsWithLogging (components store) app)
   where
     components store =
       { sessions: { key: "my-session"
diff --git a/examples/StateT.purs b/examples/StateT.purs
