5effdfd · typeable/servant

git.iko.soy/typeable/servant

on master help sign in

Rename type variables 'layout' and 'sublayout' to 'api'

5effdfdSönke Hahn10 years ago

servant-client/src/Servant/Client.hs+42−42

compare with master

unifiedsplit

@@ -57,15 +57,15 @@ import Servant.Common.Req

57-- > getAllBooks :: Manager -> BaseUrl -> ClientM [Book]

58-- > postNewBook :: Book -> Manager -> BaseUrl -> ClientM Book

59-- > (getAllBooks :<|> postNewBook) = client myApi

60−client :: HasClient layout => Proxy layout -> Client layout

60+client :: HasClient api => Proxy api -> Client api

61client p = clientWithRoute p defReq

63-- | This class lets us define how each API combinator

64-- influences the creation of an HTTP request. It's mostly

65-- an internal class, you can just use 'client'.

66−class HasClient layout where

66+class HasClient api where

67− type Client layout :: *

67+ type Client api :: *

68− clientWithRoute :: Proxy layout -> Req -> Client layout

68+ clientWithRoute :: Proxy api -> Req -> Client api

71-- | A client querying function for @a ':<|>' b@ will actually hand you

@@ -106,14 +106,14 @@ instance (HasClient a, HasClient b) => HasClient (a :<|> b) where

106-- > getBook :: Text -> Manager -> BaseUrl -> ClientM Book

107-- > getBook = client myApi

108-- > -- then you can just use "getBook" to query that endpoint

109−instance (KnownSymbol capture, ToHttpApiData a, HasClient sublayout)

109+instance (KnownSymbol capture, ToHttpApiData a, HasClient api)

110− => HasClient (Capture capture a :> sublayout) where

110+ => HasClient (Capture capture a :> api) where

111

112− type Client (Capture capture a :> sublayout) =

112+ type Client (Capture capture a :> api) =

113− a -> Client sublayout

113+ a -> Client api

114

115 clientWithRoute Proxy req val =

116− clientWithRoute (Proxy :: Proxy sublayout)

116+ clientWithRoute (Proxy :: Proxy api)

117 (appendToPath p req)

118

119 where p = unpack (toUrlPiece val)

@@ -186,14 +186,14 @@ instance OVERLAPPING_

186-- > viewReferer = client myApi

187-- > -- then you can just use "viewRefer" to query that endpoint

188-- > -- specifying Nothing or e.g Just "http://haskell.org/" as arguments

189−instance (KnownSymbol sym, ToHttpApiData a, HasClient sublayout)

189+instance (KnownSymbol sym, ToHttpApiData a, HasClient api)

190− => HasClient (Header sym a :> sublayout) where

190+ => HasClient (Header sym a :> api) where

191

192− type Client (Header sym a :> sublayout) =

192+ type Client (Header sym a :> api) =

193− Maybe a -> Client sublayout

193+ Maybe a -> Client api

194

195 clientWithRoute Proxy req mval =

196− clientWithRoute (Proxy :: Proxy sublayout)

196+ clientWithRoute (Proxy :: Proxy api)

197 (maybe req

198 (\value -> Servant.Common.Req.addHeader hname value req)

199 mval

@@ -203,14 +203,14 @@ instance (KnownSymbol sym, ToHttpApiData a, HasClient sublayout)

203

204-- | Using a 'HttpVersion' combinator in your API doesn't affect the client

205-- functions.

206−instance HasClient sublayout

206+instance HasClient api

207− => HasClient (HttpVersion :> sublayout) where

207+ => HasClient (HttpVersion :> api) where

208

209− type Client (HttpVersion :> sublayout) =

209+ type Client (HttpVersion :> api) =

210− Client sublayout

210+ Client api

211

212 clientWithRoute Proxy =

213− clientWithRoute (Proxy :: Proxy sublayout)

213+ clientWithRoute (Proxy :: Proxy api)

214

215-- | If you use a 'QueryParam' in one of your endpoints in your API,

216-- the corresponding querying function will automatically take

@@ -237,15 +237,15 @@ instance HasClient sublayout

237-- > -- then you can just use "getBooksBy" to query that endpoint.

238-- > -- 'getBooksBy Nothing' for all books

239-- > -- 'getBooksBy (Just "Isaac Asimov")' to get all books by Isaac Asimov

240−instance (KnownSymbol sym, ToHttpApiData a, HasClient sublayout)

240+instance (KnownSymbol sym, ToHttpApiData a, HasClient api)

241− => HasClient (QueryParam sym a :> sublayout) where

241+ => HasClient (QueryParam sym a :> api) where

242

243− type Client (QueryParam sym a :> sublayout) =

243+ type Client (QueryParam sym a :> api) =

244− Maybe a -> Client sublayout

244+ Maybe a -> Client api

245

246 -- if mparam = Nothing, we don't add it to the query string

247 clientWithRoute Proxy req mparam =

248− clientWithRoute (Proxy :: Proxy sublayout)

248+ clientWithRoute (Proxy :: Proxy api)

249 (maybe req

250 (flip (appendToQueryString pname) req . Just)

251 mparamText

@@ -282,14 +282,14 @@ instance (KnownSymbol sym, ToHttpApiData a, HasClient sublayout)

282-- > -- 'getBooksBy []' for all books

283-- > -- 'getBooksBy ["Isaac Asimov", "Robert A. Heinlein"]'

284-- > -- to get all books by Asimov and Heinlein

285−instance (KnownSymbol sym, ToHttpApiData a, HasClient sublayout)

285+instance (KnownSymbol sym, ToHttpApiData a, HasClient api)

286− => HasClient (QueryParams sym a :> sublayout) where

286+ => HasClient (QueryParams sym a :> api) where

287

288− type Client (QueryParams sym a :> sublayout) =

288+ type Client (QueryParams sym a :> api) =

289− [a] -> Client sublayout

289+ [a] -> Client api

290

291 clientWithRoute Proxy req paramlist =

292− clientWithRoute (Proxy :: Proxy sublayout)

292+ clientWithRoute (Proxy :: Proxy api)

293 (foldl' (\ req' -> maybe req' (flip (appendToQueryString pname) req' . Just))

294 req

295 paramlist'

@@ -320,14 +320,14 @@ instance (KnownSymbol sym, ToHttpApiData a, HasClient sublayout)

320-- > -- then you can just use "getBooks" to query that endpoint.

321-- > -- 'getBooksBy False' for all books

322-- > -- 'getBooksBy True' to only get _already published_ books

323−instance (KnownSymbol sym, HasClient sublayout)

323+instance (KnownSymbol sym, HasClient api)

324− => HasClient (QueryFlag sym :> sublayout) where

324+ => HasClient (QueryFlag sym :> api) where

325

326− type Client (QueryFlag sym :> sublayout) =

326+ type Client (QueryFlag sym :> api) =

327− Bool -> Client sublayout

327+ Bool -> Client api

328

329 clientWithRoute Proxy req flag =

330− clientWithRoute (Proxy :: Proxy sublayout)

330+ clientWithRoute (Proxy :: Proxy api)

331 (if flag

332 then appendToQueryString paramname Nothing req

333 else req

@@ -364,14 +364,14 @@ instance HasClient Raw where

364-- > addBook :: Book -> Manager -> BaseUrl -> ClientM Book

365-- > addBook = client myApi

366-- > -- then you can just use "addBook" to query that endpoint

367−instance (MimeRender ct a, HasClient sublayout)

367+instance (MimeRender ct a, HasClient api)

368− => HasClient (ReqBody (ct ': cts) a :> sublayout) where

368+ => HasClient (ReqBody (ct ': cts) a :> api) where

369

370− type Client (ReqBody (ct ': cts) a :> sublayout) =

370+ type Client (ReqBody (ct ': cts) a :> api) =

371− a -> Client sublayout

371+ a -> Client api

372

373 clientWithRoute Proxy req body =

374− clientWithRoute (Proxy :: Proxy sublayout)

374+ clientWithRoute (Proxy :: Proxy api)

375 (let ctProxy = Proxy :: Proxy ct

376 in setRQBody (mimeRender ctProxy body)

377 (contentType ctProxy)

@@ -379,11 +379,11 @@ instance (MimeRender ct a, HasClient sublayout)

379 )

380

381-- | Make the querying function append @path@ to the request path.

382−instance (KnownSymbol path, HasClient sublayout) => HasClient (path :> sublayout) where

382+instance (KnownSymbol path, HasClient api) => HasClient (path :> api) where

383− type Client (path :> sublayout) = Client sublayout

383+ type Client (path :> api) = Client api

384

385 clientWithRoute Proxy req =

386− clientWithRoute (Proxy :: Proxy sublayout)

386+ clientWithRoute (Proxy :: Proxy api)

387 (appendToPath p req)

388

389 where p = symbolVal (Proxy :: Proxy path)

servant-docs/src/Servant/Docs/Internal.hs+53−53

@@ -163,7 +163,7 @@ data DocNote = DocNote

163--

164-- These are intended to be built using extraInfo.

165-- Multiple ExtraInfo may be combined with the monoid instance.

166−newtype ExtraInfo layout = ExtraInfo (HashMap Endpoint Action)

166+newtype ExtraInfo api = ExtraInfo (HashMap Endpoint Action)

167instance Monoid (ExtraInfo a) where

168 mempty = ExtraInfo mempty

169 ExtraInfo a `mappend` ExtraInfo b =

@@ -300,11 +300,11 @@ makeLenses ''Action

300-- default way to create documentation.

301--

302-- prop> docs == docsWithOptions defaultDocOptions

303−docs :: HasDocs layout => Proxy layout -> API

303+docs :: HasDocs api => Proxy api -> API

304docs p = docsWithOptions p defaultDocOptions

305

306-- | Generate the docs for a given API that implements 'HasDocs'.

307−docsWithOptions :: HasDocs layout => Proxy layout -> DocOptions -> API

307+docsWithOptions :: HasDocs api => Proxy api -> DocOptions -> API

308docsWithOptions p = docsFor p (defEndpoint, defAction)

309

310-- | Closed type family, check if endpoint is exactly within API.

@@ -316,7 +316,7 @@ type family IsIn (endpoint :: *) (api :: *) :: Constraint where

316 IsIn (e :> sa) (e :> sb) = IsIn sa sb

317 IsIn e e = ()

318

319−-- | Create an 'ExtraInfo' that is garunteed to be within the given API layout.

319+-- | Create an 'ExtraInfo' that is guaranteed to be within the given API layout.

320--

321-- The safety here is to ensure that you only add custom documentation to an

322-- endpoint that actually exists within your API.

@@ -329,8 +329,8 @@ type family IsIn (endpoint :: *) (api :: *) :: Constraint where

329-- > , DocNote "Second secton" ["And some more"]

330-- > ]

331

332−extraInfo :: (IsIn endpoint layout, HasLink endpoint, HasDocs endpoint)

332+extraInfo :: (IsIn endpoint api, HasLink endpoint, HasDocs endpoint)

333− => Proxy endpoint -> Action -> ExtraInfo layout

333+ => Proxy endpoint -> Action -> ExtraInfo api

334extraInfo p action =

335 let api = docsFor p (defEndpoint, defAction) defaultDocOptions

336 -- Assume one endpoint, HasLink constraint means that we should only ever

@@ -349,7 +349,7 @@ extraInfo p action =

349-- 'extraInfo'.

350--

351-- If you only want to add an introduction, use 'docsWithIntros'.

352−docsWith :: HasDocs layout => DocOptions -> [DocIntro] -> ExtraInfo layout -> Proxy layout -> API

352+docsWith :: HasDocs api => DocOptions -> [DocIntro] -> ExtraInfo api -> Proxy api -> API

353docsWith opts intros (ExtraInfo endpoints) p =

354 docsWithOptions p opts

355 & apiIntros <>~ intros

@@ -358,13 +358,13 @@ docsWith opts intros (ExtraInfo endpoints) p =

358

359-- | Generate the docs for a given API that implements 'HasDocs' with with any

360-- number of introduction(s)

361−docsWithIntros :: HasDocs layout => [DocIntro] -> Proxy layout -> API

361+docsWithIntros :: HasDocs api => [DocIntro] -> Proxy api -> API

362docsWithIntros intros = docsWith defaultDocOptions intros mempty

363

364-- | The class that abstracts away the impact of API combinators

365-- on documentation generation.

366−class HasDocs layout where

366+class HasDocs api where

367− docsFor :: Proxy layout -> (Endpoint, Action) -> DocOptions -> API

367+ docsFor :: Proxy api -> (Endpoint, Action) -> DocOptions -> API

368

369-- | The class that lets us display a sample input or output in the supported

370-- content-types when generating documentation for endpoints that either:

@@ -675,26 +675,26 @@ markdown api = unlines $

675-- | The generated docs for @a ':<|>' b@ just appends the docs

676-- for @a@ with the docs for @b@.

677instance OVERLAPPABLE_

678− (HasDocs layout1, HasDocs layout2)

678+ (HasDocs a, HasDocs b)

679− => HasDocs (layout1 :<|> layout2) where

679+ => HasDocs (a :<|> b) where

680

681 docsFor Proxy (ep, action) = docsFor p1 (ep, action) <> docsFor p2 (ep, action)

682

683− where p1 :: Proxy layout1

683+ where p1 :: Proxy a

684 p1 = Proxy

685

686− p2 :: Proxy layout2

686+ p2 :: Proxy b

687 p2 = Proxy

688

689-- | @"books" :> 'Capture' "isbn" Text@ will appear as

690-- @/books/:isbn@ in the docs.

691−instance (KnownSymbol sym, ToCapture (Capture sym a), HasDocs sublayout)

691+instance (KnownSymbol sym, ToCapture (Capture sym a), HasDocs api)

692− => HasDocs (Capture sym a :> sublayout) where

692+ => HasDocs (Capture sym a :> api) where

693

694 docsFor Proxy (endpoint, action) =

695− docsFor sublayoutP (endpoint', action')

695+ docsFor subApiP (endpoint', action')

696

697− where sublayoutP = Proxy :: Proxy sublayout

697+ where subApiP = Proxy :: Proxy api

698 captureP = Proxy :: Proxy (Capture sym a)

699

700 action' = over captures (|> toCapture captureP) action

@@ -736,43 +736,43 @@ instance OVERLAPPING_

736 status = fromInteger $ natVal (Proxy :: Proxy status)

737 p = Proxy :: Proxy a

738

739−instance (KnownSymbol sym, HasDocs sublayout)

739+instance (KnownSymbol sym, HasDocs api)

740− => HasDocs (Header sym a :> sublayout) where

740+ => HasDocs (Header sym a :> api) where

741 docsFor Proxy (endpoint, action) =

742− docsFor sublayoutP (endpoint, action')

742+ docsFor subApiP (endpoint, action')

743

744− where sublayoutP = Proxy :: Proxy sublayout

744+ where subApiP = Proxy :: Proxy api

745 action' = over headers (|> headername) action

746 headername = T.pack $ symbolVal (Proxy :: Proxy sym)

747

748−instance (KnownSymbol sym, ToParam (QueryParam sym a), HasDocs sublayout)

748+instance (KnownSymbol sym, ToParam (QueryParam sym a), HasDocs api)

749− => HasDocs (QueryParam sym a :> sublayout) where

749+ => HasDocs (QueryParam sym a :> api) where

750

751 docsFor Proxy (endpoint, action) =

752− docsFor sublayoutP (endpoint, action')

752+ docsFor subApiP (endpoint, action')

753

754− where sublayoutP = Proxy :: Proxy sublayout

754+ where subApiP = Proxy :: Proxy api

755 paramP = Proxy :: Proxy (QueryParam sym a)

756 action' = over params (|> toParam paramP) action

757

758−instance (KnownSymbol sym, ToParam (QueryParams sym a), HasDocs sublayout)

758+instance (KnownSymbol sym, ToParam (QueryParams sym a), HasDocs api)

759− => HasDocs (QueryParams sym a :> sublayout) where

759+ => HasDocs (QueryParams sym a :> api) where

760

761 docsFor Proxy (endpoint, action) =

762− docsFor sublayoutP (endpoint, action')

762+ docsFor subApiP (endpoint, action')

763

764− where sublayoutP = Proxy :: Proxy sublayout

764+ where subApiP = Proxy :: Proxy api

765 paramP = Proxy :: Proxy (QueryParams sym a)

766 action' = over params (|> toParam paramP) action

767

768

769−instance (KnownSymbol sym, ToParam (QueryFlag sym), HasDocs sublayout)

769+instance (KnownSymbol sym, ToParam (QueryFlag sym), HasDocs api)

770− => HasDocs (QueryFlag sym :> sublayout) where

770+ => HasDocs (QueryFlag sym :> api) where

771

772 docsFor Proxy (endpoint, action) =

773− docsFor sublayoutP (endpoint, action')

773+ docsFor subApiP (endpoint, action')

774

775− where sublayoutP = Proxy :: Proxy sublayout

775+ where subApiP = Proxy :: Proxy api

776 paramP = Proxy :: Proxy (QueryFlag sym)

777 action' = over params (|> toParam paramP) action

778

@@ -785,49 +785,49 @@ instance HasDocs Raw where

785-- example data. However, there's no reason to believe that the instances of

786-- 'AllMimeUnrender' and 'AllMimeRender' actually agree (or to suppose that

787-- both are even defined) for any particular type.

788−instance (ToSample a, AllMimeRender (ct ': cts) a, HasDocs sublayout)

788+instance (ToSample a, AllMimeRender (ct ': cts) a, HasDocs api)

789− => HasDocs (ReqBody (ct ': cts) a :> sublayout) where

789+ => HasDocs (ReqBody (ct ': cts) a :> api) where

790

791 docsFor Proxy (endpoint, action) =

792− docsFor sublayoutP (endpoint, action')

792+ docsFor subApiP (endpoint, action')

793

794− where sublayoutP = Proxy :: Proxy sublayout

794+ where subApiP = Proxy :: Proxy api

795 action' = action & rqbody .~ sampleByteString t p

796 & rqtypes .~ allMime t

797 t = Proxy :: Proxy (ct ': cts)

798 p = Proxy :: Proxy a

799

800−instance (KnownSymbol path, HasDocs sublayout) => HasDocs (path :> sublayout) where

800+instance (KnownSymbol path, HasDocs api) => HasDocs (path :> api) where

801

802 docsFor Proxy (endpoint, action) =

803− docsFor sublayoutP (endpoint', action)

803+ docsFor subApiP (endpoint', action)

804

805− where sublayoutP = Proxy :: Proxy sublayout

805+ where subApiP = Proxy :: Proxy api

806 endpoint' = endpoint & path <>~ [symbolVal pa]

807 pa = Proxy :: Proxy path

808

809−instance HasDocs sublayout => HasDocs (RemoteHost :> sublayout) where

809+instance HasDocs api => HasDocs (RemoteHost :> api) where

810 docsFor Proxy ep =

811− docsFor (Proxy :: Proxy sublayout) ep

811+ docsFor (Proxy :: Proxy api) ep

812

813−instance HasDocs sublayout => HasDocs (IsSecure :> sublayout) where

813+instance HasDocs api => HasDocs (IsSecure :> api) where

814 docsFor Proxy ep =

815− docsFor (Proxy :: Proxy sublayout) ep

815+ docsFor (Proxy :: Proxy api) ep

816

817−instance HasDocs sublayout => HasDocs (HttpVersion :> sublayout) where

817+instance HasDocs api => HasDocs (HttpVersion :> api) where

818 docsFor Proxy ep =

819− docsFor (Proxy :: Proxy sublayout) ep

819+ docsFor (Proxy :: Proxy api) ep

820

821−instance HasDocs sublayout => HasDocs (Vault :> sublayout) where

821+instance HasDocs api => HasDocs (Vault :> api) where

822 docsFor Proxy ep =

823− docsFor (Proxy :: Proxy sublayout) ep

823+ docsFor (Proxy :: Proxy api) ep

824

825−instance HasDocs sublayout => HasDocs (WithNamedContext name context sublayout) where

825+instance HasDocs api => HasDocs (WithNamedContext name context api) where

826− docsFor Proxy = docsFor (Proxy :: Proxy sublayout)

826+ docsFor Proxy = docsFor (Proxy :: Proxy api)

827

828−instance (ToAuthInfo (BasicAuth realm usr), HasDocs sublayout) => HasDocs (BasicAuth realm usr :> sublayout) where

828+instance (ToAuthInfo (BasicAuth realm usr), HasDocs api) => HasDocs (BasicAuth realm usr :> api) where

829 docsFor Proxy (endpoint, action) =

830− docsFor (Proxy :: Proxy sublayout) (endpoint, action')

830+ docsFor (Proxy :: Proxy api) (endpoint, action')

831 where

832 authProxy = Proxy :: Proxy (BasicAuth realm usr)

833 action' = over authInfo (|> toAuthInfo authProxy) action

servant-docs/src/Servant/Docs/Internal/Pretty.hs+2−2

@@ -29,12 +29,12 @@ instance ToJSON a => MimeRender PrettyJSON a where

29-- @

30-- 'docs' ('pretty' ('Proxy' :: 'Proxy' MyAPI))

31-- @

32−pretty :: Proxy layout -> Proxy (Pretty layout)

32+pretty :: Proxy api -> Proxy (Pretty api)

33pretty Proxy = Proxy

35-- | Replace all JSON content types with PrettyJSON.

36-- Kind-polymorphic so it can operate on kinds @*@ and @[*]@.

37−type family Pretty (layout :: k) :: k where

37+type family Pretty (api :: k) :: k where

38 Pretty (x :<|> y) = Pretty x :<|> Pretty y

39 Pretty (x :> y) = Pretty x :> Pretty y

40 Pretty (Get cs r) = Get (Pretty cs) r

servant-foreign/src/Servant/Foreign/Internal.hs+50−50

@@ -184,9 +184,9 @@ data NoTypes

184instance HasForeignType NoTypes () ftype where

185 typeFor _ _ _ = ()

186

187−class HasForeign lang ftype (layout :: *) where

187+class HasForeign lang ftype (api :: *) where

188− type Foreign ftype layout :: *

188+ type Foreign ftype api :: *

189− foreignFor :: Proxy lang -> Proxy ftype -> Proxy layout -> Req ftype -> Foreign ftype layout

189+ foreignFor :: Proxy lang -> Proxy ftype -> Proxy api -> Req ftype -> Foreign ftype api

190

191instance (HasForeign lang ftype a, HasForeign lang ftype b)

192 => HasForeign lang ftype (a :<|> b) where

@@ -196,12 +196,12 @@ instance (HasForeign lang ftype a, HasForeign lang ftype b)

196 foreignFor lang ftype (Proxy :: Proxy a) req

197 :<|> foreignFor lang ftype (Proxy :: Proxy b) req

198

199−instance (KnownSymbol sym, HasForeignType lang ftype t, HasForeign lang ftype sublayout)

199+instance (KnownSymbol sym, HasForeignType lang ftype t, HasForeign lang ftype api)

200− => HasForeign lang ftype (Capture sym t :> sublayout) where

200+ => HasForeign lang ftype (Capture sym t :> api) where

201− type Foreign ftype (Capture sym a :> sublayout) = Foreign ftype sublayout

201+ type Foreign ftype (Capture sym a :> api) = Foreign ftype api

202

203 foreignFor lang Proxy Proxy req =

204− foreignFor lang Proxy (Proxy :: Proxy sublayout) $

204+ foreignFor lang Proxy (Proxy :: Proxy api) $

205 req & reqUrl . path <>~ [Segment (Cap arg)]

206 & reqFuncName . _FunctionName %~ (++ ["by", str])

207 where

@@ -224,9 +224,9 @@ instance (Elem JSON list, HasForeignType lang ftype a, ReflectMethod method)

224 method = reflectMethod (Proxy :: Proxy method)

225 methodLC = toLower $ decodeUtf8 method

226

227−instance (KnownSymbol sym, HasForeignType lang ftype a, HasForeign lang ftype sublayout)

227+instance (KnownSymbol sym, HasForeignType lang ftype a, HasForeign lang ftype api)

228− => HasForeign lang ftype (Header sym a :> sublayout) where

228+ => HasForeign lang ftype (Header sym a :> api) where

229− type Foreign ftype (Header sym a :> sublayout) = Foreign ftype sublayout

229+ type Foreign ftype (Header sym a :> api) = Foreign ftype api

230

231 foreignFor lang Proxy Proxy req =

232 foreignFor lang Proxy subP $ req & reqHeaders <>~ [HeaderArg arg]

@@ -235,14 +235,14 @@ instance (KnownSymbol sym, HasForeignType lang ftype a, HasForeign lang ftype su

235 arg = Arg

236 { _argName = PathSegment hname

237 , _argType = typeFor lang (Proxy :: Proxy ftype) (Proxy :: Proxy a) }

238− subP = Proxy :: Proxy sublayout

238+ subP = Proxy :: Proxy api

239

240−instance (KnownSymbol sym, HasForeignType lang ftype a, HasForeign lang ftype sublayout)

240+instance (KnownSymbol sym, HasForeignType lang ftype a, HasForeign lang ftype api)

241− => HasForeign lang ftype (QueryParam sym a :> sublayout) where

241+ => HasForeign lang ftype (QueryParam sym a :> api) where

242− type Foreign ftype (QueryParam sym a :> sublayout) = Foreign ftype sublayout

242+ type Foreign ftype (QueryParam sym a :> api) = Foreign ftype api

243

244 foreignFor lang Proxy Proxy req =

245− foreignFor lang (Proxy :: Proxy ftype) (Proxy :: Proxy sublayout) $

245+ foreignFor lang (Proxy :: Proxy ftype) (Proxy :: Proxy api) $

246 req & reqUrl.queryStr <>~ [QueryArg arg Normal]

247 where

248 str = pack . symbolVal $ (Proxy :: Proxy sym)

@@ -251,11 +251,11 @@ instance (KnownSymbol sym, HasForeignType lang ftype a, HasForeign lang ftype su

251 , _argType = typeFor lang (Proxy :: Proxy ftype) (Proxy :: Proxy a) }

252

253instance

254− (KnownSymbol sym, HasForeignType lang ftype [a], HasForeign lang ftype sublayout)

254+ (KnownSymbol sym, HasForeignType lang ftype [a], HasForeign lang ftype api)

255− => HasForeign lang ftype (QueryParams sym a :> sublayout) where

255+ => HasForeign lang ftype (QueryParams sym a :> api) where

256− type Foreign ftype (QueryParams sym a :> sublayout) = Foreign ftype sublayout

256+ type Foreign ftype (QueryParams sym a :> api) = Foreign ftype api

257 foreignFor lang Proxy Proxy req =

258− foreignFor lang (Proxy :: Proxy ftype) (Proxy :: Proxy sublayout) $

258+ foreignFor lang (Proxy :: Proxy ftype) (Proxy :: Proxy api) $

259 req & reqUrl.queryStr <>~ [QueryArg arg List]

260 where

261 str = pack . symbolVal $ (Proxy :: Proxy sym)

@@ -264,12 +264,12 @@ instance

264 , _argType = typeFor lang (Proxy :: Proxy ftype) (Proxy :: Proxy [a]) }

265

266instance

267− (KnownSymbol sym, HasForeignType lang ftype Bool, HasForeign lang ftype sublayout)

267+ (KnownSymbol sym, HasForeignType lang ftype Bool, HasForeign lang ftype api)

268− => HasForeign lang ftype (QueryFlag sym :> sublayout) where

268+ => HasForeign lang ftype (QueryFlag sym :> api) where

269− type Foreign ftype (QueryFlag sym :> sublayout) = Foreign ftype sublayout

269+ type Foreign ftype (QueryFlag sym :> api) = Foreign ftype api

270

271 foreignFor lang ftype Proxy req =

272− foreignFor lang ftype (Proxy :: Proxy sublayout) $

272+ foreignFor lang ftype (Proxy :: Proxy api) $

273 req & reqUrl.queryStr <>~ [QueryArg arg Flag]

274 where

275 str = pack . symbolVal $ (Proxy :: Proxy sym)

@@ -284,20 +284,20 @@ instance HasForeign lang ftype Raw where

284 req & reqFuncName . _FunctionName %~ ((toLower $ decodeUtf8 method) :)

285 & reqMethod .~ method

286

287−instance (Elem JSON list, HasForeignType lang ftype a, HasForeign lang ftype sublayout)

287+instance (Elem JSON list, HasForeignType lang ftype a, HasForeign lang ftype api)

288− => HasForeign lang ftype (ReqBody list a :> sublayout) where

288+ => HasForeign lang ftype (ReqBody list a :> api) where

289− type Foreign ftype (ReqBody list a :> sublayout) = Foreign ftype sublayout

289+ type Foreign ftype (ReqBody list a :> api) = Foreign ftype api

290

291 foreignFor lang ftype Proxy req =

292− foreignFor lang ftype (Proxy :: Proxy sublayout) $

292+ foreignFor lang ftype (Proxy :: Proxy api) $

293 req & reqBody .~ (Just $ typeFor lang ftype (Proxy :: Proxy a))

294

295−instance (KnownSymbol path, HasForeign lang ftype sublayout)

295+instance (KnownSymbol path, HasForeign lang ftype api)

296− => HasForeign lang ftype (path :> sublayout) where

296+ => HasForeign lang ftype (path :> api) where

297− type Foreign ftype (path :> sublayout) = Foreign ftype sublayout

297+ type Foreign ftype (path :> api) = Foreign ftype api

298

299 foreignFor lang ftype Proxy req =

300− foreignFor lang ftype (Proxy :: Proxy sublayout) $

300+ foreignFor lang ftype (Proxy :: Proxy api) $

301 req & reqUrl . path <>~ [Segment (Static (PathSegment str))]

302 & reqFuncName . _FunctionName %~ (++ [str])

303 where

@@ -305,39 +305,39 @@ instance (KnownSymbol path, HasForeign lang ftype sublayout)

305 Data.Text.map (\c -> if c == '.' then '_' else c)

306 . pack . symbolVal $ (Proxy :: Proxy path)

307

308−instance HasForeign lang ftype sublayout

308+instance HasForeign lang ftype api

309− => HasForeign lang ftype (RemoteHost :> sublayout) where

309+ => HasForeign lang ftype (RemoteHost :> api) where

310− type Foreign ftype (RemoteHost :> sublayout) = Foreign ftype sublayout

310+ type Foreign ftype (RemoteHost :> api) = Foreign ftype api

311

312 foreignFor lang ftype Proxy req =

313− foreignFor lang ftype (Proxy :: Proxy sublayout) req

313+ foreignFor lang ftype (Proxy :: Proxy api) req

314

315−instance HasForeign lang ftype sublayout

315+instance HasForeign lang ftype api

316− => HasForeign lang ftype (IsSecure :> sublayout) where

316+ => HasForeign lang ftype (IsSecure :> api) where

317− type Foreign ftype (IsSecure :> sublayout) = Foreign ftype sublayout

317+ type Foreign ftype (IsSecure :> api) = Foreign ftype api

318

319 foreignFor lang ftype Proxy req =

320− foreignFor lang ftype (Proxy :: Proxy sublayout) req

320+ foreignFor lang ftype (Proxy :: Proxy api) req

321

322−instance HasForeign lang ftype sublayout => HasForeign lang ftype (Vault :> sublayout) where

322+instance HasForeign lang ftype api => HasForeign lang ftype (Vault :> api) where

323− type Foreign ftype (Vault :> sublayout) = Foreign ftype sublayout

323+ type Foreign ftype (Vault :> api) = Foreign ftype api

324

325 foreignFor lang ftype Proxy req =

326− foreignFor lang ftype (Proxy :: Proxy sublayout) req

326+ foreignFor lang ftype (Proxy :: Proxy api) req

327

328−instance HasForeign lang ftype sublayout =>

328+instance HasForeign lang ftype api =>

329− HasForeign lang ftype (WithNamedContext name context sublayout) where

329+ HasForeign lang ftype (WithNamedContext name context api) where

330

331− type Foreign ftype (WithNamedContext name context sublayout) = Foreign ftype sublayout

331+ type Foreign ftype (WithNamedContext name context api) = Foreign ftype api

332

333− foreignFor lang ftype Proxy = foreignFor lang ftype (Proxy :: Proxy sublayout)

333+ foreignFor lang ftype Proxy = foreignFor lang ftype (Proxy :: Proxy api)

334

335−instance HasForeign lang ftype sublayout

335+instance HasForeign lang ftype api

336− => HasForeign lang ftype (HttpVersion :> sublayout) where

336+ => HasForeign lang ftype (HttpVersion :> api) where

337− type Foreign ftype (HttpVersion :> sublayout) = Foreign ftype sublayout

337+ type Foreign ftype (HttpVersion :> api) = Foreign ftype api

338

339 foreignFor lang ftype Proxy req =

340− foreignFor lang ftype (Proxy :: Proxy sublayout) req

340+ foreignFor lang ftype (Proxy :: Proxy api) req

341

342-- | Utility class used by 'listFromAPI' which computes

343-- the data needed to generate a function for each endpoint

servant-js/src/Servant/JS.hs+1−1

@@ -128,7 +128,7 @@ import Servant.Foreign (listFromAPI)

128-- | Generate the data necessary to generate javascript code

129-- for all the endpoints of an API, as ':<|>'-separated values

130-- of type 'AjaxReq'.

131−javascript :: HasForeign NoTypes () layout => Proxy layout -> Foreign () layout

131+javascript :: HasForeign NoTypes () api => Proxy api -> Foreign () api

132javascript p = foreignFor (Proxy :: Proxy NoTypes) (Proxy :: Proxy ()) p defReq

133

134-- | Directly generate all the javascript functions for your API

servant-js/test/Servant/JSSpec/CustomHeaders.hs+12−12

@@ -23,11 +23,11 @@ import Servant.JS.Internal

23-- using -- Basic, Digest, whatever.

24data Authorization (sym :: Symbol) a

26−instance (KnownSymbol sym, HasForeign lang () sublayout)

26+instance (KnownSymbol sym, HasForeign lang () api)

27− => HasForeign lang () (Authorization sym a :> sublayout) where

27+ => HasForeign lang () (Authorization sym a :> api) where

28− type Foreign () (Authorization sym a :> sublayout) = Foreign () sublayout

28+ type Foreign () (Authorization sym a :> api) = Foreign () api

30− foreignFor lang ftype Proxy req = foreignFor lang ftype (Proxy :: Proxy sublayout) $

30+ foreignFor lang ftype Proxy req = foreignFor lang ftype (Proxy :: Proxy api) $

31 req & reqHeaders <>~

32 [ ReplaceHeaderArg (Arg "Authorization" ())

33 $ tokenType (pack . symbolVal $ (Proxy :: Proxy sym)) ]

@@ -37,11 +37,11 @@ instance (KnownSymbol sym, HasForeign lang () sublayout)

37-- | This is a combinator that fetches an X-MyLovelyHorse header.

38data MyLovelyHorse a

40−instance (HasForeign lang () sublayout)

40+instance (HasForeign lang () api)

41− => HasForeign lang () (MyLovelyHorse a :> sublayout) where

41+ => HasForeign lang () (MyLovelyHorse a :> api) where

42− type Foreign () (MyLovelyHorse a :> sublayout) = Foreign () sublayout

42+ type Foreign () (MyLovelyHorse a :> api) = Foreign () api

44− foreignFor lang ftype Proxy req = foreignFor lang ftype (Proxy :: Proxy sublayout) $

44+ foreignFor lang ftype Proxy req = foreignFor lang ftype (Proxy :: Proxy api) $

45 req & reqHeaders <>~ [ ReplaceHeaderArg (Arg "X-MyLovelyHorse" ()) tpl ]

46 where

47 tpl = "I am good friends with {X-MyLovelyHorse}"

@@ -49,11 +49,11 @@ instance (HasForeign lang () sublayout)

49-- | This is a combinator that fetches an X-WhatsForDinner header.

50data WhatsForDinner a

52−instance (HasForeign lang () sublayout)

52+instance (HasForeign lang () api)

53− => HasForeign lang () (WhatsForDinner a :> sublayout) where

53+ => HasForeign lang () (WhatsForDinner a :> api) where

54− type Foreign () (WhatsForDinner a :> sublayout) = Foreign () sublayout

54+ type Foreign () (WhatsForDinner a :> api) = Foreign () api

56− foreignFor lang ftype Proxy req = foreignFor lang ftype (Proxy :: Proxy sublayout) $

56+ foreignFor lang ftype Proxy req = foreignFor lang ftype (Proxy :: Proxy api) $

57 req & reqHeaders <>~ [ ReplaceHeaderArg (Arg "X-WhatsForDinner" ()) tpl ]

58 where

59 tpl = "I would like {X-WhatsForDinner} with a cherry on top."

servant-server/src/Servant/Server.hs+6−6

@@ -130,11 +130,11 @@ import Servant.Utils.Enter

130-- > main :: IO ()

131-- > main = Network.Wai.Handler.Warp.run 8080 app

132--

133−serve :: (HasServer layout '[]) => Proxy layout -> Server layout -> Application

133+serve :: (HasServer api '[]) => Proxy api -> Server api -> Application

134serve p = serveWithContext p EmptyContext

135

136−serveWithContext :: (HasServer layout context)

136+serveWithContext :: (HasServer api context)

137− => Proxy layout -> Context context -> Server layout -> Application

137+ => Proxy api -> Context context -> Server api -> Application

138serveWithContext p context server =

139 toApplication (runRouter (route p context (emptyDelayed (Route server))))

140

@@ -189,12 +189,12 @@ serveWithContext p context server =

189-- that one takes precedence. If both parts fail, the \"better\" error

190-- code will be returned.

191--

192−layout :: (HasServer layout '[]) => Proxy layout -> Text

192+layout :: (HasServer api '[]) => Proxy api -> Text

193layout p = layoutWithContext p EmptyContext

194

195-- | Variant of 'layout' that takes an additional 'Context'.

196−layoutWithContext :: (HasServer layout context)

196+layoutWithContext :: (HasServer api context)

197− => Proxy layout -> Context context -> Text

197+ => Proxy api -> Context context -> Text

198layoutWithContext p context =

199 routerLayout (route p context (emptyDelayed (FailFatal err501)))

200

servant-server/src/Servant/Server/Internal.hs+39−39

@@ -68,16 +68,16 @@ import Servant.Server.Internal.RoutingApplication

68import Servant.Server.Internal.ServantErr

71−class HasServer layout context where

71+class HasServer api context where

72− type ServerT layout (m :: * -> *) :: *

72+ type ServerT api (m :: * -> *) :: *

74 route ::

75− Proxy layout

75+ Proxy api

76 -> Context context

77− -> Delayed env (Server layout)

77+ -> Delayed env (Server api)

78 -> Router env

80−type Server layout = ServerT layout Handler

80+type Server api = ServerT api Handler

82-- * Instances

@@ -118,15 +118,15 @@ instance (HasServer a context, HasServer b context) => HasServer (a :<|> b) cont

118-- > server = getBook

119-- > where getBook :: Text -> Handler Book

120-- > getBook isbn = ...

121−instance (KnownSymbol capture, FromHttpApiData a, HasServer sublayout context)

121+instance (KnownSymbol capture, FromHttpApiData a, HasServer api context)

122− => HasServer (Capture capture a :> sublayout) context where

122+ => HasServer (Capture capture a :> api) context where

123

124− type ServerT (Capture capture a :> sublayout) m =

124+ type ServerT (Capture capture a :> api) m =

125− a -> ServerT sublayout m

125+ a -> ServerT api m

126

127 route Proxy context d =

128 CaptureRouter $

129− route (Proxy :: Proxy sublayout)

129+ route (Proxy :: Proxy api)

130 context

131 (addCapture d $ \ txt -> case parseUrlPieceMaybe txt :: Maybe a of

132 Nothing -> delayedFail err400

@@ -236,15 +236,15 @@ instance OVERLAPPING_

236-- > server = viewReferer

237-- > where viewReferer :: Referer -> Handler referer

238-- > viewReferer referer = return referer

239−instance (KnownSymbol sym, FromHttpApiData a, HasServer sublayout context)

239+instance (KnownSymbol sym, FromHttpApiData a, HasServer api context)

240− => HasServer (Header sym a :> sublayout) context where

240+ => HasServer (Header sym a :> api) context where

241

242− type ServerT (Header sym a :> sublayout) m =

242+ type ServerT (Header sym a :> api) m =

243− Maybe a -> ServerT sublayout m

243+ Maybe a -> ServerT api m

244

245 route Proxy context subserver =

246 let mheader req = parseHeaderMaybe =<< lookup str (requestHeaders req)

247− in route (Proxy :: Proxy sublayout) context (passToServer subserver mheader)

247+ in route (Proxy :: Proxy api) context (passToServer subserver mheader)

248 where str = fromString $ symbolVal (Proxy :: Proxy sym)

249

250-- | If you use @'QueryParam' "author" Text@ in one of the endpoints for your API,

@@ -268,11 +268,11 @@ instance (KnownSymbol sym, FromHttpApiData a, HasServer sublayout context)

268-- > where getBooksBy :: Maybe Text -> Handler [Book]

269-- > getBooksBy Nothing = ...return all books...

270-- > getBooksBy (Just author) = ...return books by the given author...

271−instance (KnownSymbol sym, FromHttpApiData a, HasServer sublayout context)

271+instance (KnownSymbol sym, FromHttpApiData a, HasServer api context)

272− => HasServer (QueryParam sym a :> sublayout) context where

272+ => HasServer (QueryParam sym a :> api) context where

273

274− type ServerT (QueryParam sym a :> sublayout) m =

274+ type ServerT (QueryParam sym a :> api) m =

275− Maybe a -> ServerT sublayout m

275+ Maybe a -> ServerT api m

276

277 route Proxy context subserver =

278 let querytext r = parseQueryText $ rawQueryString r

@@ -282,7 +282,7 @@ instance (KnownSymbol sym, FromHttpApiData a, HasServer sublayout context)

282 Just Nothing -> Nothing -- param present with no value -> Nothing

283 Just (Just v) -> parseQueryParamMaybe v -- if present, we try to convert to

284 -- the right type

285− in route (Proxy :: Proxy sublayout) context (passToServer subserver param)

285+ in route (Proxy :: Proxy api) context (passToServer subserver param)

286 where paramname = cs $ symbolVal (Proxy :: Proxy sym)

287

288-- | If you use @'QueryParams' "authors" Text@ in one of the endpoints for your API,

@@ -304,11 +304,11 @@ instance (KnownSymbol sym, FromHttpApiData a, HasServer sublayout context)

304-- > server = getBooksBy

305-- > where getBooksBy :: [Text] -> Handler [Book]

306-- > getBooksBy authors = ...return all books by these authors...

307−instance (KnownSymbol sym, FromHttpApiData a, HasServer sublayout context)

307+instance (KnownSymbol sym, FromHttpApiData a, HasServer api context)

308− => HasServer (QueryParams sym a :> sublayout) context where

308+ => HasServer (QueryParams sym a :> api) context where

309

310− type ServerT (QueryParams sym a :> sublayout) m =

310+ type ServerT (QueryParams sym a :> api) m =

311− [a] -> ServerT sublayout m

311+ [a] -> ServerT api m

312

313 route Proxy context subserver =

314 let querytext r = parseQueryText $ rawQueryString r

@@ -317,7 +317,7 @@ instance (KnownSymbol sym, FromHttpApiData a, HasServer sublayout context)

317 -- corresponding values

318 parameters r = filter looksLikeParam (querytext r)

319 values r = mapMaybe (convert . snd) (parameters r)

320− in route (Proxy :: Proxy sublayout) context (passToServer subserver values)

320+ in route (Proxy :: Proxy api) context (passToServer subserver values)

321 where paramname = cs $ symbolVal (Proxy :: Proxy sym)

322 looksLikeParam (name, _) = name == paramname || name == (paramname <> "[]")

323 convert Nothing = Nothing

@@ -335,11 +335,11 @@ instance (KnownSymbol sym, FromHttpApiData a, HasServer sublayout context)

335-- > server = getBooks

336-- > where getBooks :: Bool -> Handler [Book]

337-- > getBooks onlyPublished = ...return all books, or only the ones that are already published, depending on the argument...

338−instance (KnownSymbol sym, HasServer sublayout context)

338+instance (KnownSymbol sym, HasServer api context)

339− => HasServer (QueryFlag sym :> sublayout) context where

339+ => HasServer (QueryFlag sym :> api) context where

340

341− type ServerT (QueryFlag sym :> sublayout) m =

341+ type ServerT (QueryFlag sym :> api) m =

342− Bool -> ServerT sublayout m

342+ Bool -> ServerT api m

343

344 route Proxy context subserver =

345 let querytext r = parseQueryText $ rawQueryString r

@@ -347,7 +347,7 @@ instance (KnownSymbol sym, HasServer sublayout context)

347 Just Nothing -> True -- param is there, with no value

348 Just (Just v) -> examine v -- param with a value

349 Nothing -> False -- param not in the query string

350− in route (Proxy :: Proxy sublayout) context (passToServer subserver param)

350+ in route (Proxy :: Proxy api) context (passToServer subserver param)

351 where paramname = cs $ symbolVal (Proxy :: Proxy sym)

352 examine v | v == "true" || v == "1" || v == "" = True

353 | otherwise = False

@@ -392,14 +392,14 @@ instance HasServer Raw context where

392-- > server = postBook

393-- > where postBook :: Book -> Handler Book

394-- > postBook book = ...insert into your db...

395−instance ( AllCTUnrender list a, HasServer sublayout context

395+instance ( AllCTUnrender list a, HasServer api context

396− ) => HasServer (ReqBody list a :> sublayout) context where

396+ ) => HasServer (ReqBody list a :> api) context where

397

398− type ServerT (ReqBody list a :> sublayout) m =

398+ type ServerT (ReqBody list a :> api) m =

399− a -> ServerT sublayout m

399+ a -> ServerT api m

400

401 route Proxy context subserver =

402− route (Proxy :: Proxy sublayout) context (addBodyCheck subserver bodyCheck)

402+ route (Proxy :: Proxy api) context (addBodyCheck subserver bodyCheck)

403 where

404 bodyCheck = withRequest $ \ request -> do

405 -- See HTTP RFC 2616, section 7.2.1

@@ -416,15 +416,15 @@ instance ( AllCTUnrender list a, HasServer sublayout context

416 Just (Right v) -> return v

417

418-- | Make sure the incoming request starts with @"/path"@, strip it and

419−-- pass the rest of the request path to @sublayout@.

419+-- pass the rest of the request path to @api@.

420−instance (KnownSymbol path, HasServer sublayout context) => HasServer (path :> sublayout) context where

420+instance (KnownSymbol path, HasServer api context) => HasServer (path :> api) context where

421

422− type ServerT (path :> sublayout) m = ServerT sublayout m

422+ type ServerT (path :> api) m = ServerT api m

423

424 route Proxy context subserver =

425 pathRouter

426 (cs (symbolVal proxyPath))

427− (route (Proxy :: Proxy sublayout) context subserver)

427+ (route (Proxy :: Proxy api) context subserver)

428 where proxyPath = Proxy :: Proxy path

429

430instance HasServer api context => HasServer (RemoteHost :> api) context where