gnu/packages/haskell-web.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
   3 ;;; Copyright © 2015, 2016, 2017, 2018 Ricardo Wurmus <rekado@elephly.net>
   4 ;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch>
   5 ;;; Copyright © 2016 Ludovic Courtès <ludo@gnu.org>
   6 ;;; Copyright © 2017 rsiddharth <s@ricketyspace.net>
   7 ;;; Copyright © 2017 Tobias Geerinckx-Rice <me@tobias.gr>
   8 ;;; Copyright © 2019 Robert Vollmert <rob@vllmrt.net>
   9 ;;; Copyright © 2019 John Soo <jsoo1@asu.edu>
  10 ;;;
  11 ;;; This file is part of GNU Guix.
  12 ;;;
  13 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  14 ;;; under the terms of the GNU General Public License as published by
  15 ;;; the Free Software Foundation; either version 3 of the License, or (at
  16 ;;; your option) any later version.
  17 ;;;
  18 ;;; GNU Guix is distributed in the hope that it will be useful, but
  19 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  20 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 ;;; GNU General Public License for more details.
  22 ;;;
  23 ;;; You should have received a copy of the GNU General Public License
  24 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  25
  26 (define-module (gnu packages haskell-web)
  27   #:use-module (gnu packages)
  28   #:use-module (gnu packages curl)
  29   #:use-module (gnu packages haskell)
  30   #:use-module (gnu packages haskell-check)
  31   #:use-module (gnu packages haskell-crypto)
  32   #:use-module (gnu packages haskell-xyz)
  33   #:use-module (guix build-system haskell)
  34   #:use-module (guix download)
  35   #:use-module ((guix licenses) #:prefix license:)
  36   #:use-module (guix packages)
  37   #:use-module (guix utils))
  38
  39 (define-public ghc-tagsoup
  40   (package
  41     (name "ghc-tagsoup")
  42     (version "0.14.8")
  43     (source
  44      (origin
  45        (method url-fetch)
  46        (uri (string-append "https://hackage.haskell.org/package/tagsoup/"
  47                            "tagsoup-" version ".tar.gz"))
  48        (sha256
  49         (base32
  50          "1m9sx6gr9y9yxvkmcap8xsks8cnhznvma1mrfl39zljkv005azms"))))
  51     (build-system haskell-build-system)
  52     (native-inputs
  53      `(("ghc-quickcheck" ,ghc-quickcheck)))
  54     (home-page "http://community.haskell.org/~ndm/tagsoup/")
  55     (synopsis
  56      "Parsing and extracting information from (possibly malformed) HTML/XML
  57 documents")
  58     (description
  59      "TagSoup is a library for parsing HTML/XML.  It supports the HTML 5
  60 specification, and can be used to parse either well-formed XML, or
  61 unstructured and malformed HTML from the web.  The library also provides
  62 useful functions to extract information from an HTML document, making it ideal
  63 for screen-scraping.")
  64     (license license:bsd-3)))
  65
  66 (define-public ghc-cookie
  67   (package
  68     (name "ghc-cookie")
  69     (version "0.4.4")
  70     (source
  71      (origin
  72        (method url-fetch)
  73        (uri (string-append
  74              "https://hackage.haskell.org/package/cookie/cookie-"
  75              version
  76              ".tar.gz"))
  77        (sha256
  78         (base32
  79          "1qy09i0jh2z9i9avy2khf8a8afq4fqgnv0fyrszgfg4kmq2fsi9j"))))
  80     (build-system haskell-build-system)
  81     (inputs
  82      `(("ghc-old-locale" ,ghc-old-locale)
  83        ("ghc-blaze-builder" ,ghc-blaze-builder)
  84        ("ghc-data-default-class" ,ghc-data-default-class)
  85        ("ghc-hunit" ,ghc-hunit)
  86        ("ghc-quickcheck" ,ghc-quickcheck)
  87        ("ghc-tasty" ,ghc-tasty)
  88        ("ghc-tasty-hunit" ,ghc-tasty-hunit)
  89        ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
  90     (home-page "https://github.com/snoyberg/cookie")
  91     (synopsis "HTTP cookie parsing and rendering")
  92     (description "HTTP cookie parsing and rendering library for Haskell.")
  93     (license license:bsd-3)))
  94
  95 (define-public ghc-httpd-shed
  96   (package
  97     (name "ghc-httpd-shed")
  98     (version "0.4.1.1")
  99     (source
 100      (origin
 101        (method url-fetch)
 102        (uri (string-append "https://hackage.haskell.org/package/httpd-shed/"
 103                            "httpd-shed-" version ".tar.gz"))
 104        (sha256
 105         (base32
 106          "19dgdimpzr7pxk7pqvyin6j87gmvnf0rm35gzhmna8qr835wy3sr"))))
 107     (build-system haskell-build-system)
 108     (inputs
 109      `(("ghc-network-bsd" ,ghc-network-bsd)
 110        ("ghc-network-uri" ,ghc-network-uri)
 111        ("ghc-network" ,ghc-network)))
 112     (home-page "https://hackage.haskell.org/package/httpd-shed")
 113     (synopsis "Simple web-server with an interact style API")
 114     (description
 115      "This web server promotes a function from @code{Request} to @code{IO
 116 Response} into a local web server.  The user can decide how to interpret the
 117 requests, and the library is intended for implementing Ajax APIs.")
 118     (license license:bsd-3)))
 119
 120 (define-public ghc-http-types
 121   (package
 122     (name "ghc-http-types")
 123     (version "0.12.3")
 124     (source
 125      (origin
 126        (method url-fetch)
 127        (uri (string-append "https://hackage.haskell.org/package/http-types/"
 128                            "http-types-" version ".tar.gz"))
 129        (sha256
 130         (base32
 131          "05j00b9nqmwh9zaq9y9x50k81v2pd3j7a71kd91zlnbl8xk4m2jf"))))
 132     (build-system haskell-build-system)
 133     (native-inputs
 134      `(("ghc-doctest" ,ghc-doctest)
 135        ("ghc-hspec" ,ghc-hspec)
 136        ("ghc-quickcheck" ,ghc-quickcheck)
 137        ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
 138        ("hspec-discover" ,hspec-discover)))
 139     (inputs
 140      `(("ghc-case-insensitive" ,ghc-case-insensitive)))
 141     (home-page "https://github.com/aristidb/http-types")
 142     (synopsis "Generic HTTP types for Haskell")
 143     (description "This package provides generic HTTP types for Haskell (for
 144 both client and server code).")
 145     (license license:bsd-3)))
 146
 147 (define-public ghc-http
 148   (package
 149     (name "ghc-http")
 150     (version "4000.3.14")
 151     (outputs '("out" "doc"))
 152     (source
 153      (origin
 154        (method url-fetch)
 155        (uri (string-append "https://hackage.haskell.org/package/HTTP/"
 156                            "HTTP-" version ".tar.gz"))
 157        (sha256
 158         (base32
 159          "0yv8mbjicpl7l2017c4dhm49117lblgwpy1llv368wci1vrxf0m6"))))
 160     (build-system haskell-build-system)
 161     (native-inputs
 162      `(("ghc-httpd-shed" ,ghc-httpd-shed)
 163        ("ghc-hunit" ,ghc-hunit)
 164        ("ghc-test-framework" ,ghc-test-framework)
 165        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
 166     (inputs
 167      `(("ghc-case-insensitive" ,ghc-case-insensitive)
 168        ("ghc-conduit" ,ghc-conduit)
 169        ("ghc-conduit-extra" ,ghc-conduit-extra)
 170        ("ghc-http-types" ,ghc-http-types)
 171        ("ghc-old-time" ,ghc-old-time)
 172        ("ghc-puremd5" ,ghc-puremd5)
 173        ("ghc-network" ,ghc-network)
 174        ("ghc-network-uri" ,ghc-network-uri)
 175        ("ghc-split" ,ghc-split)))
 176     (arguments
 177      `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
 178     (home-page "https://github.com/haskell/HTTP")
 179     (synopsis "Library for client-side HTTP")
 180     (description
 181      "The HTTP package supports client-side web programming in Haskell.  It
 182 lets you set up HTTP connections, transmitting requests and processing the
 183 responses coming back.")
 184     (license license:bsd-3)))
 185
 186 (define-public ghc-http-client
 187   (package
 188     (name "ghc-http-client")
 189     (version "0.6.4")
 190     (source (origin
 191               (method url-fetch)
 192               (uri (string-append "https://hackage.haskell.org/package/"
 193                                   "http-client/http-client-"
 194                                   version ".tar.gz"))
 195               (sha256
 196                (base32
 197                 "1n9rnbp8lwkd4whi2anniywi4y1bn9kx6nzfigfvz28d7pn7i4in"))))
 198     (build-system haskell-build-system)
 199     ;; Tests require access to the web.
 200     (arguments `(#:tests? #f))
 201     (inputs
 202      `(("ghc-async" ,ghc-async)
 203        ("ghc-base64-bytestring" ,ghc-base64-bytestring)
 204        ("ghc-blaze-builder" ,ghc-blaze-builder)
 205        ("ghc-case-insensitive" ,ghc-case-insensitive)
 206        ("ghc-cookie" ,ghc-cookie)
 207        ("ghc-data-default-class" ,ghc-data-default-class)
 208        ("ghc-exceptions" ,ghc-exceptions)
 209        ("ghc-http-types" ,ghc-http-types)
 210        ("ghc-memory" ,ghc-memory)
 211        ("ghc-mime-types" ,ghc-mime-types)
 212        ("ghc-monad-control" ,ghc-monad-control)
 213        ("ghc-network" ,ghc-network)
 214        ("ghc-network-uri" ,ghc-network-uri)
 215        ("ghc-random" ,ghc-random)
 216        ("ghc-streaming-commons" ,ghc-streaming-commons)
 217        ("ghc-zlib" ,ghc-zlib)))
 218     (native-inputs
 219      `(("ghc-hspec" ,ghc-hspec)))
 220     (home-page "https://github.com/snoyberg/http-client")
 221     (synopsis "HTTP client engine")
 222     (description
 223      "This package provides an HTTP client engine, intended as a base layer
 224 for more user-friendly packages.")
 225     (license license:expat)))
 226
 227 (define-public ghc-http-client-tls
 228   (package
 229     (name "ghc-http-client-tls")
 230     (version "0.3.5.3")
 231     (source (origin
 232               (method url-fetch)
 233               (uri (string-append "https://hackage.haskell.org/package/"
 234                                   "http-client-tls/http-client-tls-"
 235                                   version ".tar.gz"))
 236               (sha256
 237                (base32
 238                 "0qj3pcpgbsfsc4m52dz35khhl4hf1i0nmcpa445z82d9567vy6j7"))))
 239     (build-system haskell-build-system)
 240     ;; Tests require Internet access
 241     (arguments `(#:tests? #f))
 242     (inputs
 243      `(("ghc-data-default-class" ,ghc-data-default-class)
 244        ("ghc-http-client" ,ghc-http-client)
 245        ("ghc-connection" ,ghc-connection)
 246        ("ghc-network" ,ghc-network)
 247        ("ghc-tls" ,ghc-tls)
 248        ("ghc-http-types" ,ghc-http-types)))
 249     (native-inputs
 250      `(("ghc-hspec" ,ghc-hspec)))
 251     (home-page "https://github.com/snoyberg/http-client")
 252     (synopsis "Backend for http-client using the TLS library")
 253     (description
 254      "This package provides a backend for the http-client package using the
 255 connection and TLS libraries.  It is intended for use by higher-level
 256 libraries, such as http-conduit.")
 257     (license license:expat)))
 258
 259 (define-public ghc-http-date
 260   (package
 261     (name "ghc-http-date")
 262     (version "0.0.8")
 263     (source
 264      (origin
 265        (method url-fetch)
 266        (uri (string-append "https://hackage.haskell.org/package/"
 267                            "http-date-" version "/"
 268                            "http-date-" version ".tar.gz"))
 269        (sha256
 270         (base32
 271          "09slbzqayjnqqz9zybk7slgzvizgplikqgg4b2flzgks91466k0g"))))
 272     (build-system haskell-build-system)
 273     (inputs
 274      `(("ghc-attoparsec" ,ghc-attoparsec)))
 275     (native-inputs
 276      `(("ghc-doctest" ,ghc-doctest)
 277        ("ghc-hspec" ,ghc-hspec)
 278        ("hspec-discover" ,hspec-discover)
 279        ("ghc-old-locale" ,ghc-old-locale)))
 280     (home-page "https://github.com/kazu-yamamoto/http-date")
 281     (synopsis "HTTP Date parser/formatter")
 282     (description "Library for Parsing and formatting HTTP
 283 Date in Haskell.")
 284     (license license:bsd-3)))
 285
 286 (define-public ghc-http2
 287   (package
 288     (name "ghc-http2")
 289     (version "1.6.5")
 290     (source
 291      (origin
 292        (method url-fetch)
 293        (uri (string-append "https://hackage.haskell.org/package/"
 294                            "http2-" version "/"
 295                            "http2-" version ".tar.gz"))
 296        (sha256
 297         (base32
 298          "1vlmy8vnp6ml2n2pr11aa5fzigldsscgzmibrni64ykgfvpd3sqn"))))
 299     (build-system haskell-build-system)
 300     (inputs
 301      `(("ghc-case-insensitive" ,ghc-case-insensitive)
 302        ("ghc-network-byte-order" ,ghc-network-byte-order)
 303        ("ghc-aeson" ,ghc-aeson)
 304        ("ghc-aeson-pretty" ,ghc-aeson-pretty)
 305        ("ghc-base16-bytestring" ,ghc-base16-bytestring)
 306        ("ghc-unordered-containers" ,ghc-unordered-containers)
 307        ("ghc-vector" ,ghc-vector)
 308        ("ghc-word8" ,ghc-word8)
 309        ("ghc-psqueues" ,ghc-psqueues)))
 310     (native-inputs
 311      `(("ghc-glob" ,ghc-glob)
 312        ("ghc-hspec" ,ghc-hspec)
 313        ("ghc-doctest" ,ghc-doctest)
 314        ("hspec-discover" ,hspec-discover)))
 315     (home-page "https://github.com/kazu-yamamoto/http2")
 316     (synopsis "HTTP/2 library including frames, priority queues and HPACK")
 317     (description "This package provides a HTTP/2.0 library including frames
 318 and HPACK.  Currently HTTP/2 16 framing and HPACK 10 is supported.")
 319     (license license:bsd-3)))
 320
 321 (define-public ghc-http-conduit
 322   (package
 323     (name  "ghc-http-conduit")
 324     (version "2.3.7.3")
 325     (source
 326      (origin
 327        (method url-fetch)
 328        (uri (string-append "https://hackage.haskell.org/package/"
 329                            "http-conduit-" version "/" "http-conduit-"
 330                            version ".tar.gz"))
 331        (sha256
 332         (base32
 333          "00rshi1y0h8y4rvsnnad0bppxgpvp40sk7lw1kxmdwy8pi8xrvbs"))))
 334     (build-system haskell-build-system)
 335     ;; FIXME: `httpLbs TLS` in test-suite `test` fails with
 336     ;; ConnectionFailure getProtocolByName: does not exist (no such protocol
 337     ;; name: tcp)
 338     (arguments `(#:tests? #f))
 339     (inputs
 340      `(("ghc-aeson" ,ghc-aeson)
 341        ("ghc-resourcet" ,ghc-resourcet)
 342        ("ghc-conduit" ,ghc-conduit)
 343        ("ghc-conduit-extra" ,ghc-conduit-extra)
 344        ("ghc-http-types" ,ghc-http-types)
 345        ("ghc-lifted-base" ,ghc-lifted-base)
 346        ("ghc-http-client" ,ghc-http-client)
 347        ("ghc-http-client-tls" ,ghc-http-client-tls)
 348        ("ghc-monad-control" ,ghc-monad-control)
 349        ("ghc-exceptions" ,ghc-exceptions)
 350        ("ghc-unliftio" ,ghc-unliftio)))
 351     (native-inputs
 352      `(("ghc-hunit" ,ghc-hunit)
 353        ("ghc-hspec" ,ghc-hspec)
 354        ("ghc-data-default-class" ,ghc-data-default-class)
 355        ("ghc-connection" ,ghc-connection)
 356        ("ghc-warp-tls" ,ghc-warp-tls)
 357        ("ghc-blaze-builder" ,ghc-blaze-builder)
 358        ("ghc-conduit" ,ghc-conduit)
 359        ("ghc-utf8-string" ,ghc-utf8-string)
 360        ("ghc-case-insensitive" ,ghc-case-insensitive)
 361        ("ghc-lifted-base" ,ghc-lifted-base)
 362        ("ghc-network" ,ghc-network)
 363        ("ghc-wai" ,ghc-wai)
 364        ("ghc-warp" ,ghc-warp)
 365        ("ghc-wai-conduit" ,ghc-wai-conduit)
 366        ("ghc-http-types" ,ghc-http-types)
 367        ("ghc-cookie" ,ghc-cookie)
 368        ("ghc-conduit-extra" ,ghc-conduit-extra)
 369        ("ghc-streaming-commons" ,ghc-streaming-commons)
 370        ("ghc-aeson" ,ghc-aeson)
 371        ("ghc-temporary" ,ghc-temporary)
 372        ("ghc-resourcet" ,ghc-resourcet)))
 373     (home-page "https://hackage.haskell.org/package/http-conduit")
 374     (synopsis "HTTP/HTTPS client with conduit interface")
 375     (description "This library uses attoparsec for parsing the actual
 376 contents of the HTTP connection.  It also provides higher-level functions
 377 which allow you to avoid direct usage of conduits.")
 378     (license license:bsd-3)))
 379
 380 (define-public ghc-wai
 381   (package
 382     (name "ghc-wai")
 383     (version "3.2.2.1")
 384     (source
 385      (origin
 386        (method url-fetch)
 387        (uri (string-append
 388              "https://hackage.haskell.org/package/wai/wai-"
 389              version
 390              ".tar.gz"))
 391        (sha256
 392         (base32
 393          "058871axlq6r0gcqxbjw37w57df9xbv81dmz99b1zq59wf329xzy"))))
 394     (build-system haskell-build-system)
 395     (inputs
 396      `(("ghc-bytestring-builder" ,ghc-bytestring-builder)
 397        ("ghc-unix-compat" ,ghc-unix-compat)
 398        ("ghc-vault" ,ghc-vault)
 399        ("ghc-blaze-builder" ,ghc-blaze-builder)
 400        ("ghc-network" ,ghc-network)
 401        ("ghc-http-types" ,ghc-http-types)))
 402     (native-inputs
 403      `(("hspec-discover" ,hspec-discover)
 404        ("ghc-quickcheck" ,ghc-quickcheck)
 405        ("ghc-hunit" ,ghc-hunit)
 406        ("ghc-hspec" ,ghc-hspec)))
 407     (home-page "https://hackage.haskell.org/package/wai")
 408     (synopsis "Web application interface for Haskell")
 409     (description "This package provides a Web Application Interface (WAI)
 410 library for the Haskell language.  It defines a common protocol for
 411 communication between web applications and web servers.")
 412     (license license:bsd-3)))
 413
 414 (define-public ghc-wai-logger
 415   (package
 416     (name "ghc-wai-logger")
 417     (version "2.3.5")
 418     (source
 419      (origin
 420        (method url-fetch)
 421        (uri (string-append
 422              "https://hackage.haskell.org/package/wai-logger/wai-logger-"
 423              version
 424              ".tar.gz"))
 425        (sha256
 426         (base32
 427          "05gbipyw0672irynsc3wqvvgzqixhmq69ay2mxh2phb734r8bcmm"))))
 428     (build-system haskell-build-system)
 429     (arguments `(#:tests? #f)) ; FIXME: Tests cannot find libraries exported
 430                                ; by propagated-inputs.
 431     (inputs
 432      `(("ghc-auto-update" ,ghc-auto-update)
 433        ("ghc-byteorder" ,ghc-byteorder)
 434        ("ghc-easy-file" ,ghc-easy-file)
 435        ("ghc-unix-time" ,ghc-unix-time)
 436        ("ghc-blaze-builder" ,ghc-blaze-builder)
 437        ("ghc-case-insensitive" ,ghc-case-insensitive)
 438        ("ghc-fast-logger" ,ghc-fast-logger)
 439        ("ghc-http-types" ,ghc-http-types)
 440        ("ghc-network" ,ghc-network)
 441        ("ghc-wai" ,ghc-wai)))
 442     (home-page "https://hackage.haskell.org/package/wai-logger")
 443     (synopsis "Logging system for WAI")
 444     (description "This package provides the logging system for WAI.")
 445     (license license:bsd-3)))
 446
 447 (define-public ghc-wai-extra
 448   (package
 449     (name "ghc-wai-extra")
 450     (version "3.0.28")
 451     (source
 452      (origin
 453        (method url-fetch)
 454        (uri (string-append
 455              "https://hackage.haskell.org/package/wai-extra/wai-extra-"
 456              version
 457              ".tar.gz"))
 458        (sha256
 459         (base32
 460          "0iky7k4kirngvk1p2nz19zgzffb5hppfaxdjan80v06ikc8w1wm7"))))
 461     (build-system haskell-build-system)
 462     (inputs
 463      `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
 464        ("ghc-base64-bytestring" ,ghc-base64-bytestring)
 465        ("ghc-cookie" ,ghc-cookie)
 466        ("ghc-network" ,ghc-network)
 467        ("ghc-lifted-base" ,ghc-lifted-base)
 468        ("ghc-streaming-commons" ,ghc-streaming-commons)
 469        ("ghc-stringsearch" ,ghc-stringsearch)
 470        ("ghc-resourcet" ,ghc-resourcet)
 471        ("ghc-fast-logger" ,ghc-fast-logger)
 472        ("ghc-wai-logger" ,ghc-wai-logger)
 473        ("ghc-zlib" ,ghc-zlib)
 474        ("ghc-word8" ,ghc-word8)
 475        ("ghc-iproute" ,ghc-iproute)
 476        ("ghc-void" ,ghc-void)
 477        ("ghc-wai" ,ghc-wai)
 478        ("ghc-http-types" ,ghc-http-types)
 479        ("ghc-http2" ,ghc-http2)
 480        ("ghc-case-insensitive" ,ghc-case-insensitive)
 481        ("ghc-data-default-class" ,ghc-data-default-class)
 482        ("ghc-unix-compat" ,ghc-unix-compat)
 483        ("ghc-vault" ,ghc-vault)
 484        ("ghc-aeson" ,ghc-aeson)))
 485     (native-inputs
 486      `(("hspec-discover" ,hspec-discover)
 487        ("ghc-hspec" ,ghc-hspec)
 488        ("ghc-hunit" ,ghc-hunit)))
 489     (home-page "https://github.com/yesodweb/wai")
 490     (synopsis "Some basic WAI handlers and middleware")
 491     (description "This library provides basic WAI handlers and middleware
 492 functionality.")
 493     (license license:expat)))
 494
 495 (define-public ghc-wai-conduit
 496   (package
 497     (name "ghc-wai-conduit")
 498     (version "3.0.0.4")
 499     (source
 500      (origin
 501        (method url-fetch)
 502        (uri (string-append "https://hackage.haskell.org/package/"
 503                            "wai-conduit-" version "/"
 504                            "wai-conduit-" version ".tar.gz"))
 505        (sha256
 506         (base32
 507          "07yn41rn2skd5p3wqqa09wa761vj7ibl8l19gh4bi4i8slxhk417"))))
 508     (build-system haskell-build-system)
 509     (inputs
 510      `(("ghc-conduit" ,ghc-conduit)
 511        ("ghc-http-types" ,ghc-http-types)
 512        ("ghc-wai" ,ghc-wai)
 513        ("ghc-blaze-builder" ,ghc-blaze-builder)))
 514     (home-page "https://github.com/yesodweb/wai")
 515     (synopsis "Conduit wrappers for Haskell's WAI")
 516     (description "This package provides data streaming abstraction for
 517 Haskell's Web Application Interface (WAI).")
 518     (license license:expat)))
 519
 520 (define-public ghc-bsb-http-chunked
 521   (package
 522     (name "ghc-bsb-http-chunked")
 523     (version "0.0.0.4")
 524     (source
 525      (origin
 526        (method url-fetch)
 527        (uri (string-append
 528              "https://hackage.haskell.org/package/"
 529              "bsb-http-chunked/bsb-http-chunked-"
 530              version ".tar.gz"))
 531        (sha256
 532         (base32
 533          "0z0f18yc6zlwh29c6175ivfcin325lvi4irpvv0n3cmq7vi0k0ql"))))
 534     (build-system haskell-build-system)
 535     (arguments
 536      `(;; XXX: As of 0.0.4, one property test ("Identical output as Blaze")
 537        ;; fails on i686-linux.
 538        #:tests? ,(not (string-prefix? "i686" (or (%current-target-system)
 539                                                  (%current-system))))))
 540     (native-inputs
 541      `(("ghc-attoparsec" ,ghc-attoparsec)
 542        ("ghc-blaze-builder" ,ghc-blaze-builder)
 543        ("ghc-hedgehog" ,ghc-hedgehog)
 544        ("ghc-tasty" ,ghc-tasty)
 545        ("ghc-tasty-hedgehog" ,ghc-tasty-hedgehog)
 546        ("ghc-tasty-hunit" ,ghc-tasty-hunit)
 547        ("ghc-doctest" ,ghc-doctest)))
 548     (home-page "http://github.com/sjakobi/bsb-http-chunked")
 549     (synopsis "Chunked HTTP transfer encoding for bytestring builders")
 550     (description "This Haskell library contains functions for encoding
 551 bytestring builders for chunked Hypertext Transfer Protocol (HTTP) 1.1
 552 transfers.")
 553     (license license:bsd-3)))
 554
 555 (define-public ghc-warp
 556   (package
 557     (name "ghc-warp")
 558     (version "3.2.28")
 559     (source
 560      (origin
 561        (method url-fetch)
 562        (uri (string-append "https://hackage.haskell.org/package/"
 563                            "warp-" version "/" "warp-" version
 564                            ".tar.gz"))
 565        (sha256
 566         (base32 "0w2w3aiccpb2f8zssqiszcxzqdysihqi5xply23lwif5arz4saw7"))))
 567     (build-system haskell-build-system)
 568     (inputs
 569      `(("ghc-async" ,ghc-async)
 570        ("ghc-auto-update" ,ghc-auto-update)
 571        ("ghc-bsb-http-chunked" ,ghc-bsb-http-chunked)
 572        ("ghc-case-insensitive" ,ghc-case-insensitive)
 573        ("ghc-hashable" ,ghc-hashable)
 574        ("ghc-http-types" ,ghc-http-types)
 575        ("ghc-iproute" ,ghc-iproute)
 576        ("ghc-network" ,ghc-network)
 577        ("ghc-streaming-commons" ,ghc-streaming-commons)
 578        ("ghc-time-manager" ,ghc-time-manager)
 579        ("ghc-unix-compat" ,ghc-unix-compat)
 580        ("ghc-vault" ,ghc-vault)
 581        ("ghc-wai" ,ghc-wai)
 582        ("ghc-word8" ,ghc-word8)
 583        ("ghc-http-date" ,ghc-http-date)
 584        ("ghc-simple-sendfile" ,ghc-simple-sendfile)
 585        ("ghc-http2" ,ghc-http2)))
 586     (native-inputs
 587      `(("curl" ,curl)
 588        ("ghc-silently" ,ghc-silently)
 589        ("ghc-hspec" ,ghc-hspec)
 590        ("ghc-doctest" ,ghc-doctest)
 591        ("ghc-lifted-base" ,ghc-lifted-base)
 592        ("ghc-quickcheck" ,ghc-quickcheck)
 593        ("ghc-hunit" ,ghc-hunit)
 594        ("ghc-http-client" ,ghc-http-client)
 595        ("hspec-discover" ,hspec-discover)))
 596     (home-page "http://github.com/yesodweb/wai")
 597     (synopsis "HTTP server library for Haskell's WAI")
 598     (description "Warp is a server library for HTTP/1.x and HTTP/2
 599 based WAI (Web Application Interface in Haskell).")
 600     (license license:expat)))
 601
 602 (define-public ghc-tls-session-manager
 603   (package
 604   (name "ghc-tls-session-manager")
 605   (version "0.0.3")
 606   (source
 607     (origin
 608       (method url-fetch)
 609       (uri (string-append
 610             "https://hackage.haskell.org/package/"
 611             "tls-session-manager/tls-session-manager-"
 612              version ".tar.gz"))
 613       (sha256
 614         (base32
 615           "0k57flqp2b4bipafiyfipnqmdqv04ky39yr4s4s9sx577zz2j2yi"))))
 616   (build-system haskell-build-system)
 617   (inputs
 618     `(("ghc-auto-update" ,ghc-auto-update)
 619       ("ghc-clock" ,ghc-clock)
 620       ("ghc-psqueues" ,ghc-psqueues)
 621       ("ghc-tls" ,ghc-tls)))
 622   (home-page "http://hackage.haskell.org/package/tls-session-manager")
 623   (synopsis "In-memory TLS session manager")
 624   (description "This Haskell library provides a TLS session manager with
 625 limitation, automatic pruning, energy saving and replay resistance.")
 626   (license license:bsd-3)))
 627
 628 (define-public ghc-warp-tls
 629   (package
 630     (name "ghc-warp-tls")
 631     (version "3.2.8")
 632     (source
 633      (origin
 634        (method url-fetch)
 635        (uri (string-append "https://hackage.haskell.org/package/"
 636                            "warp-tls-" version "/"
 637                            "warp-tls-" version ".tar.gz"))
 638        (sha256
 639         (base32
 640          "1z5jzl40x1gp249fk8h51gkw6m3hzxchm2bp3kbpqdgmw8r5im8y"))))
 641     (build-system haskell-build-system)
 642     (inputs
 643      `(("ghc-cryptonite" ,ghc-cryptonite)
 644        ("ghc-data-default-class" ,ghc-data-default-class)
 645        ("ghc-network" ,ghc-network)
 646        ("ghc-streaming-commons" ,ghc-streaming-commons)
 647        ("ghc-tls" ,ghc-tls)
 648        ("ghc-tls-session-manager" ,ghc-tls-session-manager)
 649        ("ghc-wai" ,ghc-wai)
 650        ("ghc-warp" ,ghc-warp)))
 651     (home-page "http://github.com/yesodweb/wai")
 652     (synopsis "SSL/TLS support for Warp")
 653     (description "This package provides SSL/TLS support for Warp,
 654 a WAI handler, via the native Haskell TLS implementation.")
 655     (license license:expat)))
 656
 657 (define-public ghc-xss-sanitize
 658   (package
 659     (name "ghc-xss-sanitize")
 660     (version "0.3.6")
 661     (source
 662      (origin
 663        (method url-fetch)
 664        (uri (string-append
 665              "https://hackage.haskell.org/package/xss-sanitize/xss-sanitize-"
 666              version ".tar.gz"))
 667        (sha256
 668         (base32
 669          "1d72s3a6520iwwc1wbn9v2znqgbw6a5wwzb23iq8ny9ccnjyx1dk"))))
 670     (build-system haskell-build-system)
 671     (inputs
 672      `(("ghc-tagsoup" ,ghc-tagsoup)
 673        ("ghc-utf8-string" ,ghc-utf8-string)
 674        ("ghc-css-text" ,ghc-css-text)
 675        ("ghc-network-uri" ,ghc-network-uri)))
 676     (native-inputs
 677      `(("ghc-attoparsec" ,ghc-attoparsec)
 678        ("ghc-hspec" ,ghc-hspec)
 679        ("ghc-hunit" ,ghc-hunit)))
 680     (home-page "https://github.com/yesodweb/haskell-xss-sanitize")
 681     (synopsis "Sanitize untrusted HTML to prevent XSS attacks")
 682     (description "This library provides @code{sanitizeXSS}.  Run untrusted
 683 HTML through @code{Text.HTML.SanitizeXSS.sanitizeXSS} to prevent XSS
 684 attacks.")
 685     (license license:bsd-3)))
 686
 687 (define-public ghc-css-text
 688   (package
 689     (name "ghc-css-text")
 690     (version "0.1.3.0")
 691     (source
 692      (origin
 693        (method url-fetch)
 694        (uri (string-append
 695              "https://hackage.haskell.org/package/css-text/css-text-"
 696              version
 697              ".tar.gz"))
 698        (sha256
 699         (base32
 700          "0ynd9f4hn2sfwqzbsa0y7phmxq8za7jiblpjwx0ry8b372zhgxaz"))))
 701     (build-system haskell-build-system)
 702     (inputs
 703      `(("ghc-attoparsec" ,ghc-attoparsec)
 704        ("ghc-hspec" ,ghc-hspec)
 705        ("ghc-quickcheck" ,ghc-quickcheck)))
 706     (home-page "http://www.yesodweb.com/")
 707     (synopsis "CSS parser and renderer")
 708     (description "This package provides a CSS parser and renderer for
 709 Haskell.")
 710     (license license:bsd-3)))
 711
 712 (define-public ghc-mime-types
 713   (package
 714     (name "ghc-mime-types")
 715     (version "0.1.0.9")
 716     (source (origin
 717               (method url-fetch)
 718               (uri (string-append "https://hackage.haskell.org/package/"
 719                                   "mime-types/mime-types-"
 720                                   version ".tar.gz"))
 721               (sha256
 722                (base32
 723                 "1lkipa4v73z3l5lqs6sdhl898iq41kyxv2jb9agsajzgd58l6cha"))))
 724     (build-system haskell-build-system)
 725     (home-page "https://github.com/yesodweb/wai")
 726     (synopsis "Basic MIME type handling types and functions")
 727     (description
 728      "This library provides basic MIME type handling types and functions.")
 729     (license license:expat)))
 730
 731 (define-public ghc-html
 732   (package
 733     (name "ghc-html")
 734     (version "1.0.1.2")
 735     (source
 736      (origin
 737        (method url-fetch)
 738        (uri (string-append
 739              "https://hackage.haskell.org/package/html/html-"
 740              version
 741              ".tar.gz"))
 742        (sha256
 743         (base32
 744          "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c"))))
 745     (build-system haskell-build-system)
 746     (home-page
 747      "https://hackage.haskell.org/package/html")
 748     (synopsis "HTML combinator library")
 749     (description
 750      "This package contains a combinator library for constructing HTML
 751 documents.")
 752     (license license:bsd-3)))
 753
 754 (define-public ghc-blaze-html
 755   (package
 756     (name "ghc-blaze-html")
 757     (version "0.9.1.2")
 758     (source
 759      (origin
 760        (method url-fetch)
 761        (uri (string-append "https://hackage.haskell.org/package/"
 762                            "blaze-html/blaze-html-"
 763                            version ".tar.gz"))
 764        (sha256
 765         (base32
 766          "0k1r1hddjgqighazcazxrx6xfhvy2gm8il8l82ainv3cai13yl30"))))
 767     (build-system haskell-build-system)
 768     (inputs
 769      `(("ghc-blaze-builder" ,ghc-blaze-builder)
 770        ("ghc-blaze-markup" ,ghc-blaze-markup)))
 771     (native-inputs
 772      `(("ghc-hunit" ,ghc-hunit)
 773        ("ghc-quickcheck" ,ghc-quickcheck)
 774        ("ghc-test-framework" ,ghc-test-framework)
 775        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
 776        ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
 777     (home-page "http://jaspervdj.be/blaze")
 778     (synopsis "Fast HTML combinator library")
 779     (description "This library provides HTML combinators for Haskell.")
 780     (license license:bsd-3)))
 781
 782 (define-public ghc-aeson
 783   (package
 784     (name "ghc-aeson")
 785     (version "1.4.5.0")
 786     (source
 787      (origin
 788        (method url-fetch)
 789        (uri (string-append
 790              "https://hackage.haskell.org/package/aeson/aeson-"
 791              version
 792              ".tar.gz"))
 793        (sha256
 794         (base32
 795          "1jhabz1lbbv6yqxqiybifi86cb5xlsadrn368n5dd0wzzc7ja4iz"))))
 796     (build-system haskell-build-system)
 797     (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
 798     (inputs
 799      `(("ghc-attoparsec" ,ghc-attoparsec)
 800        ("ghc-base-compat" ,ghc-base-compat)
 801        ("ghc-dlist" ,ghc-dlist)
 802        ("ghc-hashable" ,ghc-hashable)
 803        ("ghc-scientific" ,ghc-scientific)
 804        ("ghc-tagged" ,ghc-tagged)
 805        ("ghc-th-abstraction" ,ghc-th-abstraction)
 806        ("ghc-time-locale-compat" ,ghc-time-locale-compat)
 807        ("ghc-unordered-containers" ,ghc-unordered-containers)
 808        ("ghc-uuid-types" ,ghc-uuid-types)
 809        ("ghc-vector" ,ghc-vector)
 810        ("ghc-hunit" ,ghc-hunit)
 811        ("ghc-quickcheck" ,ghc-quickcheck)
 812        ("ghc-integer-logarithms" ,ghc-integer-logarithms)
 813        ("ghc-base-orphans" ,ghc-base-orphans)
 814        ("ghc-base16-bytestring" ,ghc-base16-bytestring)
 815        ("ghc-generic-deriving" ,ghc-generic-deriving)
 816        ("ghc-test-framework" ,ghc-test-framework)
 817        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
 818        ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
 819        ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
 820        ("ghc-hashable-time" ,ghc-hashable-time)))
 821     (home-page "https://github.com/bos/aeson")
 822     (synopsis "Fast JSON parsing and encoding")
 823     (description "This package provides a JSON parsing and encoding library
 824 for Haskell, optimized for ease of use and high performance.  (A note on
 825 naming: in Greek mythology, Aeson was the father of Jason.)")
 826     (license license:bsd-3)))
 827
 828 (define-public ghc-aeson-pretty
 829   (package
 830     (name "ghc-aeson-pretty")
 831     (version "0.8.8")
 832     (source (origin
 833               (method url-fetch)
 834               (uri (string-append
 835                     "https://hackage.haskell.org/package/aeson-pretty/aeson-pretty-"
 836                     version ".tar.gz"))
 837               (sha256
 838                (base32
 839                 "09n7gs91y1fbw6gjszrd2na3isnvk3y5rsi90lzjrwywnqfadkl1"))))
 840     (build-system haskell-build-system)
 841     (inputs
 842      `(("ghc-aeson" ,ghc-aeson)
 843        ("ghc-base-compat" ,ghc-base-compat)
 844        ("ghc-scientific" ,ghc-scientific)
 845        ("ghc-vector" ,ghc-vector)
 846        ("ghc-unordered-containers" ,ghc-unordered-containers)
 847        ("ghc-attoparsec" ,ghc-attoparsec)
 848        ("ghc-cmdargs" ,ghc-cmdargs)))
 849     (home-page "https://github.com/informatikr/aeson-pretty")
 850     (synopsis "JSON pretty-printing library and command-line tool")
 851     (description
 852      "This package provides a JSON pretty-printing library compatible with aeson
 853 as well as a command-line tool to improve readability of streams of JSON data.
 854 The library provides the function @code{encodePretty}.  It is a drop-in
 855 replacement for aeson's @code{encode} function, producing JSON-ByteStrings for
 856 human readers.  The command-line tool reads JSON from stdin and writes
 857 prettified JSON to stdout.  It also offers a complementary \"compact\"-mode,
 858 essentially the opposite of pretty-printing.")
 859     (license license:bsd-3)))
 860
 861 (define-public ghc-aeson-qq
 862   (package
 863     (name "ghc-aeson-qq")
 864     (version "0.8.2")
 865     (source (origin
 866               (method url-fetch)
 867               (uri (string-append "https://hackage.haskell.org/package/"
 868                                   "aeson-qq/aeson-qq-" version ".tar.gz"))
 869               (sha256
 870                (base32
 871                 "0ln13jqyfh5726hdrk1rad9a6cgrrj201plmwcfcpvq18v4m5ckd"))))
 872     (build-system haskell-build-system)
 873     (inputs
 874      `(("ghc-base-compat" ,ghc-base-compat)
 875        ("ghc-attoparsec" ,ghc-attoparsec)
 876        ("ghc-scientific" ,ghc-scientific)
 877        ("ghc-vector" ,ghc-vector)
 878        ("ghc-aeson" ,ghc-aeson)
 879        ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
 880     (native-inputs
 881      `(("ghc-hspec" ,ghc-hspec)
 882        ("hspec-discover" ,hspec-discover)))
 883     (home-page "https://github.com/zalora/aeson-qq")
 884     (synopsis "JSON quasiquoter for Haskell")
 885     (description
 886      "aeson-qq provides a JSON quasiquoter for Haskell.  This package exposes
 887 the function @code{aesonQQ} that compile-time converts a string representation
 888 of a JSON value into a @code{Data.Aeson.Value}.")
 889     (license license:expat)))
 890
 891 (define-public ghc-multipart
 892   (package
 893     (name "ghc-multipart")
 894     (version "0.1.3")
 895     (source
 896      (origin
 897        (method url-fetch)
 898        (uri (string-append
 899              "https://hackage.haskell.org/package/multipart/multipart-"
 900              version
 901              ".tar.gz"))
 902        (sha256
 903         (base32
 904          "1x4n4yyva22dhfr1pg5ki112qvvzb4hyd7bwpm189iq4gcp52q4z"))))
 905     (build-system haskell-build-system)
 906     (inputs
 907      `(("ghc-stringsearch" ,ghc-stringsearch)))
 908     (home-page
 909      "http://www.github.com/silkapp/multipart")
 910     (synopsis
 911      "HTTP multipart library")
 912     (description
 913      "HTTP multipart split out of the cgi package, for Haskell.")
 914     (license license:bsd-3)))
 915
 916 (define-public ghc-uri-encode
 917   (package
 918     (name "ghc-uri-encode")
 919     (version "1.5.0.5")
 920     (source
 921      (origin
 922        (method url-fetch)
 923        (uri (string-append
 924              "https://hackage.haskell.org/package/uri-encode/uri-encode-"
 925              version ".tar.gz"))
 926        (sha256
 927         (base32
 928          "11miwb5vvnn17m92ykz1pzg9x6s8fbpz3mmsyqs2s4b3mn55haz8"))))
 929     (build-system haskell-build-system)
 930     (inputs
 931      `(("ghc-utf8-string" ,ghc-utf8-string)
 932        ("ghc-network-uri" ,ghc-network-uri)))
 933     (home-page "https://hackage.haskell.org/package/uri-encode")
 934     (synopsis "Unicode aware uri-encoding")
 935     (description "Unicode aware uri-encoding for Haskell.")
 936     (license license:bsd-3)))
 937
 938 (define-public ghc-path-pieces
 939   (package
 940     (name "ghc-path-pieces")
 941     (version "0.2.1")
 942     (source
 943      (origin
 944        (method url-fetch)
 945        (uri (string-append "https://hackage.haskell.org/package/"
 946                            "path-pieces-" version "/"
 947                            "path-pieces-" version ".tar.gz"))
 948        (sha256
 949         (base32
 950          "0vx3sivcsld76058925hym2j6hm3g71f0qjr7v59f1g2afgx82q8"))))
 951     (build-system haskell-build-system)
 952     (native-inputs `(("ghc-hunit" ,ghc-hunit)
 953                      ("ghc-hspec" ,ghc-hspec)
 954                      ("ghc-quickcheck" ,ghc-quickcheck)))
 955     (home-page "https://github.com/yesodweb/path-pieces")
 956     (synopsis "Used in Yesod to automatically marshall data in the request path")
 957     (description  "This Haskell package provides two typeclasses for converting
 958 Haskell data types to and from route pieces.")
 959     (license license:bsd-3)))
 960
 961 (define-public ghc-skein
 962   (package
 963     (name "ghc-skein")
 964     (version "1.0.9.4")
 965     (source
 966      (origin
 967        (method url-fetch)
 968        (uri (string-append "https://hackage.haskell.org/package/"
 969                            "skein-" version "/"
 970                            "skein-" version ".tar.gz"))
 971        (sha256
 972         (base32
 973          "1jdqdk0rz2wnvw735clnj8jh0a9rkrbqjg7vk3w6wczdql6cm0pq"))))
 974     (build-system haskell-build-system)
 975     (inputs `(("ghc-cereal" ,ghc-cereal)
 976               ("ghc-tagged" ,ghc-tagged)
 977               ("ghc-crpto-api" ,ghc-crypto-api)))
 978     (native-inputs `(("ghc-hspec" ,ghc-hspec)))
 979     (home-page "https://github.com/yesodweb/path-pieces")
 980     (synopsis "Skein family of cryptographic hash functions for Haskell")
 981     (description "@uref{(http://www.skein-hash.info, Skein} is a family of
 982 fast secure cryptographic hash functions designed by Niels Ferguson, Stefan
 983 Lucks, Bruce Schneier, Doug Whiting, Mihir Bellare, Tadayoshi Kohno, Jon
 984 Callas and Jesse Walker.
 985
 986 This Haskell package uses bindings to the optimized C implementation of Skein.")
 987     (license license:bsd-3)))
 988
 989 (define-public ghc-clientsession
 990   (package
 991     (name "ghc-clientsession")
 992     (version "0.9.1.2")
 993     (source
 994      (origin
 995        (method url-fetch)
 996        (uri (string-append "https://hackage.haskell.org/package/"
 997                            "clientsession-" version "/"
 998                            "clientsession-" version ".tar.gz"))
 999        (sha256
1000         (base32
1001          "0s6h4ykj16mpf7nlw2iqn2ji0p8g1fn5ni0s7yqaili6vv2as5ar"))))
1002     (build-system haskell-build-system)
1003     (inputs `(("ghc-cereal" ,ghc-cereal)
1004               ("ghc-tagged" ,ghc-tagged)
1005               ("ghc-crypto-api" ,ghc-crypto-api)
1006               ("ghc-skein" ,ghc-skein)
1007               ("ghc-base64-bytestring" ,ghc-base64-bytestring)
1008               ("ghc-entropy" ,ghc-entropy)
1009               ("ghc-cprng-aes" ,ghc-cprng-aes)
1010               ("ghc-cipher-aes" ,ghc-cipher-aes)
1011               ("ghc-crypto-random" ,ghc-crypto-random)
1012               ("ghc-setenv" ,ghc-setenv)))
1013     (native-inputs `(("ghc-hunit" ,ghc-hunit)
1014                      ("ghc-hspec" ,ghc-hspec)
1015                      ("ghc-quickcheck" ,ghc-quickcheck)))
1016     (home-page "https://github.com/yesodweb/clientsession/tree/master")
1017     (synopsis "Haskell library for securely store session data in a
1018 client-side cookie")
1019     (description "This Haskell package achieves security through AES-CTR
1020 encryption and Skein-MAC-512-256 authentication.  Uses Base64 encoding to
1021 avoid any issues with characters.")
1022     (license license:expat)))
1023
1024 (define-public ghc-yesod-core
1025   (package
1026     (name "ghc-yesod-core")
1027     (version "1.6.16.1")
1028     (source
1029      (origin
1030        (method url-fetch)
1031        (uri (string-append "https://hackage.haskell.org/package/"
1032                            "yesod-core-" version "/"
1033                            "yesod-core-" version ".tar.gz"))
1034        (sha256
1035         (base32
1036          "0a0yv7wkwvb0n6iia532y9nzrirgnm09pjc8hpm0lx4ff609pgd2"))))
1037     (build-system haskell-build-system)
1038     (inputs `(("ghc-wai" ,ghc-wai)
1039               ("ghc-extra" ,ghc-extra)
1040               ("ghc-shakespeare" ,ghc-shakespeare)
1041               ("ghc-blaze-builder" ,ghc-blaze-builder)
1042               ("ghc-clientsession" ,ghc-clientsession)
1043               ("ghc-random" ,ghc-random)
1044               ("ghc-cereal" ,ghc-cereal)
1045               ("ghc-old-locale" ,ghc-old-locale)
1046               ("ghc-unliftio" ,ghc-unliftio)
1047               ("ghc-unordered-containers" ,ghc-unordered-containers)
1048               ("ghc-monad-control" ,ghc-monad-control)
1049               ("ghc-transformers-base" ,ghc-transformers-base)
1050               ("ghc-cookie" ,ghc-cookie)
1051               ("ghc-http-types" ,ghc-http-types)
1052               ("ghc-case-insensitive" ,ghc-case-insensitive)
1053               ("ghc-vector" ,ghc-vector)
1054               ("ghc-aeson" ,ghc-aeson)
1055               ("ghc-fast-logger" ,ghc-fast-logger)
1056               ("ghc-wai-logger" ,ghc-wai-logger)
1057               ("ghc-monad-logger" ,ghc-monad-logger)
1058               ("ghc-conduit" ,ghc-conduit)
1059               ("ghc-resourcet" ,ghc-resourcet)
1060               ("ghc-rio" ,ghc-rio)
1061               ("ghc-lifted-base" ,ghc-lifted-base)
1062               ("ghc-blaze-html" ,ghc-blaze-html)
1063               ("ghc-blaze-markup" ,ghc-blaze-markup)
1064               ("ghc-data-default" ,ghc-data-default)
1065               ("ghc-safe" ,ghc-safe)
1066               ("ghc-warp" ,ghc-warp)
1067               ("ghc-unix-compat" ,ghc-unix-compat)
1068               ("ghc-conduit-extra" ,ghc-conduit-extra)
1069               ("ghc-exceptions" ,ghc-exceptions)
1070               ("ghc-deepseq-generics" ,ghc-deepseq-generics)
1071               ("ghc-mwc-random" ,ghc-mwc-random)
1072               ("ghc-primitive" ,ghc-primitive)
1073               ("ghc-word8" ,ghc-word8)
1074               ("ghc-auto-update" ,ghc-auto-update)
1075               ("ghc-semigroups" ,ghc-semigroups)
1076               ("ghc-byteable" ,ghc-byteable)))
1077     (native-inputs `(("ghc-hspec" ,ghc-hspec)
1078                      ("ghc-path-pieces" ,ghc-path-pieces)
1079                      ("ghc-hunit" ,ghc-hunit)
1080                      ("ghc-hspec-expectations" ,ghc-hspec-expectations)
1081                      ("ghc-quickcheck" ,ghc-quickcheck)
1082                      ("ghc-network" ,ghc-network)
1083                      ("ghc-async" ,ghc-async)
1084                      ("ghc-streaming-commons" ,ghc-streaming-commons)
1085                      ("ghc-wai-extra" ,ghc-wai-extra)))
1086     (home-page "https://www.yesodweb.com")
1087     (synopsis "Core package for the Yesod web framework")
1088     (description "This Haskell package provides all core functionality, for
1089 Yesod, on which other packages can be built.  It provides dispatch, handler
1090 functions, widgets, etc.")
1091     (license license:expat)))
1092
1093 (define-public ghc-yesod-persistent
1094   (package
1095     (name "ghc-yesod-persistent")
1096     (version "1.6.0.2")
1097     (source
1098      (origin
1099        (method url-fetch)
1100        (uri (string-append "https://hackage.haskell.org/package/"
1101                            "yesod-persistent-" version "/"
1102                            "yesod-persistent-" version ".tar.gz"))
1103        (sha256
1104         (base32
1105          "17adw0aaj29ia7ii3jka301442860b5wvfrms079q973gzahz5fd"))))
1106     (build-system haskell-build-system)
1107     (arguments `(#:tests? #f)) ; FIXME: hspec-discover not available in PATH.
1108     (inputs `(("ghc-yesod-core" ,ghc-yesod-core)
1109               ("ghc-persistent" ,ghc-persistent)
1110               ("ghc-persistent-template" ,ghc-persistent-template)
1111               ("ghc-blaze-builder" ,ghc-blaze-builder)
1112               ("ghc-conduit" ,ghc-conduit)
1113               ("ghc-resourcet" ,ghc-resourcet)
1114               ("ghc-resource-pool" ,ghc-resource-pool)))
1115     (native-inputs `(("ghc-hspec" ,ghc-hspec)
1116                      ("ghc-wai-extra" ,ghc-wai-extra)
1117                      ("ghc-yesod-core" ,ghc-yesod-core)
1118                      ("ghc-persistent-sqlite" ,ghc-persistent-sqlite)))
1119     (home-page "http://www.yesodweb.com/")
1120     (synopsis "Helpers for using Persistent from Yesod")
1121     (description "This Haskell package provides helpers for using Persistent
1122 from Yesod.")
1123     (license license:expat)))
1124
1125 (define-public ghc-yesod-form
1126     (package
1127     (name "ghc-yesod-form")
1128     (version "1.6.7")
1129     (source
1130       (origin
1131         (method url-fetch)
1132         (uri (string-append
1133                "https://hackage.haskell.org/package/yesod-form/yesod-form-"
1134                version
1135                ".tar.gz"))
1136         (sha256
1137           (base32
1138             "0mny71dyp6cp5akyp5wvmrhmip5rkqi8ibdn3lipvmajx9h58r5d"))))
1139     (build-system haskell-build-system)
1140     (inputs
1141       `(("ghc-yesod-core" ,ghc-yesod-core)
1142         ("ghc-yesod-persistent" ,ghc-yesod-persistent)
1143         ("ghc-shakespeare" ,ghc-shakespeare)
1144         ("ghc-persistent" ,ghc-persistent)
1145         ("ghc-data-default" ,ghc-data-default)
1146         ("ghc-xss-sanitize" ,ghc-xss-sanitize)
1147         ("ghc-blaze-builder" ,ghc-blaze-builder)
1148         ("ghc-email-validate" ,ghc-email-validate)
1149         ("ghc-wai" ,ghc-wai)
1150         ("ghc-blaze-html" ,ghc-blaze-html)
1151         ("ghc-blaze-markup" ,ghc-blaze-markup)
1152         ("ghc-attoparsec" ,ghc-attoparsec)
1153         ("ghc-byteable" ,ghc-byteable)
1154         ("ghc-aeson" ,ghc-aeson)
1155         ("ghc-resourcet" ,ghc-resourcet)
1156         ("ghc-semigroups" ,ghc-semigroups)
1157         ("ghc-network-uri" ,ghc-network-uri)
1158         ("ghc-hspec" ,ghc-hspec)))
1159     (home-page "https://www.yesodweb.com")
1160     (synopsis "Form handling support for Yesod Web Framework")
1161     (description "This Haskell package provies a set of basic form inputs such
1162 as text, number, time, checkbox, select, textarea, etc through the
1163 @code{Yesod.Form.Fields} module.  Also, there is @code{Yesod.Form.Nic} module
1164 providing richtext field using Nic editor. ")
1165     (license license:expat)))
1166
1167 (define-public ghc-yesod
1168   (package
1169     (name "ghc-yesod")
1170     (version "1.6.0")
1171     (source
1172      (origin
1173        (method url-fetch)
1174        (uri (string-append
1175              "https://hackage.haskell.org/package/yesod/yesod-"
1176              version ".tar.gz"))
1177        (sha256
1178         (base32
1179          "0wx77nbpzdh40p1bm527kimfj48vs9d2avpvvz2w42zi3pz2y94a"))))
1180     (build-system haskell-build-system)
1181     (inputs
1182      `(("ghc-yesod-core" ,ghc-yesod-core)
1183        ("ghc-yesod-persistent" ,ghc-yesod-persistent)
1184        ("ghc-yesod-form" ,ghc-yesod-form)
1185        ("ghc-monad-control" ,ghc-monad-control)
1186        ("ghc-wai" ,ghc-wai)
1187        ("ghc-wai-extra" ,ghc-wai-extra)
1188        ("ghc-warp" ,ghc-warp)
1189        ("ghc-blaze-html" ,ghc-blaze-html)
1190        ("ghc-blaze-markup" ,ghc-blaze-markup)
1191        ("ghc-aeson" ,ghc-aeson)
1192        ("ghc-data-default-class" ,ghc-data-default-class)
1193        ("ghc-unordered-containers" ,ghc-unordered-containers)
1194        ("ghc-yaml" ,ghc-yaml)
1195        ("ghc-monad-logger" ,ghc-monad-logger)
1196        ("ghc-fast-logger" ,ghc-fast-logger)
1197        ("ghc-conduit" ,ghc-conduit)
1198        ("ghc-conduit-extra" ,ghc-conduit-extra)
1199        ("ghc-resourcet" ,ghc-resourcet)
1200        ("ghc-shakespeare" ,ghc-shakespeare)
1201        ("ghc-streaming-commons" ,ghc-streaming-commons)
1202        ("ghc-wai-logger" ,ghc-wai-logger)
1203        ("ghc-semigroups" ,ghc-semigroups)))
1204     (home-page "https://www.yesodweb.com")
1205     (synopsis "Framework for creating type-safe, RESTful web applications")
1206     (description "The Haskell package package groups together the various
1207 Yesod related packages into one cohesive whole.  This is the version of Yesod,
1208 whereas most of the core code lives in @code{ghc-yesod-core}.")
1209     (license license:expat)))
1210
1211 (define-public ghc-hxt-charproperties
1212   (package
1213     (name "ghc-hxt-charproperties")
1214     (version "9.4.0.0")
1215     (source
1216      (origin
1217        (method url-fetch)
1218        (uri (string-append "https://hackage.haskell.org/package/"
1219                            "hxt-charproperties/hxt-charproperties-"
1220                            version ".tar.gz"))
1221        (sha256
1222         (base32
1223          "1bk88hj2pqlvcnyfncqyb9j7w9vvdxcq3cgr0w2l09c0abas23pm"))))
1224     (build-system haskell-build-system)
1225     (home-page "https://github.com/UweSchmidt/hxt")
1226     (synopsis "Character properties and classes for XML and Unicode")
1227     (description
1228      "The modules provided by this package contain predicates for Unicode
1229 blocks and char properties and character predicates defined by XML.  The
1230 supported Unicode version is 7.0.0")
1231     (license license:expat)))
1232
1233 (define-public ghc-hxt-unicode
1234   (package
1235     (name "ghc-hxt-unicode")
1236     (version "9.0.2.4")
1237     (source
1238      (origin
1239        (method url-fetch)
1240        (uri (string-append
1241              "https://hackage.haskell.org/package/hxt-unicode/hxt-unicode-"
1242              version
1243              ".tar.gz"))
1244        (sha256
1245         (base32
1246          "0rj48cy8z4fl3zpg5bpa458kqr83adav6jnqv4i71dclpprj6n3v"))))
1247     (build-system haskell-build-system)
1248     (inputs
1249      `(("ghc-hxt-charproperties" ,ghc-hxt-charproperties)))
1250     (home-page
1251      "http://www.fh-wedel.de/~si/HXmlToolbox/index.html https://github.com/UweSchmidt/hxt")
1252     (synopsis
1253      "Unicode en-/decoding functions for utf8, iso-latin-* and other encodings")
1254     (description
1255      "This package provides Unicode encoding and decoding functions for
1256 encodings used in the Haskell XML Toolbox.  ISO Latin 1-16, utf8, utf16, ASCII
1257 are supported. Decoding is done with lazy functions, errors may be detected or
1258 ignored.")
1259     (license license:expat)))
1260
1261 (define-public ghc-hxt-regex-xmlschema
1262   (package
1263     (name "ghc-hxt-regex-xmlschema")
1264     (version "9.2.0.3")
1265     (source
1266      (origin
1267        (method url-fetch)
1268        (uri (string-append "https://hackage.haskell.org/package/"
1269                            "hxt-regex-xmlschema/hxt-regex-xmlschema-"
1270                            version ".tar.gz"))
1271        (sha256
1272         (base32
1273          "1c4jr0439f5yc05h7iz53fa47g6l2wrvqp6gvwf01mlqajk3nx7l"))))
1274     (build-system haskell-build-system)
1275     (inputs
1276      `(("ghc-hxt-charproperties" ,ghc-hxt-charproperties)
1277        ("ghc-hunit" ,ghc-hunit)))
1278     (home-page "http://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema")
1279     (synopsis "Regular expression library for W3C XML Schema regular expressions")
1280     (description
1281      "This library supports full W3C XML Schema regular expressions inclusive
1282 all Unicode character sets and blocks.  It is implemented by the technique of
1283 derivations of regular expressions.")
1284     (license license:expat)))
1285
1286 (define-public ghc-hxt
1287   (package
1288     (name "ghc-hxt")
1289     (version "9.3.1.18")
1290     (source
1291      (origin
1292        (method url-fetch)
1293        (uri (string-append
1294              "https://hackage.haskell.org/package/hxt/hxt-"
1295              version
1296              ".tar.gz"))
1297        (sha256
1298         (base32
1299          "0836k65px3w9c5h1h2bmzq5a7mp6ajxwvfg3pfr2kbxwkgc0j63j"))))
1300     (build-system haskell-build-system)
1301     (inputs
1302      `(("ghc-hxt-charproperties" ,ghc-hxt-charproperties)
1303        ("ghc-hxt-unicode" ,ghc-hxt-unicode)
1304        ("ghc-hxt-regex-xmlschema" ,ghc-hxt-regex-xmlschema)
1305        ("ghc-network-uri" ,ghc-network-uri)))
1306     (home-page "https://github.com/UweSchmidt/hxt")
1307     (synopsis "Collection of tools for processing XML with Haskell")
1308     (description
1309      "The Haskell XML Toolbox bases on the ideas of HaXml and HXML, but
1310 introduces a more general approach for processing XML with Haskell.")
1311     (license license:expat)))
1312
1313 (define-public ghc-http-common
1314   (package
1315     (name "ghc-http-common")
1316     (version "0.8.2.0")
1317     (source
1318      (origin
1319        (method url-fetch)
1320        (uri (string-append "https://hackage.haskell.org/package/"
1321                            "http-common/http-common-" version ".tar.gz"))
1322        (sha256
1323         (base32
1324          "14s5a178sb2vm5k00rs21760mds5dz2gs10k9iyn22h01mxyf599"))))
1325     (build-system haskell-build-system)
1326     (inputs
1327      `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
1328        ("ghc-blaze-builder" ,ghc-blaze-builder)
1329        ("ghc-case-insensitive" ,ghc-case-insensitive)
1330        ("ghc-network" ,ghc-network)
1331        ("ghc-unordered-containers" ,ghc-unordered-containers)))
1332     (home-page "https://github.com/afcowie/http-streams/")
1333     (synopsis "Common types for HTTP clients and servers")
1334     (description "Base types used by a variety of HTTP clients and
1335 servers.  See http-streams @code{Network.Http.Client} or pipes-http
1336 @code{Pipes.Http.Client} for full documentation.  You can import
1337 @code{Network.Http.Types} if you like, but both http-streams and
1338 pipes-http re-export this package's types and functions.")
1339     (license license:bsd-3)))
1340
1341 (define-public ghc-http-streams
1342   (package
1343     (name "ghc-http-streams")
1344     (version "0.8.6.1")
1345     (source
1346      (origin
1347        (method url-fetch)
1348        (uri (string-append "https://hackage.haskell.org/package/"
1349                            "http-streams/http-streams-" version ".tar.gz"))
1350        (sha256
1351         (base32
1352          "18vxd35n7s3z4gjvad94bknc8z1w9d7ccgphnhsxlz5cackizmxq"))))
1353     (build-system haskell-build-system)
1354     (inputs
1355      `(("ghc-attoparsec" ,ghc-attoparsec)
1356        ("ghc-base64-bytestring" ,ghc-base64-bytestring)
1357        ("ghc-blaze-builder" ,ghc-blaze-builder)
1358        ("ghc-case-insensitive" ,ghc-case-insensitive)
1359        ("ghc-io-streams" ,ghc-io-streams)
1360        ("ghc-hsopenssl" ,ghc-hsopenssl)
1361        ("ghc-openssl-streams" ,ghc-openssl-streams)
1362        ("ghc-unordered-containers" ,ghc-unordered-containers)
1363        ("ghc-aeson" ,ghc-aeson)
1364        ("ghc-http-common" ,ghc-http-common)
1365        ("ghc-network-uri" ,ghc-network-uri)
1366        ("ghc-network" ,ghc-network)))
1367     (arguments
1368      `(#:tests? #f)) ; tests rely on an outdated version of snap-server
1369     (home-page "https://github.com/afcowie/http-streams/")
1370     (synopsis "HTTP client using io-streams")
1371     (description "An HTTP client using the Snap Framework's io-streams
1372 library to handle the streaming IO.  The API is optimized for ease of
1373 use for the rather common case of code needing to query web services and
1374 deal with the result.")
1375     (license license:bsd-3)))
1376
1377 (define-public ghc-snap-core
1378   (package
1379     (name "ghc-snap-core")
1380     (version "1.0.4.0")
1381     (source
1382      (origin
1383        (method url-fetch)
1384        (uri (string-append "https://hackage.haskell.org/package/"
1385                            "snap-core/snap-core-" version ".tar.gz"))
1386        (sha256
1387         (base32
1388          "0dklxgrbqhnb6bc4ic358g4fyj11ywmjrkxxhqcjmci2hhpn00mr"))))
1389     (build-system haskell-build-system)
1390     (inputs
1391      `(("ghc-old-locale" ,ghc-old-locale)
1392        ("ghc-hunit" ,ghc-hunit)
1393        ("ghc-attoparsec" ,ghc-attoparsec)
1394        ("ghc-bytestring-builder" ,ghc-bytestring-builder)
1395        ("ghc-case-insensitive" ,ghc-case-insensitive)
1396        ("ghc-lifted-base" ,ghc-lifted-base)
1397        ("ghc-io-streams" ,ghc-io-streams)
1398        ("ghc-hashable" ,ghc-hashable)
1399        ("ghc-monad-control" ,ghc-monad-control)
1400        ("ghc-random" ,ghc-random)
1401        ("ghc-readable" ,ghc-readable)
1402        ("ghc-regex-posix" ,ghc-regex-posix)
1403        ("ghc-transformers-base" ,ghc-transformers-base)
1404        ("ghc-unix-compat" ,ghc-unix-compat)
1405        ("ghc-unordered-containers" ,ghc-unordered-containers)
1406        ("ghc-vector" ,ghc-vector)
1407        ("ghc-network-uri" ,ghc-network-uri)
1408        ("ghc-network" ,ghc-network)))
1409     (native-inputs
1410      `(("ghc-quickcheck" ,ghc-quickcheck)
1411        ("ghc-parallel" ,ghc-parallel)
1412        ("ghc-test-framework" ,ghc-test-framework)
1413        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
1414        ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
1415        ("ghc-zlib" ,ghc-zlib)))
1416     (home-page "http://snapframework.com/")
1417     (synopsis "Haskell Web Framework (core interfaces and types)")
1418     (description "Snap is a simple and fast web development framework
1419 and server written in Haskell.  For more information, you can visit the
1420 Snap project website at @uref{http://snapframework.com/}.  This library
1421 contains the core definitions and types for the Snap framework.")
1422     (license license:bsd-3)))
1423
1424 (define-public ghc-snap-server
1425   (package
1426     (name "ghc-snap-server")
1427     (version "1.1.1.1")
1428     (source
1429      (origin
1430        (method url-fetch)
1431        (uri (string-append "https://hackage.haskell.org/package/"
1432                            "snap-server/snap-server-" version ".tar.gz"))
1433        (sha256
1434         (base32
1435          "0lw475wp0lnrbgc3jcfif3qjjc3pmrh2k74d8cgpnc1304g6a2s5"))))
1436     (build-system haskell-build-system)
1437     (inputs
1438      `(("ghc-attoparsec" ,ghc-attoparsec)
1439        ("ghc-blaze-builder" ,ghc-blaze-builder)
1440        ("ghc-bytestring-builder" ,ghc-bytestring-builder)
1441        ("ghc-case-insensitive" ,ghc-case-insensitive)
1442        ("ghc-clock" ,ghc-clock)
1443        ("ghc-io-streams" ,ghc-io-streams)
1444        ("ghc-io-streams-haproxy" ,ghc-io-streams-haproxy)
1445        ("ghc-lifted-base" ,ghc-lifted-base)
1446        ("ghc-network" ,ghc-network)
1447        ("ghc-old-locale" ,ghc-old-locale)
1448        ("ghc-snap-core" ,ghc-snap-core)
1449        ("ghc-unix-compat" ,ghc-unix-compat)
1450        ("ghc-vector" ,ghc-vector)))
1451     (native-inputs
1452      `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
1453        ("ghc-monad-control" ,ghc-monad-control)
1454        ("ghc-random" ,ghc-random)
1455        ("ghc-threads" ,ghc-threads)
1456        ("ghc-hunit" ,ghc-hunit)
1457        ("ghc-quickcheck" ,ghc-quickcheck)
1458        ("ghc-http-streams" ,ghc-http-streams)
1459        ("ghc-http-common" ,ghc-http-common)
1460        ("ghc-parallel" ,ghc-parallel)
1461        ("ghc-test-framework" ,ghc-test-framework)
1462        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
1463        ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
1464     (arguments
1465      `(#:cabal-revision
1466        ("1" "094b7ll47lxd4lvr6kd59jyw0vz686gw5cx16w758d6fli0cy3x3")))
1467     (home-page "http://snapframework.com/")
1468     (synopsis "Web server for the Snap Framework")
1469     (description "Snap is a simple and fast web development framework
1470 and server written in Haskell.  For more information, you can visit the
1471 Snap project website at @uref{http://snapframework.com/}.  The Snap HTTP
1472 server is a high performance web server library written in Haskell.
1473 Together with the snap-core library upon which it depends, it provides a
1474 clean and efficient Haskell programming interface to the HTTP
1475 protocol.")
1476     (license license:bsd-3)))
1477
1478 (define-public ghc-js-jquery
1479   (package
1480     (name "ghc-js-jquery")
1481     (version "3.3.1")
1482     (source
1483      (origin
1484        (method url-fetch)
1485        (uri
1486         (string-append
1487          "https://hackage.haskell.org/package/js-jquery/js-jquery-"
1488          version ".tar.gz"))
1489        (sha256
1490         (base32
1491          "16q68jzbs7kp07dnq8cprdcc8fd41rim38039vg0w4x11lgniq70"))))
1492     (build-system haskell-build-system)
1493     (arguments `(#:tests? #f)) ; tests do network IO
1494     (home-page "https://github.com/ndmitchell/js-jquery")
1495     (synopsis "Obtain minified jQuery code")
1496     (description "This package bundles the minified
1497 @url{http://jquery.com/, jQuery} code into a Haskell package, so it can
1498 be depended upon by Cabal packages.  The first three components of the
1499 version number match the upstream jQuery version.  The package is
1500 designed to meet the redistribution requirements of downstream
1501 users (e.g. Debian).")
1502     (license license:expat)))
1503
1504 (define-public ghc-js-flot
1505   (package
1506     (name "ghc-js-flot")
1507     (version "0.8.3")
1508     (source
1509      (origin
1510        (method url-fetch)
1511        (uri
1512         (string-append
1513          "https://hackage.haskell.org/package/js-flot/js-flot-"
1514          version ".tar.gz"))
1515        (sha256
1516         (base32
1517          "0yjyzqh3qzhy5h3nql1fckw0gcfb0f4wj9pm85nafpfqp2kg58hv"))))
1518     (build-system haskell-build-system)
1519     (inputs
1520      `(("ghc-http" ,ghc-http)))
1521     (home-page "https://github.com/ndmitchell/js-flot")
1522     (synopsis "Obtain minified flot code")
1523     (description "This package bundles the minified
1524 @url{http://www.flotcharts.org/, Flot} code (a jQuery plotting library)
1525 into a Haskell package, so it can be depended upon by Cabal packages.
1526 The first three components of the version number match the upstream flot
1527 version.  The package is designed to meet the redistribution
1528 requirements of downstream users (e.g. Debian).")
1529     (license license:expat)))
1530
1531 (define-public ghc-happstack-server
1532   (package
1533     (name "ghc-happstack-server")
1534     (version "7.5.4")
1535     (source
1536      (origin
1537        (method url-fetch)
1538        (uri (string-append
1539              "https://hackage.haskell.org/package/happstack-server/happstack-server-"
1540              version ".tar.gz"))
1541        (sha256
1542         (base32
1543          "0i7csvmwv7n68gkwqzi985p2mjdgzipjnlj873sdiknhx9pfmq70"))))
1544     (build-system haskell-build-system)
1545     (inputs
1546      `(("ghc-network" ,ghc-network)
1547        ("ghc-network-bsd" ,ghc-network-bsd)
1548        ("ghc-network-uri" ,ghc-network-uri)
1549        ("ghc-base64-bytestring" ,ghc-base64-bytestring)
1550        ("ghc-blaze-html" ,ghc-blaze-html)
1551        ("ghc-exceptions" ,ghc-exceptions)
1552        ("ghc-extensible-exceptions"
1553         ,ghc-extensible-exceptions)
1554        ("ghc-hslogger" ,ghc-hslogger)
1555        ("ghc-html" ,ghc-html)
1556        ("ghc-monad-control" ,ghc-monad-control)
1557        ("ghc-old-locale" ,ghc-old-locale)
1558        ("ghc-semigroups" ,ghc-semigroups)
1559        ("ghc-sendfile" ,ghc-sendfile)
1560        ("ghc-system-filepath" ,ghc-system-filepath)
1561        ("ghc-syb" ,ghc-syb)
1562        ("ghc-threads" ,ghc-threads)
1563        ("ghc-transformers-base" ,ghc-transformers-base)
1564        ("ghc-transformers-compat"
1565         ,ghc-transformers-compat)
1566        ("ghc-utf8-string" ,ghc-utf8-string)
1567        ("ghc-zlib" ,ghc-zlib)))
1568     (native-inputs `(("ghc-hunit" ,ghc-hunit)))
1569     (home-page "http://happstack.com")
1570     (synopsis "Web related tools and services for Haskell")
1571     (description
1572      "Happstack Server provides an HTTP server and a rich set of functions for
1573 routing requests, handling query parameters, generating responses, working with
1574 cookies, serving files, and more.")
1575     (license license:bsd-3)))
1576
1577 (define-public ghc-sendfile
1578   (package
1579     (name "ghc-sendfile")
1580     (version "0.7.11.1")
1581     (source
1582      (origin
1583        (method url-fetch)
1584        (uri (string-append
1585              "https://hackage.haskell.org/package/sendfile/sendfile-"
1586              version ".tar.gz"))
1587        (sha256
1588         (base32
1589          "0988snmx3bylpw3kcq8hsgji8idc6xcrcfp275qjv3apfdgc9rp0"))))
1590     (build-system haskell-build-system)
1591     (inputs `(("ghc-network" ,ghc-network)))
1592     (home-page
1593      "https://hub.darcs.net/stepcut/sendfile")
1594     (synopsis "Portable sendfile library for Haskell")
1595     (description
1596      "Haskell library which exposes zero-copy sendfile functionality in a portable way.")
1597     (license license:bsd-3)))