Network.Wreq.Lens

Options for configuring a client.

A lens onto configuration of the connection manager provided by the http-client package.

In this example, we enable the use of OpenSSL for (hopefully) secure connections:

import OpenSSL.Session (context)
import Network.HTTP.Client.OpenSSL

let opts = defaults Control.Lens.& manager Control.Lens..~ Left (Network.HTTP.Client.OpenSSL.opensslManagerSettings context)
Network.HTTP.Client.OpenSSL.withOpenSSL $
  getWith opts "https://httpbin.org/get"
 

In this example, we also set the response timeout to 10000 microseconds:

import OpenSSL.Session (context)
import Network.HTTP.Client.OpenSSL
import Network.HTTP.Client (defaultManagerSettings, managerResponseTimeout)

let opts = defaults Control.Lens.& manager Control.Lens..~ Left (Network.HTTP.Client.OpenSSL.opensslManagerSettings context)
                    Control.Lens.& manager Control.Lens..~ Left (defaultManagerSettings { managerResponseTimeout = responseTimeoutMicro 10000 } )

Network.HTTP.Client.OpenSSL.withOpenSSL $
  getWith opts "https://httpbin.org/get"
 

A lens onto proxy configuration.

Example:

let opts = defaults Control.Lens.& proxy Control.Lens.?~ httpProxy "localhost" 8000
getWith opts "http://httpbin.org/get"
 

Note here the use of the Control.Lens.?~ setter to turn a Proxy into a Maybe Proxy, to make the type of the RHS compatible with the proxy lens.

A lens onto request authentication.

Example (note the use of TLS):

let opts = defaults Control.Lens.& Lens.auth Control.Lens.?~ basicAuth "user" "pass"
getWith opts "https://httpbin.org/basic-auth/user/pass"
 

A lens onto all headers with the given name (there can legitimately be zero or more).

Example:

let opts = defaults Control.Lens.& header "Accept" Control.Lens..~ ["*/*"]
getWith opts "http://httpbin.org/get"
 

A lens onto all query parameters with the given name (there can legitimately be zero or more).

In this example, we construct the query URL "http://httpbin.org/get?foo=bar&foo=quux".

let opts = defaults Control.Lens.& param "foo" Control.Lens..~ ["bar", "quux"]
getWith opts "http://httpbin.org/get"
 

A lens onto the maximum number of redirects that will be followed before an exception is thrown.

In this example, a HttpException will be thrown with a TooManyRedirects constructor, because the maximum number of redirects allowed will be exceeded.

let opts = defaults Control.Lens.& redirects Control.Lens..~ 3
getWith opts "http://httpbin.org/redirect/5"
 

A lens onto all headers (there can legitimately be zero or more).

In this example, we print all the headers sent by default with every request.

print (defaults Control.Lens.^. headers)
 

A lens onto all query parameters.

A traversal onto the cookie with the given name, if one exists.

N.B. This is an "illegal" Traversal': we can change the cookieName of the associated Cookie so that it differs from the name provided to this function.

A lens onto all cookies.

A function that checks the result of a HTTP request and potentially throw an exception.

A lens to get the optional status check function

A lens onto the name of a cookie.

A lens onto the value of a cookie.

A lens onto the expiry time of a cookie.

A lens onto the domain of a cookie.

A lens onto the path of a cookie.

A lens onto the creation time of a cookie.

A lens onto the last access time of a cookie.

A lens onto whether a cookie is persistent across sessions (also known as a "tracking cookie").

A lens onto whether a cookie is host-only.

A lens onto whether a cookie is secure-only, such that it will only be used over TLS.

A lens onto whether a cookie is "HTTP-only".

Such cookies should be used only by browsers when transmitting HTTP requests. They must be unavailable in non-browser environments, such as when executing JavaScript scripts.

A simple representation of the HTTP response.

Since 0.1.0

A lens onto the body of a response.

r <- get "http://httpbin.org/get"
print (r Control.Lens.^. responseBody)
 

A lens onto all matching named headers in an HTTP response.

To access exactly one header (the result will be the empty string if there is no match), use the (Control.Lens.^.) operator.

r <- get "http://httpbin.org/get"
print (r Control.Lens.^. responseHeader "Content-Type")
 

To access at most one header (the result will be Nothing if there is no match), use the (Control.Lens.^?) operator.

r <- get "http://httpbin.org/get"
print (r Control.Lens.^? responseHeader "Content-Transfer-Encoding")
 

To access all (zero or more) matching headers, use the (Control.Lens.^..) operator.

r <- get "http://httpbin.org/get"
print (r Control.Lens.^.. responseHeader "Set-Cookie")
 

A fold over Link headers, matching on both parameter name and value.

For example, here is a Link header returned by the GitHub search API.

Link:
  <https://api.github.com/search/code?q=addClass+user%3Amozilla&page=2>; rel="next",
  <https://api.github.com/search/code?q=addClass+user%3Amozilla&page=34>; rel="last"

And here is an example of how we can retrieve the URL for the next link programatically.

r <- get "https://api.github.com/search/code?q=addClass+user:mozilla"
print (r Control.Lens.^? responseLink "rel" "next" . linkURL)
 

A fold over any cookies that match the given name.

r <- get "http://www.nytimes.com/"
print (r Control.Lens.^? responseCookie "RMID")
 

A lens onto all headers in an HTTP response.

A lens onto all cookies set in the response.

A lens onto the status of an HTTP response.

A lens onto the version of an HTTP response.

A datatype holding information on redirected requests and the final response.

Since 0.4.1

A lens onto the final response of a historied response.

A lens onto the final request of a historied response.

A lens onto the list of redirects of a historied response.

An element of a Link header.

A lens onto the URL portion of a Link element.

A lens onto the parameters of a Link element.

A lens onto the name of the input element associated with part of a multipart form upload.

A lens onto the filename associated with part of a multipart form upload.

A lens onto the content-type associated with part of a multipart form upload.

A lens onto the code that fetches the data associated with part of a multipart form upload.

Turn an attoparsec Parser into a Fold.

Both headers and bodies can contain complicated data that we may need to parse.

Example: when responding to an OPTIONS request, a server may return the list of verbs it supports in any order, up to and including changing the order on every request (which httpbin.org /actually does/!). To deal with this possibility, we parse the list, then sort it.

>>> import Data.Attoparsec.ByteString.Char8 as A>>> import Data.List (sort)>>> >>> let comma = skipSpace >> "," >> skipSpace>>> let verbs = A.takeWhile isAlpha_ascii `sepBy` comma>>> >>> r <- options "http://httpbin.org/get">>> r ^. responseHeader "Allow" . atto verbs . to sort["GET","HEAD","OPTIONS"]

The same as atto, but ensures that the parser consumes the entire input.

Equivalent to:

atto_ myParser = atto (myParser <* endOfInput)