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