6c5afe8 · servant · git.iko.soy

git.iko.soy/servant

Merge remote-tracking branch 'origin/master' into client-ghcjs_update-stack-file

commit6c5afe8fb3592b1364e2688b61c6007392047fa9 authorSönke Hahn <soenkehahn@gmail.com> dateSat 9 Jul 2016, 11:11 (10 years ago) parentcd22bf7 af7391c

90 files changed+1543−1305

compare with master

unifiedsplit

.travis.yml+7−4

@@ -3,8 +3,9 @@ sudo: false

33language: c

55env:

6− - GHCVER=7.8.4

7− - GHCVER=7.10.2

6+ - GHCVER=7.8.4 CABALVER=1.22

7+ - GHCVER=7.10.3 CABALVER=1.22

8+ - GHCVER=8.0.1 CABALVER=1.24

910addons:

1011 apt:

@@ -12,13 +13,15 @@ addons:

1213 - hvr-ghc

1314 packages:

1415 - ghc-7.8.4

15− - ghc-7.10.2

16+ - ghc-7.10.3

17+ - ghc-8.0.1

1618 - cabal-install-1.22

19+ - cabal-install-1.24

1720 - libgmp-dev

1821

1922install:

2023 - (mkdir -p $HOME/.local/bin && cd $HOME/.local/bin && wget https://zalora-public.s3.amazonaws.com/tinc && chmod +x tinc)

21− - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/1.22/bin:$PATH

24+ - export PATH=/opt/ghc/$GHCVER/bin:/opt/cabal/$CABALVER/bin:$PATH

2225 - ghc --version

2326 - cabal --version

2427 - travis_retry cabal update

README.md+2−1

@@ -4,11 +4,12 @@

55## Getting Started

7−We have a [tutorial](http://haskell-servant.github.io/tutorial) that

7+We have a [tutorial](http://haskell-servant.readthedocs.org/en/stable/tutorial/index.html) that

88introduces the core features of servant. After this article, you should be able

99to write your first servant webservices, learning the rest from the haddocks'

1010examples.

1111

12+The central documentation can be found [here](http://haskell-servant.readthedocs.org/).

1213Other blog posts, videos and slides can be found on the

1314[website](http://haskell-servant.github.io/).

1415

doc/examples.mdnew file+37

@@ -0,0 +1,37 @@

1+# Example Projects

3+- **[example-servant-minimal](https://github.com/haskell-servant/example-servant-minimal)**:

5+ A minimal example for a web server written using **servant-server**,

6+ including a test-suite using [**hspec**](http://hspec.github.io/) and

7+ **servant-client**.

10+- **[stack-templates](https://github.com/commercialhaskell/stack-templates)**

11+

12+ Repository for templates for haskell projects, including some templates using

13+ **servant**. These templates can be used with `stack new`.

14+

15+- **[custom-monad](https://github.com/themoritz/diener)**:

16+

17+ A custom monad that can replace `IO` in servant applications. It adds among

18+ other things logging functionality and a reader monad (for database connections).

19+ A full usage example of servant/diener is also provided.

20+

21+

22+- **[example-servant-elm](https://github.com/haskell-servant/example-servant-elm)**:

23+

24+ An example for a project consisting of

25+

26+ - a backend web server written using **servant-server**,

27+ - a frontend written in [elm](http://elm-lang.org/) using

28+ [servant-elm](https://github.com/mattjbray/servant-elm) to generate client

29+ functions in elm for the API,

30+ - test-suites for both the backend and the frontend.

31+

32+

33+- **[example-servant-persistent](https://github.com/haskell-servant/example-servant-persistent)**:

34+

35+ An example for a web server written with **servant-server** and

36+ [persistent](https://www.stackage.org/package/persistent) for writing data

37+ into a database.

doc/index.rst+1

@@ -19,4 +19,5 @@ All in a type-safe manner.

1919

2020 introduction.rst

2121 tutorial/index.rst

22+ examples.md

2223 links.rst

doc/tutorial/ApiType.lhs+1−1

@@ -297,7 +297,7 @@ Authentication](https://en.wikipedia.org/wiki/Basic_access_authentication).

297297

298298When protecting endpoints with basic authentication, we need to specify two items:

299299

300−1. The **realm** of authentication as per the Basic Authentictaion spec.

300+1. The **realm** of authentication as per the Basic Authentication spec.

3013012. The datatype returned by the server after authentication is verified. This

302302 is usually a `User` or `Customer` type datatype.

303303

doc/tutorial/Authentication.lhs+15−15

@@ -44,7 +44,6 @@ You can use this combinator to protect an API as follows:

4444

4545module Authentication where

4646

47−import Control.Monad.Trans.Except (ExceptT, throwE)

4847import Data.Aeson (ToJSON)

4948import Data.ByteString (ByteString)

5049import Data.Map (Map, fromList)

@@ -59,13 +58,14 @@ import Servant.API ((:<|>) ((:<|>)), (:>), BasicAuth,

5958 Get, JSON)

6059import Servant.API.BasicAuth (BasicAuthData (BasicAuthData))

6160import Servant.API.Experimental.Auth (AuthProtect)

61+import Servant (throwError)

6262import Servant.Server (BasicAuthCheck (BasicAuthCheck),

6363 BasicAuthResult( Authorized

6464 , Unauthorized

6565 ),

6666 Context ((:.), EmptyContext),

6767 err401, err403, errBody, Server,

68− ServantErr, serveWithContext)

68+ serveWithContext, Handler)

6969import Servant.Server.Experimental.Auth (AuthHandler, AuthServerData,

7070 mkAuthHandler)

7171import Servant.Server.Experimental.Auth()

@@ -117,22 +117,22 @@ or dictated the structure of a response (e.g. a `Capture` param is pulled from

117117the request path). Now consider an API resource protected by basic

118118authentication. Once the required `WWW-Authenticate` header is checked, we need

119119to verify the username and password. But how? One solution would be to force an

120−API author to provide a function of type `BasicAuthData -> ExceptT ServantErr IO User`

120+API author to provide a function of type `BasicAuthData -> Handler User`

121121and servant should use this function to authenticate a request. Unfortunately

122122this didn't work prior to `0.5` because all of servant's machinery was

123123engineered around the idea that each combinator can extract information from

124124only the request. We cannot extract the function

125−`BasicAuthData -> ExceptT ServantErr IO User` from a request! Are we doomed?

125+`BasicAuthData -> Handler User` from a request! Are we doomed?

126126

127127Servant `0.5` introduced `Context` to handle this. The type machinery is beyond

128128the scope of this tutorial, but the idea is simple: provide some data to the

129129`serve` function, and that data is propagated to the functions that handle each

130130combinator. Using `Context`, we can supply a function of type

131−`BasicAuthData -> ExceptT ServantErr IO User` to the `BasicAuth` combinator

131+`BasicAuthData -> Handler User` to the `BasicAuth` combinator

132132handler. This will allow the handler to check authentication and return a `User`

133133to downstream handlers if successful.

134134

135−In practice we wrap `BasicAuthData -> ExceptT ServantErr IO` into a slightly

135+In practice we wrap `BasicAuthData -> Handler` into a slightly

136136different function to better capture the semantics of basic authentication:

137137

138138``` haskell ignore

@@ -173,7 +173,7 @@ And now we create the `Context` used by servant to find `BasicAuthCheck`:

173173```haskell

174174-- | We need to supply our handlers with the right Context. In this case,

175175-- Basic Authentication requires a Context Entry with the 'BasicAuthCheck' value

176−-- tagged with "foo-tag" This context is then supplied to 'server' and threaded

176+-- tagged with "foo-tag" This context is then supplied to 'server' and threaded

177177-- to the BasicAuth HasServer handlers.

178178basicAuthServerContext :: Context (BasicAuthCheck User ': '[])

179179basicAuthServerContext = authCheck :. EmptyContext

@@ -246,7 +246,7 @@ your feedback!

246246### What is Generalized Authentication?

247247

248248**TL;DR**: you throw a tagged `AuthProtect` combinator in front of the endpoints

249−you want protected and then supply a function `Request -> ExceptT IO ServantErr user`

249+you want protected and then supply a function `Request -> Handler user`

250250which we run anytime a request matches a protected endpoint. It precisely solves

251251the "I just need to protect these endpoints with a function that does some

252252complicated business logic" and nothing more. Behind the scenes we use a type

@@ -272,24 +272,24 @@ database = fromList [ ("key1", Account "Anne Briggs")

272272

273273-- | A method that, when given a password, will return a Account.

274274-- This is our bespoke (and bad) authentication logic.

275−lookupAccount :: ByteString -> ExceptT ServantErr IO Account

275+lookupAccount :: ByteString -> Handler Account

276276lookupAccount key = case Map.lookup key database of

277− Nothing -> throwE (err403 { errBody = "Invalid Cookie" })

277+ Nothing -> throwError (err403 { errBody = "Invalid Cookie" })

278278 Just usr -> return usr

279279```

280280

281281For generalized authentication, servant exposes the `AuthHandler` type,

282−which is used to wrap the `Request -> ExceptT IO ServantErr user` logic. Let's

282+which is used to wrap the `Request -> Handler user` logic. Let's

283283create a value of type `AuthHandler Request Account` using the above `lookupAccount`

284284method:

285285

286286```haskell

287−-- | The auth handler wraps a function from Request -> ExceptT ServantErr IO Account

287+-- | The auth handler wraps a function from Request -> Handler Account

288288-- we look for a Cookie and pass the value of the cookie to `lookupAccount`.

289289authHandler :: AuthHandler Request Account

290290authHandler =

291291 let handler req = case lookup "servant-auth-cookie" (requestHeaders req) of

292− Nothing -> throwE (err401 { errBody = "Missing auth header" })

292+ Nothing -> throwError (err401 { errBody = "Missing auth header" })

293293 Just authCookieKey -> lookupAccount authCookieKey

294294 in mkAuthHandler handler

295295```

@@ -329,7 +329,7 @@ We now construct the `Context` for our server, allowing us to instantiate a

329329value of type `Server AuthGenAPI`, in addition to the server value:

330330

331331```haskell

332−-- | The context that will be made available to request handlers. We supply the

332+-- | The context that will be made available to request handlers. We supply the

333333-- "cookie-auth"-tagged request handler defined above, so that the 'HasServer' instance

334334-- of 'AuthProtect' can extract the handler and run it on the request.

335335genAuthServerContext :: Context (AuthHandler Request Account ': '[])

@@ -379,7 +379,7 @@ forward:

3793792. choose a application-specific data type used by your server when

380380authentication is successful (in our case this was `User`).

3813813. Create a value of `AuthHandler Request User` which encapsulates the

382−authentication logic (`Request -> ExceptT IO ServantErr User`). This function

382+authentication logic (`Request -> Handler User`). This function

383383will be executed everytime a request matches a protected route.

3843844. Provide an instance of the `AuthServerData` type family, specifying your

385385application-specific data type returned when authentication is successful (in

doc/tutorial/Server.lhs+54−58

@@ -111,11 +111,11 @@ corresponding API type.

111111The first thing to know about the `Server` type family is that behind the

112112scenes it will drive the routing, letting you focus only on the business

113113logic. The second thing to know is that for each endpoint, your handlers will

114−by default run in the `ExceptT ServantErr IO` monad. This is overridable very

114+by default run in the `Handler` monad. This is overridable very

115115easily, as explained near the end of this guide. Third thing, the type of the

116116value returned in that monad must be the same as the second argument of the

117117HTTP method combinator used for the corresponding endpoint. In our case, it

118−means we must provide a handler of type `ExceptT ServantErr IO [User]`. Well,

118+means we must provide a handler of type `Handler [User]`. Well,

119119we have a monad, let's just `return` our list:

120120

121121``` haskell

@@ -269,15 +269,15 @@ server3 = position

269269 :<|> hello

270270 :<|> marketing

271271

272− where position :: Int -> Int -> ExceptT ServantErr IO Position

272+ where position :: Int -> Int -> Handler Position

273273 position x y = return (Position x y)

274274

275− hello :: Maybe String -> ExceptT ServantErr IO HelloMessage

275+ hello :: Maybe String -> Handler HelloMessage

276276 hello mname = return . HelloMessage $ case mname of

277277 Nothing -> "Hello, anonymous coward"

278278 Just n -> "Hello, " ++ n

279279

280− marketing :: ClientInfo -> ExceptT ServantErr IO Email

280+ marketing :: ClientInfo -> Handler Email

281281 marketing clientinfo = return (emailForClient clientinfo)

282282```

283283

@@ -307,7 +307,7 @@ $ curl -X POST -d '{"clientName":"Alp Mestanogullari", "clientEmail" : "alp@foo.

307307

308308For reference, here's a list of some combinators from **servant**:

309309

310− > - `Delete`, `Get`, `Patch`, `Post`, `Put`: these do not become arguments. They provide the return type of handlers, which usually is `ExceptT ServantErr IO <something>`.

310+ > - `Delete`, `Get`, `Patch`, `Post`, `Put`: these do not become arguments. They provide the return type of handlers, which usually is `Handler <something>`.

311311 > - `Capture "something" a` becomes an argument of type `a`.

312312 > - `QueryParam "something" a`, `Header "something" a` all become arguments of type `Maybe a`, because there might be no value at all specified by the client for these.

313313 > - `QueryFlag "something"` gets turned into an argument of type `Bool`.

@@ -601,11 +601,10 @@ $ curl -H 'Accept: text/html' http://localhost:8081/persons

601601# or just point your browser to http://localhost:8081/persons

602602```

603603

604−## The `ExceptT ServantErr IO` monad

604+## The `Handler` monad

605605

606−At the heart of the handlers is the monad they run in, namely `ExceptT

607−ServantErr IO`

608−([haddock documentation for `ExceptT`](http://hackage.haskell.org/package/mtl-2.2.1/docs/Control-Monad-Except.html#t:ExceptT)).

606+At the heart of the handlers is the monad they run in, namely `ExceptT ServantErr IO`

607+([haddock documentation for `ExceptT`](http://hackage.haskell.org/package/mtl-2.2.1/docs/Control-Monad-Except.html#t:ExceptT)), which is aliased as `Handler`.

609608One might wonder: why this monad? The answer is that it is the

610609simplest monad with the following properties:

611610

@@ -621,7 +620,7 @@ Let's recall some definitions.

621620newtype ExceptT e m a = ExceptT (m (Either e a))

622621```

623622

624−In short, this means that a handler of type `ExceptT ServantErr IO a` is simply

623+In short, this means that a handler of type `Handler a` is simply

625624equivalent to a computation of type `IO (Either ServantErr a)`, that is, an IO

626625action that either returns an error or a result.

627626

@@ -688,7 +687,7 @@ module. If you want to use these values but add a body or some headers, just

688687use record update syntax:

689688

690689``` haskell

691−failingHandler :: ExceptT ServantErr IO ()

690+failingHandler :: Handler ()

692691failingHandler = throwError myerr

693692

694693 where myerr :: ServantErr

@@ -810,7 +809,7 @@ type UserAPI3 = -- view the user with given userid, in JSON

810809 Capture "userid" Int :> Get '[JSON] User

811810

812811 :<|> -- delete the user with given userid. empty response

813− Capture "userid" Int :> Delete '[] ()

812+ Capture "userid" Int :> DeleteNoContent '[JSON] NoContent

814813```

815814

816815We can instead factor out the `userid`:

@@ -818,7 +817,7 @@ We can instead factor out the `userid`:

818817``` haskell

819818type UserAPI4 = Capture "userid" Int :>

820819 ( Get '[JSON] User

821− :<|> Delete '[] ()

820+ :<|> DeleteNoContent '[JSON] NoContent

822821 )

823822```

824823

@@ -826,11 +825,11 @@ However, you have to be aware that this has an effect on the type of the

826825corresponding `Server`:

827826

828827``` haskell ignore

829−Server UserAPI3 = (Int -> ExceptT ServantErr IO User)

830− :<|> (Int -> ExceptT ServantErr IO ())

828+Server UserAPI3 = (Int -> Handler User)

829+ :<|> (Int -> Handler NoContent)

831830

832−Server UserAPI4 = Int -> ( ExceptT ServantErr IO User

833− :<|> ExceptT ServantErr IO ()

831+Server UserAPI4 = Int -> ( Handler User

832+ :<|> Handler NoContent

834833 )

835834```

836835

@@ -842,10 +841,10 @@ computations in `ExceptT`, with no arguments. In other words:

842841server8 :: Server UserAPI3

843842server8 = getUser :<|> deleteUser

844843

845− where getUser :: Int -> ExceptT ServantErr IO User

844+ where getUser :: Int -> Handler User

846845 getUser _userid = error "..."

847846

848− deleteUser :: Int -> ExceptT ServantErr IO ()

847+ deleteUser :: Int -> Handler NoContent

849848 deleteUser _userid = error "..."

850849

851850-- notice how getUser and deleteUser

@@ -854,10 +853,10 @@ server8 = getUser :<|> deleteUser

854853server9 :: Server UserAPI4

855854server9 userid = getUser userid :<|> deleteUser userid

856855

857− where getUser :: Int -> ExceptT ServantErr IO User

856+ where getUser :: Int -> Handler User

858857 getUser = error "..."

859858

860− deleteUser :: Int -> ExceptT ServantErr IO ()

859+ deleteUser :: Int -> Handler NoContent

861860 deleteUser = error "..."

862861```

863862

@@ -876,13 +875,13 @@ type API1 = "users" :>

876875-- we factor out the Request Body

877876type API2 = ReqBody '[JSON] User :>

878877 ( Get '[JSON] User -- just display the same user back, don't register it

879− :<|> Post '[JSON] () -- register the user. empty response

878+ :<|> PostNoContent '[JSON] NoContent -- register the user. empty response

880879 )

881880

882881-- we factor out a Header

883882type API3 = Header "Authorization" Token :>

884883 ( Get '[JSON] SecretData -- get some secret data, if authorized

885− :<|> ReqBody '[JSON] SecretData :> Post '[] () -- add some secret data, if authorized

884+ :<|> ReqBody '[JSON] SecretData :> PostNoContent '[JSON] NoContent -- add some secret data, if authorized

886885 )

887886

888887newtype Token = Token ByteString

@@ -895,44 +894,44 @@ API type only at the end.

895894``` haskell

896895type UsersAPI =

897896 Get '[JSON] [User] -- list users

898− :<|> ReqBody '[JSON] User :> Post '[] () -- add a user

897+ :<|> ReqBody '[JSON] User :> PostNoContent '[JSON] NoContent -- add a user

899898 :<|> Capture "userid" Int :>

900899 ( Get '[JSON] User -- view a user

901− :<|> ReqBody '[JSON] User :> Put '[] () -- update a user

902− :<|> Delete '[] () -- delete a user

900+ :<|> ReqBody '[JSON] User :> PutNoContent '[JSON] NoContent -- update a user

901+ :<|> DeleteNoContent '[JSON] NoContent -- delete a user

903902 )

904903

905904usersServer :: Server UsersAPI

906905usersServer = getUsers :<|> newUser :<|> userOperations

907906

908− where getUsers :: ExceptT ServantErr IO [User]

907+ where getUsers :: Handler [User]

909908 getUsers = error "..."

910909

911− newUser :: User -> ExceptT ServantErr IO ()

910+ newUser :: User -> Handler NoContent

912911 newUser = error "..."

913912

914913 userOperations userid =

915914 viewUser userid :<|> updateUser userid :<|> deleteUser userid

916915

917916 where

918− viewUser :: Int -> ExceptT ServantErr IO User

917+ viewUser :: Int -> Handler User

919918 viewUser = error "..."

920919

921− updateUser :: Int -> User -> ExceptT ServantErr IO ()

920+ updateUser :: Int -> User -> Handler NoContent

922921 updateUser = error "..."

923922

924− deleteUser :: Int -> ExceptT ServantErr IO ()

923+ deleteUser :: Int -> Handler NoContent

925924 deleteUser = error "..."

926925```

927926

928927``` haskell

929928type ProductsAPI =

930929 Get '[JSON] [Product] -- list products

931− :<|> ReqBody '[JSON] Product :> Post '[] () -- add a product

930+ :<|> ReqBody '[JSON] Product :> PostNoContent '[JSON] NoContent -- add a product

932931 :<|> Capture "productid" Int :>

933932 ( Get '[JSON] Product -- view a product

934− :<|> ReqBody '[JSON] Product :> Put '[] () -- update a product

935− :<|> Delete '[] () -- delete a product

933+ :<|> ReqBody '[JSON] Product :> PutNoContent '[JSON] NoContent -- update a product

934+ :<|> DeleteNoContent '[JSON] NoContent -- delete a product

936935 )

937936

938937data Product = Product { productId :: Int }

@@ -940,23 +939,23 @@ data Product = Product { productId :: Int }

940939productsServer :: Server ProductsAPI

941940productsServer = getProducts :<|> newProduct :<|> productOperations

942941

943− where getProducts :: ExceptT ServantErr IO [Product]

942+ where getProducts :: Handler [Product]

944943 getProducts = error "..."

945944

946− newProduct :: Product -> ExceptT ServantErr IO ()

945+ newProduct :: Product -> Handler NoContent

947946 newProduct = error "..."

948947

949948 productOperations productid =

950949 viewProduct productid :<|> updateProduct productid :<|> deleteProduct productid

951950

952951 where

953− viewProduct :: Int -> ExceptT ServantErr IO Product

952+ viewProduct :: Int -> Handler Product

954953 viewProduct = error "..."

955954

956− updateProduct :: Int -> Product -> ExceptT ServantErr IO ()

955+ updateProduct :: Int -> Product -> Handler NoContent

957956 updateProduct = error "..."

958957

959− deleteProduct :: Int -> ExceptT ServantErr IO ()

958+ deleteProduct :: Int -> Handler NoContent

960959 deleteProduct = error "..."

961960```

962961

@@ -976,20 +975,20 @@ abstract that away:

976975-- indexed by values of type 'i'

977976type APIFor a i =

978977 Get '[JSON] [a] -- list 'a's

979− :<|> ReqBody '[JSON] a :> Post '[] () -- add an 'a'

978+ :<|> ReqBody '[JSON] a :> PostNoContent '[JSON] NoContent -- add an 'a'

980979 :<|> Capture "id" i :>

981980 ( Get '[JSON] a -- view an 'a' given its "identifier" of type 'i'

982− :<|> ReqBody '[JSON] a :> Put '[] () -- update an 'a'

983− :<|> Delete '[] () -- delete an 'a'

981+ :<|> ReqBody '[JSON] a :> PutNoContent '[JSON] NoContent -- update an 'a'

982+ :<|> DeleteNoContent '[JSON] NoContent -- delete an 'a'

984983 )

985984

986985-- Build the appropriate 'Server'

987986-- given the handlers of the right type.

988−serverFor :: ExceptT ServantErr IO [a] -- handler for listing of 'a's

989− -> (a -> ExceptT ServantErr IO ()) -- handler for adding an 'a'

990− -> (i -> ExceptT ServantErr IO a) -- handler for viewing an 'a' given its identifier of type 'i'

991− -> (i -> a -> ExceptT ServantErr IO ()) -- updating an 'a' with given id

992− -> (i -> ExceptT ServantErr IO ()) -- deleting an 'a' given its id

987+serverFor :: Handler [a] -- handler for listing of 'a's

988+ -> (a -> Handler NoContent) -- handler for adding an 'a'

989+ -> (i -> Handler a) -- handler for viewing an 'a' given its identifier of type 'i'

990+ -> (i -> a -> Handler NoContent) -- updating an 'a' with given id

991+ -> (i -> Handler NoContent) -- deleting an 'a' given its id

993992 -> Server (APIFor a i)

994993serverFor = error "..."

995994-- implementation left as an exercise. contact us on IRC

@@ -998,12 +997,11 @@ serverFor = error "..."

998997

999998## Using another monad for your handlers

1000999

1001−Remember how `Server` turns combinators for HTTP methods into `ExceptT

1002−ServantErr IO`? Well, actually, there's more to that. `Server` is actually a

1000+Remember how `Server` turns combinators for HTTP methods into `Handler`? Well, actually, there's more to that. `Server` is actually a

10031001simple type synonym.

10041002

10051003``` haskell ignore

1006−type Server api = ServerT api (ExceptT ServantErr IO)

1004+type Server api = ServerT api Handler

10071005```

10081006

10091007`ServerT` is the actual type family that computes the required types for the

@@ -1036,12 +1034,11 @@ listToMaybeNat = Nat listToMaybe -- from Data.Maybe

10361034

10371035(`Nat` comes from "natural transformation", in case you're wondering.)

10381036

1039−So if you want to write handlers using another monad/type than `ExceptT

1040−ServantErr IO`, say the `Reader String` monad, the first thing you have to

1037+So if you want to write handlers using another monad/type than `Handler`, say the `Reader String` monad, the first thing you have to

10411038prepare is a function:

10421039

10431040``` haskell ignore

1044−readerToHandler :: Reader String :~> ExceptT ServantErr IO

1041+readerToHandler :: Reader String :~> Handler

10451042```

10461043

10471044Let's start with `readerToHandler'`. We obviously have to run the `Reader`

@@ -1050,10 +1047,10 @@ from that and can then just `return` it into `ExceptT`. We can then just wrap

10501047that function with the `Nat` constructor to make it have the fancier type.

10511048

10521049``` haskell

1053−readerToHandler' :: forall a. Reader String a -> ExceptT ServantErr IO a

1050+readerToHandler' :: forall a. Reader String a -> Handler a

10541051readerToHandler' r = return (runReader r "hi")

10551052

1056−readerToHandler :: Reader String :~> ExceptT ServantErr IO

1053+readerToHandler :: Reader String :~> Handler

10571054readerToHandler = Nat readerToHandler'

10581055```

10591056

@@ -1077,8 +1074,7 @@ readerServerT = a :<|> b

10771074```

10781075

10791076We unfortunately can't use `readerServerT` as an argument of `serve`, because

1080−`serve` wants a `Server ReaderAPI`, i.e., with handlers running in `ExceptT

1081−ServantErr IO`. But there's a simple solution to this.

1077+`serve` wants a `Server ReaderAPI`, i.e., with handlers running in `Handler`. But there's a simple solution to this.

10821078

10831079### Enter `enter`

10841080

doc/tutorial/index.rst+2−8

@@ -3,14 +3,8 @@ Tutorial

44This is an introductory tutorial to **servant**.

6−.. note::

7− This tutorial is for the latest version of servant. The tutorial for

8− servant-0.4 can be viewed

9− `here <https://haskell-servant.github.io/tutorial/>`_.

10−

11−(Any comments, issues or feedback about the tutorial can be handled

12−through

13−`servant's issue tracker <http://github.com/haskell-servant/servant/issues>`_.)

6+(Any comments, issues or feedback about the tutorial can be submitted

7+to `servant's issue tracker <http://github.com/haskell-servant/servant/issues>`_.)

148

159

1610.. toctree::

doc/tutorial/tutorial.cabal+9−13

@@ -1,7 +1,7 @@

11name: tutorial

2−version: 0.6

2+version: 0.7.1

33synopsis: The servant tutorial

4−homepage: http://haskell-servant.github.io/

4+homepage: http://haskell-servant.readthedocs.org/

55license: BSD3

66license-file: LICENSE

77author: Servant Contributors

@@ -25,11 +25,11 @@ library

2525 , directory

2626 , blaze-markup

2727 , containers

28− , servant == 0.6.*

29− , servant-server == 0.6.*

30− , servant-client == 0.6.*

31− , servant-docs == 0.6.*

32− , servant-js == 0.6.*

28+ , servant == 0.7.*

29+ , servant-server == 0.7.*

30+ , servant-client == 0.7.*

31+ , servant-docs == 0.7.*

32+ , servant-js == 0.7.*

3333 , warp

3434 , http-media

3535 , lucid

@@ -46,15 +46,11 @@ library

4646 , markdown-unlit >= 0.4

4747 , http-client

4848 default-language: Haskell2010

49− ghc-options: -Wall -Werror -pgmL markdown-unlit

50− -- to silence aeson-0.10 warnings:

51− ghc-options: -fno-warn-missing-methods

52− ghc-options: -fno-warn-name-shadowing

49+ ghc-options: -Wall -pgmL markdown-unlit

5350

5451test-suite spec

5552 type: exitcode-stdio-1.0

56− ghc-options:

57− -Wall -fno-warn-name-shadowing -fno-warn-missing-signatures

53+ ghc-options: -Wall

5854 default-language: Haskell2010

5955 hs-source-dirs: test

6056 main-is: Spec.hs

scripts/test-stack.shnew file+11

@@ -0,0 +1,11 @@

1+#!/usr/bin/env bash

3+set -o nounset

4+set -o errexit

6+for stack_file in stack*.yaml ; do

7+ echo testing $stack_file...

8+ export STACK_YAML=$stack_file

9+ stack setup

10+ stack test --fast --ghc-options="-Werror"

11+done

scripts/upload.hs+1−1

@@ -11,4 +11,4 @@ main :: IO ()

1111main = do

1212 sources <- words <$> readFile "sources.txt"

1313 forM_ sources $ \ source -> do

14− callCommand ("stack upload " ++ source)

14+ callCommand ("stack upload --no-signature " ++ source)

servant-blaze/LICENSEdeleted−30

@@ -1,30 +0,0 @@

2−

4−

5−Redistribution and use in source and binary forms, with or without

6−modification, are permitted provided that the following conditions are met:

7−

8− * Redistributions of source code must retain the above copyright

9− notice, this list of conditions and the following disclaimer.

10−

11− * Redistributions in binary form must reproduce the above

12− copyright notice, this list of conditions and the following

13− disclaimer in the documentation and/or other materials provided

14− with the distribution.

15−

16− * Neither the name of Julian K. Arni nor the names of other

17− contributors may be used to endorse or promote products derived

18− from this software without specific prior written permission.

19−

20−THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

21−"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

22−LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

23−A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

24−OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

25−SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

26−LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

27−DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

28−THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

29−(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

30−OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

servant-blaze/Setup.hsdeleted−2

@@ -1,2 +0,0 @@

1−import Distribution.Simple

2−main = defaultMain

servant-blaze/include/overlapping-compat.hdeleted−8

@@ -1,8 +0,0 @@

1−#if __GLASGOW_HASKELL__ >= 710

2−#define OVERLAPPABLE_ {-# OVERLAPPABLE #-}

3−#define OVERLAPPING_ {-# OVERLAPPING #-}

4−#else

5−{-# LANGUAGE OverlappingInstances #-}

6−#define OVERLAPPABLE_

7−#define OVERLAPPING_

8−#endif

servant-blaze/servant-blaze.cabaldeleted−33

@@ -1,33 +0,0 @@

1−-- Initial servant-blaze.cabal generated by cabal init. For further

2−-- documentation, see http://haskell.org/cabal/users-guide/

3−

4−name: servant-blaze

5−version: 0.6

6−synopsis: Blaze-html support for servant

7−-- description:

8−homepage: http://haskell-servant.github.io/

9−license: BSD3

10−license-file: LICENSE

11−author: Servant Contributors

12−maintainer: haskell-servant-maintainers@googlegroups.com

13−copyright: 2015-2016 Servant Contributors

14−category: Web

15−build-type: Simple

16−extra-source-files: include/*.h

17−cabal-version: >=1.10

18−bug-reports: http://github.com/haskell-servant/servant/issues

19−source-repository head

20− type: git

21− location: http://github.com/haskell-servant/servant.git

22−

23−library

24− exposed-modules: Servant.HTML.Blaze

25− -- other-modules:

26− -- other-extensions:

27− build-depends: base >=4.7 && <5

28− , servant == 0.6.*

29− , http-media

30− , blaze-html

31− hs-source-dirs: src

32− default-language: Haskell2010

33− include-dirs: include

servant-blaze/src/Servant/HTML/Blaze.hsdeleted−35

@@ -1,35 +0,0 @@

1−{-# LANGUAGE CPP #-}

2−{-# LANGUAGE DeriveDataTypeable #-}

3−{-# LANGUAGE FlexibleInstances #-}

4−{-# LANGUAGE MultiParamTypeClasses #-}

5−{-# LANGUAGE OverloadedStrings #-}

6−

7−#include "overlapping-compat.h"

8−-- | An @HTML@ empty data type with `MimeRender` instances for @blaze-html@'s

9−-- `ToMarkup` class and `Html` datatype.

10−-- You should only need to import this module for it's instances and the

11−-- `HTML` datatype.:

12−--

13−-- >>> type Eg = Get '[HTML] a

14−--

15−-- Will then check that @a@ has a `ToMarkup` instance, or is `Html`.

16−module Servant.HTML.Blaze where

17−

18−import Data.Typeable (Typeable)

19−import qualified Network.HTTP.Media as M

20−import Servant.API (Accept (..), MimeRender (..))

21−import Text.Blaze.Html (Html, ToMarkup, toHtml)

22−import Text.Blaze.Html.Renderer.Utf8 (renderHtml)

23−

24−data HTML deriving Typeable

25−

26−-- | @text/html;charset=utf-8@

27−instance Accept HTML where

28− contentType _ = "text" M.// "html" M./: ("charset", "utf-8")

29−

30−instance OVERLAPPABLE_ ToMarkup a => MimeRender HTML a where

31− mimeRender _ = renderHtml . toHtml

32−

33−instance OVERLAPPING_ MimeRender HTML Html where

34− mimeRender _ = renderHtml

35−

servant-blaze/tinc.yamldeleted−3

@@ -1,3 +0,0 @@

1−dependencies:

2− - name: servant

3− path: ../servant

servant-cassava/LICENSEdeleted−30