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