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 ;;; Copyright © 2020 Marius Bakke <marius@gnu.org>
  12 ;;; Copyright © 2020, 2022 Kyle Meyer <kyle@kyleam.com>
  13 ;;; Copyright © 2020 Alexandru-Sergiu Marton <brown121407@member.fsf.org>
  14 ;;; Copyright © 2020 Giacomo Leidi <goodoldpaul@autistici.org>
  15 ;;; Copyright © 2022 Alice Brenon <alice.brenon@ens-lyon.fr>
  16 ;;;
  17 ;;; This file is part of GNU Guix.
  18 ;;;
  19 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  20 ;;; under the terms of the GNU General Public License as published by
  21 ;;; the Free Software Foundation; either version 3 of the License, or (at
  22 ;;; your option) any later version.
  23 ;;;
  24 ;;; GNU Guix is distributed in the hope that it will be useful, but
  25 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  26 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27 ;;; GNU General Public License for more details.
  28 ;;;
  29 ;;; You should have received a copy of the GNU General Public License
  30 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  31
  32 (define-module (gnu packages haskell-web)
  33   #:use-module (gnu packages)
  34   #:use-module (gnu packages curl)
  35   #:use-module (gnu packages haskell)
  36   #:use-module (gnu packages haskell-check)
  37   #:use-module (gnu packages haskell-crypto)
  38   #:use-module (gnu packages haskell-xyz)
  39   #:use-module (guix build-system haskell)
  40   #:use-module (guix download)
  41   #:use-module ((guix licenses) #:prefix license:)
  42   #:use-module (guix packages)
  43   #:use-module (guix utils))
  44
  45 (define-public ghc-tagsoup
  46   (package
  47     (name "ghc-tagsoup")
  48     (version "0.14.8")
  49     (source
  50      (origin
  51        (method url-fetch)
  52        (uri (string-append "https://hackage.haskell.org/package/tagsoup/"
  53                            "tagsoup-" version ".tar.gz"))
  54        (sha256
  55         (base32
  56          "1m9sx6gr9y9yxvkmcap8xsks8cnhznvma1mrfl39zljkv005azms"))))
  57     (build-system haskell-build-system)
  58     (native-inputs
  59      (list ghc-quickcheck))
  60     (home-page "https://github.com/ndmitchell/tagsoup")
  61     (synopsis
  62      "Parsing and extracting information from (possibly malformed) HTML/XML
  63 documents")
  64     (description
  65      "TagSoup is a library for parsing HTML/XML.  It supports the HTML 5
  66 specification, and can be used to parse either well-formed XML, or
  67 unstructured and malformed HTML from the web.  The library also provides
  68 useful functions to extract information from an HTML document, making it ideal
  69 for screen-scraping.")
  70     (license license:bsd-3)))
  71
  72 (define-public ghc-cookie
  73   (package
  74     (name "ghc-cookie")
  75     (version "0.4.5")
  76     (source
  77      (origin
  78        (method url-fetch)
  79        (uri (string-append
  80              "https://hackage.haskell.org/package/cookie/cookie-"
  81              version
  82              ".tar.gz"))
  83        (sha256
  84         (base32
  85          "10rmdasb7mypbwxdj2mhr810vqhkakpik7hyd8fvj60hng8r8zvh"))))
  86     (build-system haskell-build-system)
  87     (inputs
  88      (list ghc-old-locale
  89            ghc-blaze-builder
  90            ghc-data-default-class
  91            ghc-hunit
  92            ghc-quickcheck
  93            ghc-tasty
  94            ghc-tasty-hunit
  95            ghc-tasty-quickcheck))
  96     (home-page "https://github.com/snoyberg/cookie")
  97     (synopsis "HTTP cookie parsing and rendering")
  98     (description "HTTP cookie parsing and rendering library for Haskell.")
  99     (license license:bsd-3)))
 100
 101 (define-public ghc-curl
 102   (package
 103     (name "ghc-curl")
 104     (version "1.3.8")
 105     (source (origin
 106               (method url-fetch)
 107               (uri (string-append "mirror://hackage/package/curl/curl-"
 108                                   version ".tar.gz"))
 109               (sha256
 110                (base32
 111                 "0vj4hpaa30jz7c702xpsfvqaqdxz28zslsqnsfx6bf6dpwvck1wh"))))
 112     (build-system haskell-build-system)
 113     (inputs
 114      (list curl))
 115     (home-page "https://hackage.haskell.org/package/curl")
 116     (synopsis "Haskell bindings for libcurl")
 117     (description
 118      "@code{libcurl} is a versatile client-side URL transfer library.
 119 This package provides a Haskell binding to libcurl.")
 120     (license license:bsd-3)))
 121
 122 (define-public ghc-httpd-shed
 123   (package
 124     (name "ghc-httpd-shed")
 125     (version "0.4.1.1")
 126     (source
 127      (origin
 128        (method url-fetch)
 129        (uri (string-append "https://hackage.haskell.org/package/httpd-shed/"
 130                            "httpd-shed-" version ".tar.gz"))
 131        (sha256
 132         (base32
 133          "19dgdimpzr7pxk7pqvyin6j87gmvnf0rm35gzhmna8qr835wy3sr"))))
 134     (build-system haskell-build-system)
 135     (inputs
 136      (list ghc-network-bsd ghc-network-uri ghc-network))
 137     (home-page "https://hackage.haskell.org/package/httpd-shed")
 138     (synopsis "Simple web-server with an interact style API")
 139     (description
 140      "This web server promotes a function from @code{Request} to @code{IO
 141 Response} into a local web server.  The user can decide how to interpret the
 142 requests, and the library is intended for implementing Ajax APIs.")
 143     (license license:bsd-3)))
 144
 145 (define-public ghc-http-types
 146   (package
 147     (name "ghc-http-types")
 148     (version "0.12.3")
 149     (source
 150      (origin
 151        (method url-fetch)
 152        (uri (string-append "https://hackage.haskell.org/package/http-types/"
 153                            "http-types-" version ".tar.gz"))
 154        (sha256
 155         (base32
 156          "05j00b9nqmwh9zaq9y9x50k81v2pd3j7a71kd91zlnbl8xk4m2jf"))))
 157     (build-system haskell-build-system)
 158     (native-inputs
 159      (list ghc-doctest ghc-hspec ghc-quickcheck ghc-quickcheck-instances
 160            hspec-discover))
 161     (inputs
 162      (list ghc-case-insensitive))
 163     (home-page "https://github.com/aristidb/http-types")
 164     (synopsis "Generic HTTP types for Haskell")
 165     (description "This package provides generic HTTP types for Haskell (for
 166 both client and server code).")
 167     (license license:bsd-3)))
 168
 169 (define-public ghc-http
 170   (package
 171     (name "ghc-http")
 172     (version "4000.3.16")
 173     (outputs '("out" "static" "doc"))
 174     (source
 175      (origin
 176        (method url-fetch)
 177        (uri (string-append "https://hackage.haskell.org/package/HTTP/"
 178                            "HTTP-" version ".tar.gz"))
 179        (sha256
 180         (base32
 181          "0bgyj3ahqlyg0jw6qsm2sncp8mklc4h0dj91s043vb3ig01iq2fn"))))
 182     (build-system haskell-build-system)
 183     (native-inputs
 184      (list ghc-httpd-shed ghc-hunit ghc-test-framework
 185            ghc-test-framework-hunit))
 186     (inputs
 187      (list ghc-case-insensitive
 188            ghc-conduit
 189            ghc-conduit-extra
 190            ghc-http-types
 191            ghc-old-time
 192            ghc-puremd5
 193            ghc-network
 194            ghc-network-uri
 195            ghc-split))
 196     (arguments
 197      `(#:tests? #f  ; FIXME: currently missing libraries used for tests.
 198        #:phases
 199        (modify-phases %standard-phases
 200          (add-after 'unpack 'create-simple-paths-module
 201            (lambda _
 202              (call-with-output-file "Paths_HTTP.hs"
 203                (lambda (port)
 204                  (format port "\
 205 {-# LANGUAGE CPP #-}
 206 {-# LANGUAGE NoRebindableSyntax #-}
 207 {-# OPTIONS_GHC -fno-warn-missing-import-lists #-}
 208 module Paths_HTTP (version) where
 209 import Data.Version (Version(..))
 210 version :: Version
 211 version = Version [~a] []
 212 " (string-map (lambda (chr) (if (eq? chr #\.) #\, chr)) ,version))))
 213              #t)))))
 214     (home-page "https://github.com/haskell/HTTP")
 215     (synopsis "Library for client-side HTTP")
 216     (description
 217      "The HTTP package supports client-side web programming in Haskell.  It
 218 lets you set up HTTP connections, transmitting requests and processing the
 219 responses coming back.")
 220     (license license:bsd-3)))
 221
 222 (define-public ghc-http-client
 223   (package
 224     (name "ghc-http-client")
 225     (version "0.7.11")
 226     (source (origin
 227               (method url-fetch)
 228               (uri (string-append "https://hackage.haskell.org/package/"
 229                                   "http-client/http-client-"
 230                                   version ".tar.gz"))
 231               (sha256
 232                (base32
 233                 "12j7vkpkm2djws6ny7vm2324c7916d0iaf1mbvf4mfjxzy2w7imv"))))
 234     (build-system haskell-build-system)
 235     ;; Tests require access to the web.
 236     (arguments `(#:tests? #f))
 237     (inputs
 238      (list ghc-async
 239            ghc-base64-bytestring
 240            ghc-blaze-builder
 241            ghc-case-insensitive
 242            ghc-cookie
 243            ghc-data-default-class
 244            ghc-exceptions
 245            ghc-http-types
 246            ghc-iproute
 247            ghc-memory
 248            ghc-mime-types
 249            ghc-monad-control
 250            ghc-network
 251            ghc-network-uri
 252            ghc-random
 253            ghc-streaming-commons
 254            ghc-zlib))
 255     (native-inputs
 256      (list ghc-hspec))
 257     (home-page "https://github.com/snoyberg/http-client")
 258     (synopsis "HTTP client engine")
 259     (description
 260      "This package provides an HTTP client engine, intended as a base layer
 261 for more user-friendly packages.")
 262     (license license:expat)))
 263
 264 (define-public ghc-http-client-tls
 265   (package
 266     (name "ghc-http-client-tls")
 267     (version "0.3.6.1")
 268     (source (origin
 269               (method url-fetch)
 270               (uri (string-append "https://hackage.haskell.org/package/"
 271                                   "http-client-tls/http-client-tls-"
 272                                   version ".tar.gz"))
 273               (sha256
 274                (base32
 275                 "03f8p9gxdzl6slyw1r6vpv2dqhsyjvbaawbjv75kaq0vlj3gz7xi"))))
 276     (build-system haskell-build-system)
 277     ;; Tests require Internet access
 278     (arguments `(#:tests? #f))
 279     (inputs
 280      (list ghc-data-default-class
 281            ghc-http-client
 282            ghc-connection
 283            ghc-network
 284            ghc-tls
 285            ghc-http-types))
 286     (native-inputs
 287      (list ghc-hspec))
 288     (home-page "https://github.com/snoyberg/http-client")
 289     (synopsis "Backend for http-client using the TLS library")
 290     (description
 291      "This package provides a backend for the http-client package using the
 292 connection and TLS libraries.  It is intended for use by higher-level
 293 libraries, such as http-conduit.")
 294     (license license:expat)))
 295
 296 (define-public ghc-http-client-restricted
 297   (package
 298     (name "ghc-http-client-restricted")
 299     (version "0.0.5")
 300     (source
 301      (origin
 302        (method url-fetch)
 303        (uri (hackage-uri "http-client-restricted" version))
 304        (sha256
 305         (base32 "1vfm9qc3zr0rmq2ddgyg13i67020cdk8xqhyzfc2zcn1km2p6r85"))))
 306     (build-system haskell-build-system)
 307     (inputs
 308      (list ghc-http-client
 309            ghc-http-client-tls
 310            ghc-connection
 311            ghc-data-default
 312            ghc-network
 313            ghc-network-bsd
 314            ghc-utf8-string))
 315     (home-page "http://hackage.haskell.org/package/http-client-restricted")
 316     (synopsis "Restrict the servers used by http-client")
 317     (description
 318      "This library makes it possible to restrict the HTTP servers that can be
 319 used by the @code{http-client} and @code{http-client-tls} libraries.  This is
 320 useful when a security policy needs to, e.g., prevent connections to HTTP
 321 servers on localhost or only allow connections to a specific server.")
 322     (license license:expat)))
 323
 324 (define-public ghc-http-date
 325   (package
 326     (name "ghc-http-date")
 327     (version "0.0.11")
 328     (source
 329      (origin
 330        (method url-fetch)
 331        (uri (string-append "https://hackage.haskell.org/package/"
 332                            "http-date-" version "/"
 333                            "http-date-" version ".tar.gz"))
 334        (sha256
 335         (base32
 336          "1lzlrj2flcnz3k5kfhf11nk5n8m6kcya0lkwrsnzxgfr3an27y9j"))))
 337     (build-system haskell-build-system)
 338     (inputs
 339      (list ghc-attoparsec))
 340     (native-inputs
 341      (list ghc-doctest ghc-hspec hspec-discover ghc-old-locale))
 342     (home-page "https://github.com/kazu-yamamoto/http-date")
 343     (synopsis "HTTP Date parser/formatter")
 344     (description "Library for Parsing and formatting HTTP
 345 Date in Haskell.")
 346     (license license:bsd-3)))
 347
 348 (define-public ghc-http2
 349   (package
 350     (name "ghc-http2")
 351     (version "3.0.2")
 352     (source
 353      (origin
 354        (method url-fetch)
 355        (uri (string-append "https://hackage.haskell.org/package/"
 356                            "http2-" version "/"
 357                            "http2-" version ".tar.gz"))
 358        (sha256
 359         (base32
 360          "13c2z35gdimncgpyg5dn5cpjvd83rbrigc8b40crg36678m0k0d1"))))
 361     (build-system haskell-build-system)
 362     (inputs
 363      (list ghc-aeson
 364            ghc-aeson-pretty
 365            ghc-base16-bytestring
 366            ghc-case-insensitive
 367            ghc-cryptonite
 368            ghc-http-types
 369            ghc-network-byte-order
 370            ghc-network
 371            ghc-network-run
 372            ghc-psqueues
 373            ghc-time-manager
 374            ghc-unix-time
 375            ghc-unordered-containers
 376            ghc-vector
 377            ghc-word8))
 378     (native-inputs
 379      (list ghc-async
 380            ghc-doctest
 381            ghc-glob
 382            ghc-hspec
 383            hspec-discover
 384            ghc-typed-process))
 385     (home-page "https://github.com/kazu-yamamoto/http2")
 386     (synopsis "HTTP/2 library including frames, priority queues and HPACK")
 387     (description "This package provides a HTTP/2.0 library including frames
 388 and HPACK.  Currently HTTP/2 16 framing and HPACK 10 is supported.")
 389     (license license:bsd-3)))
 390
 391 (define-public ghc-http-conduit
 392   (package
 393     (name  "ghc-http-conduit")
 394     (version "2.3.8")
 395     (source
 396      (origin
 397        (method url-fetch)
 398        (uri (string-append "https://hackage.haskell.org/package/"
 399                            "http-conduit-" version "/" "http-conduit-"
 400                            version ".tar.gz"))
 401        (sha256
 402         (base32
 403          "1bj24phbcb7s3k6v48l5gk82m3m23j8zy9l7c5ccxp3ghn9z5gng"))))
 404     (build-system haskell-build-system)
 405     ;; FIXME: `httpLbs TLS` in test-suite `test` fails with
 406     ;; ConnectionFailure getProtocolByName: does not exist (no such protocol
 407     ;; name: tcp)
 408     (arguments `(#:tests? #f))
 409     (inputs
 410      (list ghc-aeson
 411            ghc-resourcet
 412            ghc-conduit
 413            ghc-conduit-extra
 414            ghc-http-types
 415            ghc-lifted-base
 416            ghc-http-client
 417            ghc-http-client-tls
 418            ghc-monad-control
 419            ghc-exceptions
 420            ghc-unliftio))
 421     (native-inputs
 422      (list ghc-hunit
 423            ghc-hspec
 424            ghc-data-default-class
 425            ghc-connection
 426            ghc-warp-tls
 427            ghc-blaze-builder
 428            ghc-conduit
 429            ghc-utf8-string
 430            ghc-case-insensitive
 431            ghc-lifted-base
 432            ghc-network
 433            ghc-wai
 434            ghc-warp
 435            ghc-wai-conduit
 436            ghc-http-types
 437            ghc-cookie
 438            ghc-conduit-extra
 439            ghc-streaming-commons
 440            ghc-aeson
 441            ghc-temporary
 442            ghc-resourcet))
 443     (home-page "https://hackage.haskell.org/package/http-conduit")
 444     (synopsis "HTTP/HTTPS client with conduit interface")
 445     (description "This library uses attoparsec for parsing the actual
 446 contents of the HTTP connection.  It also provides higher-level functions
 447 which allow you to avoid direct usage of conduits.")
 448     (license license:bsd-3)))
 449
 450 (define-public ghc-http-reverse-proxy
 451   (package
 452     (name "ghc-http-reverse-proxy")
 453     (version "0.6.0")
 454     (source
 455      (origin
 456        (method url-fetch)
 457        (uri (string-append
 458              "https://hackage.haskell.org/package/http-reverse-proxy/"
 459              "http-reverse-proxy-" version ".tar.gz"))
 460        (sha256
 461         (base32
 462          "1a6i5njf85b2lhg8m83njagcf09wih5q2irnyb2890s724qr277v"))))
 463     (build-system haskell-build-system)
 464     (inputs
 465      (list ghc-case-insensitive
 466            ghc-http-types
 467            ghc-word8
 468            ghc-blaze-builder
 469            ghc-http-client
 470            ghc-wai
 471            ghc-network
 472            ghc-conduit
 473            ghc-conduit-extra
 474            ghc-wai-logger
 475            ghc-resourcet
 476            ghc-unliftio
 477            ghc-streaming-commons))
 478     (native-inputs
 479      (list ghc-hspec ghc-warp ghc-http-conduit))
 480     (home-page
 481      "https://github.com/fpco/http-reverse-proxy")
 482     (synopsis
 483      "Reverse proxy HTTP requests, either over raw sockets or with WAI")
 484     (description
 485      "Provides a simple means of reverse-proxying HTTP requests.  The raw
 486 approach uses the same technique as leveraged by keter, whereas the WAI
 487 approach performs full request/response parsing via WAI and http-conduit.")
 488     (license license:bsd-3)))
 489
 490 (define-public ghc-wai
 491   (package
 492     (name "ghc-wai")
 493     (version "3.2.3")
 494     (source
 495      (origin
 496        (method url-fetch)
 497        (uri (string-append
 498              "https://hackage.haskell.org/package/wai/wai-"
 499              version
 500              ".tar.gz"))
 501        (sha256
 502         (base32
 503          "1y19h9v0cq1fl17ywcyyvd6419fhgyw2s0yk0ki8z60021adcx2m"))))
 504     (build-system haskell-build-system)
 505     (inputs
 506      (list ghc-bytestring-builder
 507            ghc-unix-compat
 508            ghc-vault
 509            ghc-blaze-builder
 510            ghc-network
 511            ghc-http-types))
 512     (native-inputs
 513      (list hspec-discover ghc-quickcheck ghc-hunit ghc-hspec))
 514     (home-page "https://hackage.haskell.org/package/wai")
 515     (synopsis "Web application interface for Haskell")
 516     (description "This package provides a Web Application Interface (WAI)
 517 library for the Haskell language.  It defines a common protocol for
 518 communication between web applications and web servers.")
 519     (license license:bsd-3)))
 520
 521 (define-public ghc-wai-logger
 522   (package
 523     (name "ghc-wai-logger")
 524     (version "2.3.6")
 525     (source
 526      (origin
 527        (method url-fetch)
 528        (uri (string-append
 529              "https://hackage.haskell.org/package/wai-logger/wai-logger-"
 530              version
 531              ".tar.gz"))
 532        (sha256
 533         (base32
 534          "0hbm7if28p6qa36cgpyq6i569275si53z9gsl2g1z8x09z3xiyz2"))))
 535     (build-system haskell-build-system)
 536     (arguments `(#:tests? #f)) ; FIXME: Tests cannot find libraries exported
 537                                ; by propagated-inputs.
 538     (inputs
 539      (list ghc-auto-update
 540            ghc-byteorder
 541            ghc-easy-file
 542            ghc-unix-time
 543            ghc-blaze-builder
 544            ghc-case-insensitive
 545            ghc-fast-logger
 546            ghc-http-types
 547            ghc-network
 548            ghc-wai))
 549     (home-page "https://hackage.haskell.org/package/wai-logger")
 550     (synopsis "Logging system for WAI")
 551     (description "This package provides the logging system for WAI.")
 552     (license license:bsd-3)))
 553
 554 (define-public ghc-wai-extra
 555   (package
 556     (name "ghc-wai-extra")
 557     (version "3.1.7")
 558     (source
 559      (origin
 560        (method url-fetch)
 561        (uri (string-append
 562              "https://hackage.haskell.org/package/wai-extra/wai-extra-"
 563              version
 564              ".tar.gz"))
 565        (sha256
 566         (base32
 567          "1avf7bjcsbs8l6klp5kkd0cd2dc5n0j0a2yf8813pnwfn5b7qyd4"))))
 568     (build-system haskell-build-system)
 569     (inputs
 570      (list ghc-ansi-terminal
 571            ghc-base64-bytestring
 572            ghc-call-stack
 573            ghc-cookie
 574            ghc-network
 575            ghc-streaming-commons
 576            ghc-resourcet
 577            ghc-fast-logger
 578            ghc-wai-logger
 579            ghc-word8
 580            ghc-iproute
 581            ghc-wai
 582            ghc-http-types
 583            ghc-http2
 584            ghc-case-insensitive
 585            ghc-data-default-class
 586            ghc-vault
 587            ghc-aeson))
 588     (native-inputs
 589      (list hspec-discover ghc-hspec ghc-hunit ghc-zlib))
 590     (home-page "https://github.com/yesodweb/wai")
 591     (synopsis "Some basic WAI handlers and middleware")
 592     (description "This library provides basic WAI handlers and middleware
 593 functionality.")
 594     (license license:expat)))
 595
 596 (define-public ghc-wai-conduit
 597   (package
 598     (name "ghc-wai-conduit")
 599     (version "3.0.0.4")
 600     (source
 601      (origin
 602        (method url-fetch)
 603        (uri (string-append "https://hackage.haskell.org/package/"
 604                            "wai-conduit-" version "/"
 605                            "wai-conduit-" version ".tar.gz"))
 606        (sha256
 607         (base32
 608          "07yn41rn2skd5p3wqqa09wa761vj7ibl8l19gh4bi4i8slxhk417"))))
 609     (build-system haskell-build-system)
 610     (inputs
 611      (list ghc-conduit ghc-http-types ghc-wai ghc-blaze-builder))
 612     (home-page "https://github.com/yesodweb/wai")
 613     (synopsis "Conduit wrappers for Haskell's WAI")
 614     (description "This package provides data streaming abstraction for
 615 Haskell's Web Application Interface (WAI).")
 616     (license license:expat)))
 617
 618 (define-public ghc-bsb-http-chunked
 619   (package
 620     (name "ghc-bsb-http-chunked")
 621     (version "0.0.0.4")
 622     (source
 623      (origin
 624        (method url-fetch)
 625        (uri (string-append
 626              "https://hackage.haskell.org/package/"
 627              "bsb-http-chunked/bsb-http-chunked-"
 628              version ".tar.gz"))
 629        (sha256
 630         (base32
 631          "0z0f18yc6zlwh29c6175ivfcin325lvi4irpvv0n3cmq7vi0k0ql"))))
 632     (build-system haskell-build-system)
 633     (arguments
 634      `(;; XXX: As of 0.0.4, one property test ("Identical output as Blaze")
 635        ;; fails on i686-linux.
 636        #:tests? ,(and (not (%current-target-system))
 637                       (not (string-prefix? "i686" (or (%current-target-system)
 638                                                       (%current-system)))))
 639        #:cabal-revision
 640        ("3" "15hg352id2f4x0dnvv47bdiz6gv5hp5a2mki9yzmhc7ajpk31mdd")))
 641     (native-inputs
 642      (list ghc-attoparsec
 643            ghc-blaze-builder
 644            ghc-hedgehog
 645            ghc-tasty
 646            ghc-tasty-hedgehog
 647            ghc-tasty-hunit
 648            ghc-doctest))
 649     (home-page "https://github.com/sjakobi/bsb-http-chunked")
 650     (synopsis "Chunked HTTP transfer encoding for bytestring builders")
 651     (description "This Haskell library contains functions for encoding
 652 bytestring builders for chunked Hypertext Transfer Protocol (HTTP) 1.1
 653 transfers.")
 654     (license license:bsd-3)))
 655
 656 (define-public ghc-warp
 657   (package
 658     (name "ghc-warp")
 659     (version "3.3.17")
 660     (source
 661      (origin
 662        (method url-fetch)
 663        (uri (string-append "https://hackage.haskell.org/package/"
 664                            "warp-" version "/" "warp-" version
 665                            ".tar.gz"))
 666        (sha256
 667         (base32 "0v54ca3wpa79gdyiikwhbv9h8b5vr3d60piq3ndb2v7s7fi1qpm0"))))
 668     (build-system haskell-build-system)
 669     (inputs
 670      (list ghc-async
 671            ghc-auto-update
 672            ghc-bsb-http-chunked
 673            ghc-case-insensitive
 674            ghc-hashable
 675            ghc-http-types
 676            ghc-iproute
 677            ghc-network
 678            ghc-streaming-commons
 679            ghc-time-manager
 680            ghc-unix-compat
 681            ghc-vault
 682            ghc-wai
 683            ghc-word8
 684            ghc-http-date
 685            ghc-simple-sendfile
 686            ghc-unliftio
 687            ghc-x509
 688            ghc-http2))
 689     (native-inputs
 690      (list curl
 691            ghc-silently
 692            ghc-hspec
 693            ghc-doctest
 694            ghc-lifted-base
 695            ghc-quickcheck
 696            ghc-hunit
 697            ghc-http-client
 698            hspec-discover))
 699     (home-page "https://github.com/yesodweb/wai")
 700     (synopsis "HTTP server library for Haskell's WAI")
 701     (description "Warp is a server library for HTTP/1.x and HTTP/2
 702 based WAI (Web Application Interface in Haskell).")
 703     (license license:expat)))
 704
 705 (define-public ghc-tls-session-manager
 706   (package
 707   (name "ghc-tls-session-manager")
 708   (version "0.0.4")
 709   (source
 710     (origin
 711       (method url-fetch)
 712       (uri (string-append
 713             "https://hackage.haskell.org/package/"
 714             "tls-session-manager/tls-session-manager-"
 715              version ".tar.gz"))
 716       (sha256
 717         (base32
 718           "134kb5nz668f4xrr5g98g7fc1bwb3ri6q433a1i6asjkniwpy85s"))))
 719   (build-system haskell-build-system)
 720   (inputs
 721     (list ghc-auto-update ghc-clock ghc-psqueues ghc-tls))
 722   (home-page "https://hackage.haskell.org/package/tls-session-manager")
 723   (synopsis "In-memory TLS session manager")
 724   (description "This Haskell library provides a TLS session manager with
 725 limitation, automatic pruning, energy saving and replay resistance.")
 726   (license license:bsd-3)))
 727
 728 (define-public ghc-warp-tls
 729   (package
 730     (name "ghc-warp-tls")
 731     (version "3.3.2")
 732     (source
 733      (origin
 734        (method url-fetch)
 735        (uri (string-append "https://hackage.haskell.org/package/"
 736                            "warp-tls-" version "/"
 737                            "warp-tls-" version ".tar.gz"))
 738        (sha256
 739         (base32
 740          "0b9viw26ymzq4q8snfddz3w59sqcf5ankxnw6f99iacxjhk6zs6m"))))
 741     (build-system haskell-build-system)
 742     (inputs
 743      (list ghc-cryptonite
 744            ghc-data-default-class
 745            ghc-network
 746            ghc-streaming-commons
 747            ghc-tls
 748            ghc-tls-session-manager
 749            ghc-unliftio
 750            ghc-wai
 751            ghc-warp))
 752     (home-page "https://github.com/yesodweb/wai")
 753     (synopsis "SSL/TLS support for Warp")
 754     (description "This package provides SSL/TLS support for Warp,
 755 a WAI handler, via the native Haskell TLS implementation.")
 756     (license license:expat)))
 757
 758 (define-public ghc-websockets
 759   (package
 760     (name "ghc-websockets")
 761     (version "0.12.7.2")
 762     (source
 763      (origin
 764        (method url-fetch)
 765        (uri (string-append
 766              "https://hackage.haskell.org/package/websockets/websockets-"
 767              version
 768              ".tar.gz"))
 769        (sha256
 770         (base32
 771          "1b92a41l2var1ccg350mh2bjmb2plb6d79yzvmlwkd41nifmmi44"))))
 772     (build-system haskell-build-system)
 773     (inputs
 774      (list ghc-attoparsec
 775            ghc-base64-bytestring
 776            ghc-bytestring-builder
 777            ghc-case-insensitive
 778            ghc-network
 779            ghc-random
 780            ghc-sha
 781            ghc-clock
 782            ghc-async
 783            ghc-streaming-commons
 784            ghc-entropy))
 785     (native-inputs
 786      (list ghc-hunit ghc-quickcheck ghc-test-framework
 787            ghc-test-framework-hunit ghc-test-framework-quickcheck2))
 788     (home-page "https://jaspervdj.be/websockets/")
 789     (synopsis
 790      "Write WebSocket-capable servers in Haskell")
 791     (description
 792      "This library allows you to write WebSocket-capable servers.
 793
 794 An example server:
 795 @url{https://github.com/jaspervdj/websockets/blob/master/example/server.lhs}
 796 An example client:
 797 @url{https://github.com/jaspervdj/websockets/blob/master/example/client.hs}
 798
 799 See also:
 800 @itemize
 801 @item The specification of the WebSocket protocol:
 802 @url{http://www.whatwg.org/specs/web-socket-protocol/}
 803 @item The JavaScript API for dealing with WebSockets:
 804 @url{http://www.w3.org/TR/websockets/}
 805 @end itemize")
 806     (license license:bsd-3)))
 807
 808 (define-public ghc-wai-websockets
 809   (package
 810     (name "ghc-wai-websockets")
 811     (version "3.0.1.2")
 812     (source
 813      (origin
 814        (method url-fetch)
 815        (uri (string-append
 816              "mirror://hackage/package/wai-websockets/wai-websockets-"
 817              version
 818              ".tar.gz"))
 819        (sha256
 820         (base32
 821          "0b2xmdsrsqpssyib53wbr6r8hf75789ndyyanv37sv99iyqcwz4i"))))
 822     (build-system haskell-build-system)
 823     (inputs
 824      (list ghc-wai ghc-case-insensitive ghc-network ghc-websockets
 825            ghc-http-types))
 826     (arguments
 827      `(#:configure-flags '("--flags=-example")))
 828     (home-page "https://github.com/yesodweb/wai")
 829     (synopsis
 830      "Provide a bridge between WAI and the websockets package")
 831     (description
 832      "Use websockets with WAI applications, primarily those hosted via Warp.")
 833     (license license:expat)))
 834
 835 (define-public ghc-xss-sanitize
 836   (package
 837     (name "ghc-xss-sanitize")
 838     (version "0.3.6")
 839     (source
 840      (origin
 841        (method url-fetch)
 842        (uri (string-append
 843              "https://hackage.haskell.org/package/xss-sanitize/xss-sanitize-"
 844              version ".tar.gz"))
 845        (sha256
 846         (base32
 847          "1d72s3a6520iwwc1wbn9v2znqgbw6a5wwzb23iq8ny9ccnjyx1dk"))))
 848     (build-system haskell-build-system)
 849     (inputs
 850      (list ghc-tagsoup ghc-utf8-string ghc-css-text ghc-network-uri))
 851     (native-inputs
 852      (list ghc-attoparsec ghc-hspec ghc-hunit))
 853     (home-page "https://github.com/yesodweb/haskell-xss-sanitize")
 854     (synopsis "Sanitize untrusted HTML to prevent XSS attacks")
 855     (description "This library provides @code{sanitizeXSS}.  Run untrusted
 856 HTML through @code{Text.HTML.SanitizeXSS.sanitizeXSS} to prevent XSS
 857 attacks.")
 858     (license license:bsd-3)))
 859
 860 (define-public ghc-css-text
 861   (package
 862     (name "ghc-css-text")
 863     (version "0.1.3.0")
 864     (source
 865      (origin
 866        (method url-fetch)
 867        (uri (string-append
 868              "https://hackage.haskell.org/package/css-text/css-text-"
 869              version
 870              ".tar.gz"))
 871        (sha256
 872         (base32
 873          "0ynd9f4hn2sfwqzbsa0y7phmxq8za7jiblpjwx0ry8b372zhgxaz"))))
 874     (build-system haskell-build-system)
 875     (inputs
 876      (list ghc-attoparsec ghc-hspec ghc-quickcheck))
 877     (home-page "https://www.yesodweb.com/")
 878     (synopsis "CSS parser and renderer")
 879     (description "This package provides a CSS parser and renderer for
 880 Haskell.")
 881     (license license:bsd-3)))
 882
 883 (define-public ghc-mime-types
 884   (package
 885     (name "ghc-mime-types")
 886     (version "0.1.0.9")
 887     (source (origin
 888               (method url-fetch)
 889               (uri (string-append "https://hackage.haskell.org/package/"
 890                                   "mime-types/mime-types-"
 891                                   version ".tar.gz"))
 892               (sha256
 893                (base32
 894                 "1lkipa4v73z3l5lqs6sdhl898iq41kyxv2jb9agsajzgd58l6cha"))))
 895     (build-system haskell-build-system)
 896     (home-page "https://github.com/yesodweb/wai")
 897     (synopsis "Basic MIME type handling types and functions")
 898     (description
 899      "This library provides basic MIME type handling types and functions.")
 900     (license license:expat)))
 901
 902 (define-public ghc-html
 903   (package
 904     (name "ghc-html")
 905     (version "1.0.1.2")
 906     (source
 907      (origin
 908        (method url-fetch)
 909        (uri (string-append
 910              "https://hackage.haskell.org/package/html/html-"
 911              version
 912              ".tar.gz"))
 913        (sha256
 914         (base32
 915          "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c"))))
 916     (build-system haskell-build-system)
 917     (home-page
 918      "https://hackage.haskell.org/package/html")
 919     (synopsis "HTML combinator library")
 920     (description
 921      "This package contains a combinator library for constructing HTML
 922 documents.")
 923     (license license:bsd-3)))
 924
 925 (define-public ghc-html-conduit
 926   (package
 927     (name "ghc-html-conduit")
 928     (version "1.3.2.2")
 929     (source
 930      (origin
 931        (method url-fetch)
 932        (uri (string-append
 933              "https://hackage.haskell.org/package/html-conduit/"
 934              "html-conduit-" version ".tar.gz"))
 935        (sha256
 936         (base32
 937          "09bwrdam3y47kqllgg6w098ghqb8jb10dp4wxirsvx5ddpx9zpi6"))))
 938     (build-system haskell-build-system)
 939     (inputs
 940      (list ghc-resourcet
 941            ghc-conduit
 942            ghc-xml-conduit
 943            ghc-xml-types
 944            ghc-attoparsec
 945            ghc-conduit-extra))
 946     (native-inputs
 947      (list ghc-hspec ghc-hunit))
 948     (home-page "https://github.com/snoyberg/xml")
 949     (synopsis "Parse HTML documents using xml-conduit datatypes")
 950     (description
 951      "This package provides a parser for HTML documents that uses
 952 tagstream-conduit.  It automatically balances mismatched tags, so that
 953 there shouldn't be any parse failures.  It does not handle a full HTML
 954 document rendering, such as adding missing html and head tags.  Note that,
 955 since version 1.3.1, it uses an inlined copy of tagstream-conduit with
 956 entity decoding bugfixes applied.")
 957     (license license:expat)))
 958
 959 (define-public ghc-blaze-html
 960   (package
 961     (name "ghc-blaze-html")
 962     (version "0.9.1.2")
 963     (source
 964      (origin
 965        (method url-fetch)
 966        (uri (string-append "https://hackage.haskell.org/package/"
 967                            "blaze-html/blaze-html-"
 968                            version ".tar.gz"))
 969        (sha256
 970         (base32
 971          "0k1r1hddjgqighazcazxrx6xfhvy2gm8il8l82ainv3cai13yl30"))))
 972     (build-system haskell-build-system)
 973     (arguments
 974      `(#:tests? #f ; TODO: Depends on quickcheck<2.14
 975        #:cabal-revision
 976        ("1" "0wvlfb3rd9cm3p894p5rl9kggrsr5da3n8x9ydrbagx91yvkxns9")))
 977     (inputs
 978      (list ghc-blaze-builder ghc-blaze-markup))
 979     (native-inputs
 980      (list ghc-hunit ghc-quickcheck ghc-test-framework
 981            ghc-test-framework-hunit ghc-test-framework-quickcheck2))
 982     (home-page "http://jaspervdj.be/blaze")
 983     (synopsis "Fast HTML combinator library")
 984     (description "This library provides HTML combinators for Haskell.")
 985     (license license:bsd-3)))
 986
 987 (define-public ghc-aeson
 988   (package
 989     (name "ghc-aeson")
 990     (version "1.5.6.0")
 991     (source
 992      (origin
 993        (method url-fetch)
 994        (uri (string-append
 995              "https://hackage.haskell.org/package/aeson/aeson-"
 996              version
 997              ".tar.gz"))
 998        (sha256
 999         (base32
1000          "1s5z4bgb5150h6a4cjf5vh8dmyrn6ilh29gh05999v6jwd5w6q83"))))
1001     (build-system haskell-build-system)
1002     (arguments
1003      `(#:tests? #f ; FIXME: testing libraries are missing.
1004        #:cabal-revision
1005        ("2" "1zxkarvmbgc2cpcc9sx1rlqm7nfh473052898ypiwk8azawp1hbj")))
1006     (outputs '("out" "static" "doc"))
1007     (inputs
1008      (list ghc-attoparsec
1009            ghc-base-compat-batteries
1010            ghc-data-fix
1011            ghc-dlist
1012            ghc-hashable
1013            ghc-primitive
1014            ghc-scientific
1015            ghc-strict
1016            ghc-tagged
1017            ghc-th-abstraction
1018            ghc-these
1019            ghc-time-compat
1020            ghc-unordered-containers
1021            ghc-uuid-types
1022            ghc-vector))
1023 ;    (native-inputs
1024 ;     `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
1025 ;       ("ghc-base-compat" ,ghc-base-compat)
1026 ;       ("ghc-base-orphans" ,ghc-base-orphans)
1027 ;       ("ghc-diff" ,ghc-diff)
1028 ;       ("ghc-generic-deriving" ,ghc-generic-deriving)
1029 ;       ("ghc-hashable-time" ,ghc-hashable-time)
1030 ;       ("ghc-integer-logarithms" ,ghc-integer-logarithms)
1031 ;       ("ghc-quickcheck" ,ghc-quickcheck)
1032 ;       ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
1033 ;       ("ghc-tasty" ,ghc-tasty)
1034 ;       ("ghc-tasty-golden" ,ghc-tasty-golden)
1035 ;       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
1036 ;       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
1037     (home-page "https://github.com/bos/aeson")
1038     (synopsis "Fast JSON parsing and encoding")
1039     (description "This package provides a JSON parsing and encoding library
1040 for Haskell, optimized for ease of use and high performance.  (A note on
1041 naming: in Greek mythology, Aeson was the father of Jason.)")
1042     (license license:bsd-3)))
1043
1044 (define-public ghc-aeson-pretty
1045   (package
1046     (name "ghc-aeson-pretty")
1047     (version "0.8.9")
1048     (source (origin
1049               (method url-fetch)
1050               (uri (string-append
1051                     "https://hackage.haskell.org/package/aeson-pretty/aeson-pretty-"
1052                     version ".tar.gz"))
1053               (sha256
1054                (base32
1055                 "021az9az6xik9c9s3rnar5fr1lgy2h3igibf5ixnc7ps3m2lzg2x"))))
1056     (build-system haskell-build-system)
1057     (inputs
1058      (list ghc-aeson
1059            ghc-base-compat
1060            ghc-scientific
1061            ghc-vector
1062            ghc-unordered-containers
1063            ghc-attoparsec
1064            ghc-cmdargs))
1065     (home-page "https://github.com/informatikr/aeson-pretty")
1066     (synopsis "JSON pretty-printing library and command-line tool")
1067     (description
1068      "This package provides a JSON pretty-printing library compatible with aeson
1069 as well as a command-line tool to improve readability of streams of JSON data.
1070 The library provides the function @code{encodePretty}.  It is a drop-in
1071 replacement for aeson's @code{encode} function, producing JSON-ByteStrings for
1072 human readers.  The command-line tool reads JSON from stdin and writes
1073 prettified JSON to stdout.  It also offers a complementary \"compact\"-mode,
1074 essentially the opposite of pretty-printing.")
1075     (license license:bsd-3)))
1076
1077 (define-public ghc-aeson-qq
1078   (package
1079     (name "ghc-aeson-qq")
1080     (version "0.8.4")
1081     (source (origin
1082               (method url-fetch)
1083               (uri (string-append "https://hackage.haskell.org/package/"
1084                                   "aeson-qq/aeson-qq-" version ".tar.gz"))
1085               (sha256
1086                (base32
1087                 "0dpklq2xdhrkg1rdc7zfdjnzm6c3qxx2i1xskrqdxpqi84ffnlyh"))))
1088     (build-system haskell-build-system)
1089     (inputs
1090      (list ghc-base-compat
1091            ghc-attoparsec
1092            ghc-scientific
1093            ghc-vector
1094            ghc-aeson
1095            ghc-haskell-src-meta))
1096     (native-inputs
1097      (list ghc-hspec hspec-discover))
1098     (home-page "https://github.com/zalora/aeson-qq")
1099     (synopsis "JSON quasiquoter for Haskell")
1100     (description
1101      "aeson-qq provides a JSON quasiquoter for Haskell.  This package exposes
1102 the function @code{aesonQQ} that compile-time converts a string representation
1103 of a JSON value into a @code{Data.Aeson.Value}.")
1104     (license license:expat)))
1105
1106 (define-public ghc-aeson-better-errors
1107   (package
1108     (name "ghc-aeson-better-errors")
1109     (version "0.9.1.0")
1110     (source
1111      (origin
1112        (method url-fetch)
1113        (uri (string-append
1114              "mirror://hackage/package/aeson-better-errors/aeson-better-errors-"
1115              version
1116              ".tar.gz"))
1117        (sha256
1118         (base32
1119          "09vkyrhwak3bmpfsqcd2az8hfqqkxyhg468hv5avgisy0nzh3w38"))))
1120     (build-system haskell-build-system)
1121     (inputs
1122      (list ghc-aeson
1123            ghc-unordered-containers
1124            ghc-dlist
1125            ghc-scientific
1126            ghc-vector
1127            ghc-transformers-compat
1128            ghc-void))
1129     (home-page
1130      "https://github.com/hdgarrood/aeson-better-errors")
1131     (synopsis
1132      "Better error messages when decoding JSON values in Haskell")
1133     (description
1134      "Gives you the tools to build parsers to decode JSON values, and gives
1135 good error messages when parsing fails.  See also
1136 @url{http://harry.garrood.me/blog/aeson-better-errors/}.")
1137     (license license:expat)))
1138
1139 (define-public ghc-multipart
1140   (package
1141     (name "ghc-multipart")
1142     (version "0.2.1")
1143     (source
1144      (origin
1145        (method url-fetch)
1146        (uri (string-append
1147              "https://hackage.haskell.org/package/multipart/multipart-"
1148              version
1149              ".tar.gz"))
1150        (sha256
1151         (base32
1152          "0p6n4knxpjv70nbl6cmd6x7gkdjsjqp4ya7fz00bfrqp7jvhlivn"))))
1153     (build-system haskell-build-system)
1154     (inputs
1155      (list ghc-stringsearch))
1156     (home-page
1157      "http://www.github.com/silkapp/multipart")
1158     (synopsis
1159      "HTTP multipart library")
1160     (description
1161      "HTTP multipart split out of the cgi package, for Haskell.")
1162     (license license:bsd-3)))
1163
1164 (define-public ghc-uri-encode
1165   (package
1166     (name "ghc-uri-encode")
1167     (version "1.5.0.7")
1168     (source
1169      (origin
1170        (method url-fetch)
1171        (uri (string-append
1172              "https://hackage.haskell.org/package/uri-encode/uri-encode-"
1173              version ".tar.gz"))
1174        (sha256
1175         (base32
1176          "0lj2h701af12539p957rw24bxr07mfqd5r4h52i42f43ax165767"))))
1177     (build-system haskell-build-system)
1178     (inputs
1179      (list ghc-utf8-string ghc-network-uri))
1180     (home-page "https://hackage.haskell.org/package/uri-encode")
1181     (synopsis "Unicode aware uri-encoding")
1182     (description "Unicode aware uri-encoding for Haskell.")
1183     (license license:bsd-3)))
1184
1185 (define-public ghc-path-pieces
1186   (package
1187     (name "ghc-path-pieces")
1188     (version "0.2.1")
1189     (source
1190      (origin
1191        (method url-fetch)
1192        (uri (string-append "https://hackage.haskell.org/package/"
1193                            "path-pieces-" version "/"
1194                            "path-pieces-" version ".tar.gz"))
1195        (sha256
1196         (base32
1197          "0vx3sivcsld76058925hym2j6hm3g71f0qjr7v59f1g2afgx82q8"))))
1198     (build-system haskell-build-system)
1199     (native-inputs (list ghc-hunit ghc-hspec ghc-quickcheck))
1200     (home-page "https://github.com/yesodweb/path-pieces")
1201     (synopsis "Used in Yesod to automatically marshall data in the request path")
1202     (description  "This Haskell package provides two typeclasses for converting
1203 Haskell data types to and from route pieces.")
1204     (license license:bsd-3)))
1205
1206 (define-public ghc-skein
1207   (package
1208     (name "ghc-skein")
1209     (version "1.0.9.4")
1210     (source
1211      (origin
1212        (method url-fetch)
1213        (uri (string-append "https://hackage.haskell.org/package/"
1214                            "skein-" version "/"
1215                            "skein-" version ".tar.gz"))
1216        (sha256
1217         (base32
1218          "1jdqdk0rz2wnvw735clnj8jh0a9rkrbqjg7vk3w6wczdql6cm0pq"))))
1219     (build-system haskell-build-system)
1220     (inputs (list ghc-cereal ghc-tagged ghc-crypto-api))
1221     (native-inputs (list ghc-hspec))
1222     (home-page "https://github.com/yesodweb/path-pieces")
1223     (synopsis "Skein family of cryptographic hash functions for Haskell")
1224     (description "@uref{(http://www.skein-hash.info, Skein} is a family of
1225 fast secure cryptographic hash functions designed by Niels Ferguson, Stefan
1226 Lucks, Bruce Schneier, Doug Whiting, Mihir Bellare, Tadayoshi Kohno, Jon
1227 Callas and Jesse Walker.
1228
1229 This Haskell package uses bindings to the optimized C implementation of Skein.")
1230     (license license:bsd-3)))
1231
1232 (define-public ghc-clientsession
1233   (package
1234     (name "ghc-clientsession")
1235     (version "0.9.1.2")
1236     (source
1237      (origin
1238        (method url-fetch)
1239        (uri (string-append "https://hackage.haskell.org/package/"
1240                            "clientsession-" version "/"
1241                            "clientsession-" version ".tar.gz"))
1242        (sha256
1243         (base32
1244          "0s6h4ykj16mpf7nlw2iqn2ji0p8g1fn5ni0s7yqaili6vv2as5ar"))))
1245     (build-system haskell-build-system)
1246     (inputs (list ghc-cereal
1247                   ghc-tagged
1248                   ghc-crypto-api
1249                   ghc-skein
1250                   ghc-base64-bytestring
1251                   ghc-entropy
1252                   ghc-cprng-aes
1253                   ghc-cipher-aes
1254                   ghc-crypto-random
1255                   ghc-setenv))
1256     (native-inputs (list ghc-hunit ghc-hspec ghc-quickcheck))
1257     (home-page "https://github.com/yesodweb/clientsession/tree/master")
1258     (synopsis "Haskell library for securely store session data in a
1259 client-side cookie")
1260     (description "This Haskell package achieves security through AES-CTR
1261 encryption and Skein-MAC-512-256 authentication.  Uses Base64 encoding to
1262 avoid any issues with characters.")
1263     (license license:expat)))
1264
1265 (define-public ghc-yesod-core
1266   (package
1267     (name "ghc-yesod-core")
1268     (version "1.6.21.0")
1269     (source
1270      (origin
1271        (method url-fetch)
1272        (uri (string-append "https://hackage.haskell.org/package/"
1273                            "yesod-core-" version "/"
1274                            "yesod-core-" version ".tar.gz"))
1275        (sha256
1276         (base32
1277          "0wmh7ip318p89lyy6k5mvxkkpq43knp41wlq9iaf3icz0ahqdmb7"))))
1278     (build-system haskell-build-system)
1279     (inputs (list ghc-wai
1280                   ghc-extra
1281                   ghc-shakespeare
1282                   ghc-blaze-builder
1283                   ghc-clientsession
1284                   ghc-random
1285                   ghc-cereal
1286                   ghc-old-locale
1287                   ghc-unliftio
1288                   ghc-unordered-containers
1289                   ghc-monad-control
1290                   ghc-transformers-base
1291                   ghc-cookie
1292                   ghc-http-types
1293                   ghc-case-insensitive
1294                   ghc-vector
1295                   ghc-aeson
1296                   ghc-fast-logger
1297                   ghc-wai-logger
1298                   ghc-monad-logger
1299                   ghc-conduit
1300                   ghc-resourcet
1301                   ghc-rio
1302                   ghc-lifted-base
1303                   ghc-blaze-html
1304                   ghc-blaze-markup
1305                   ghc-data-default
1306                   ghc-safe
1307                   ghc-warp
1308                   ghc-unix-compat
1309                   ghc-conduit-extra
1310                   ghc-exceptions
1311                   ghc-deepseq-generics
1312                   ghc-mwc-random
1313                   ghc-primitive
1314                   ghc-word8
1315                   ghc-auto-update
1316                   ghc-semigroups
1317                   ghc-byteable))
1318     (native-inputs (list ghc-hspec
1319                          ghc-path-pieces
1320                          ghc-hunit
1321                          ghc-hspec-expectations
1322                          ghc-quickcheck
1323                          ghc-network
1324                          ghc-async
1325                          ghc-streaming-commons
1326                          ghc-wai-extra))
1327     (home-page "https://www.yesodweb.com")
1328     (synopsis "Core package for the Yesod web framework")
1329     (description "This Haskell package provides all core functionality, for
1330 Yesod, on which other packages can be built.  It provides dispatch, handler
1331 functions, widgets, etc.")
1332     (license license:expat)))
1333
1334 (define-public ghc-yesod-persistent
1335   (package
1336     (name "ghc-yesod-persistent")
1337     (version "1.6.0.7")
1338     (source
1339      (origin
1340        (method url-fetch)
1341        (uri (string-append "https://hackage.haskell.org/package/"
1342                            "yesod-persistent-" version "/"
1343                            "yesod-persistent-" version ".tar.gz"))
1344        (sha256
1345         (base32
1346          "102xmp7n08sk1g5rv31jpln2v9kqf1zsqsnmi83mnhmgggcbj1k4"))))
1347     (build-system haskell-build-system)
1348     (arguments `(#:tests? #f)) ; FIXME: hspec-discover not available in PATH.
1349     (inputs (list ghc-yesod-core
1350                   ghc-persistent
1351                   ghc-persistent-template
1352                   ghc-blaze-builder
1353                   ghc-conduit
1354                   ghc-resourcet
1355                   ghc-resource-pool))
1356     (native-inputs (list ghc-hspec ghc-wai-extra ghc-yesod-core
1357                          ghc-persistent-sqlite))
1358     (home-page "https://www.yesodweb.com/")
1359     (synopsis "Helpers for using Persistent from Yesod")
1360     (description "This Haskell package provides helpers for using Persistent
1361 from Yesod.")
1362     (license license:expat)))
1363
1364 (define-public ghc-yesod-form
1365     (package
1366     (name "ghc-yesod-form")
1367     (version "1.7.0")
1368     (source
1369       (origin
1370         (method url-fetch)
1371         (uri (string-append
1372                "https://hackage.haskell.org/package/yesod-form/yesod-form-"
1373                version
1374                ".tar.gz"))
1375         (sha256
1376           (base32
1377             "170gby381h5pg9njn908cyx2931yiv79x3rc5npg2rd74kif06vi"))))
1378     (build-system haskell-build-system)
1379     (inputs
1380       (list ghc-yesod-core
1381             ghc-yesod-persistent
1382             ghc-shakespeare
1383             ghc-persistent
1384             ghc-data-default
1385             ghc-xss-sanitize
1386             ghc-blaze-builder
1387             ghc-email-validate
1388             ghc-wai
1389             ghc-blaze-html
1390             ghc-blaze-markup
1391             ghc-attoparsec
1392             ghc-byteable
1393             ghc-aeson
1394             ghc-resourcet
1395             ghc-semigroups
1396             ghc-network-uri
1397             ghc-hspec))
1398     (home-page "https://www.yesodweb.com")
1399     (synopsis "Form handling support for Yesod Web Framework")
1400     (description "This Haskell package provides a set of basic form inputs such
1401 as text, number, time, checkbox, select, textarea, etc through the
1402 @code{Yesod.Form.Fields} module.  Also, there is @code{Yesod.Form.Nic} module
1403 providing richtext field using Nic editor.")
1404     (license license:expat)))
1405
1406 (define-public ghc-yesod
1407   (package
1408     (name "ghc-yesod")
1409     (version "1.6.1.2")
1410     (source
1411      (origin
1412        (method url-fetch)
1413        (uri (string-append
1414              "https://hackage.haskell.org/package/yesod/yesod-"
1415              version ".tar.gz"))
1416        (sha256
1417         (base32
1418          "13r0ispprj41kgn2rkc7zhy1rxfmgpjbmdlnys15h0ihhh3zhw2f"))))
1419     (build-system haskell-build-system)
1420     (inputs
1421      (list ghc-yesod-core
1422            ghc-yesod-persistent
1423            ghc-yesod-form
1424            ghc-wai
1425            ghc-wai-extra
1426            ghc-warp
1427            ghc-aeson
1428            ghc-file-embed
1429            ghc-data-default-class
1430            ghc-unordered-containers
1431            ghc-yaml
1432            ghc-monad-logger
1433            ghc-fast-logger
1434            ghc-conduit
1435            ghc-shakespeare
1436            ghc-streaming-commons
1437            ghc-wai-logger))
1438     (home-page "https://www.yesodweb.com")
1439     (synopsis "Framework for creating type-safe, RESTful web applications")
1440     (description "The Haskell package package groups together the various
1441 Yesod related packages into one cohesive whole.  This is the version of Yesod,
1442 whereas most of the core code lives in @code{ghc-yesod-core}.")
1443     (license license:expat)))
1444
1445 (define-public ghc-hxt-charproperties
1446   (package
1447     (name "ghc-hxt-charproperties")
1448     (version "9.5.0.0")
1449     (source
1450      (origin
1451        (method url-fetch)
1452        (uri (string-append "https://hackage.haskell.org/package/"
1453                            "hxt-charproperties/hxt-charproperties-"
1454                            version ".tar.gz"))
1455        (sha256
1456         (base32
1457          "0jm98jddbsd60jc2bz8wa71rslagbaqf00ia7fvfsaiaa54nk0r8"))))
1458     (build-system haskell-build-system)
1459     (home-page "https://github.com/UweSchmidt/hxt")
1460     (synopsis "Character properties and classes for XML and Unicode")
1461     (description
1462      "The modules provided by this package contain predicates for Unicode
1463 blocks and char properties and character predicates defined by XML.  The
1464 supported Unicode version is 7.0.0")
1465     (license license:expat)))
1466
1467 (define-public ghc-hxt-unicode
1468   (package
1469     (name "ghc-hxt-unicode")
1470     (version "9.0.2.4")
1471     (source
1472      (origin
1473        (method url-fetch)
1474        (uri (string-append
1475              "https://hackage.haskell.org/package/hxt-unicode/hxt-unicode-"
1476              version
1477              ".tar.gz"))
1478        (sha256
1479         (base32
1480          "0rj48cy8z4fl3zpg5bpa458kqr83adav6jnqv4i71dclpprj6n3v"))))
1481     (build-system haskell-build-system)
1482     (inputs
1483      (list ghc-hxt-charproperties))
1484     (home-page
1485      "http://www.fh-wedel.de/~si/HXmlToolbox/index.html https://github.com/UweSchmidt/hxt")
1486     (synopsis
1487      "Unicode en-/decoding functions for utf8, iso-latin-* and other encodings")
1488     (description
1489      "This package provides Unicode encoding and decoding functions for
1490 encodings used in the Haskell XML Toolbox.  ISO Latin 1-16, utf8, utf16, ASCII
1491 are supported. Decoding is done with lazy functions, errors may be detected or
1492 ignored.")
1493     (license license:expat)))
1494
1495 (define-public ghc-hxt-regex-xmlschema
1496   (package
1497     (name "ghc-hxt-regex-xmlschema")
1498     (version "9.2.0.7")
1499     (source
1500      (origin
1501        (method url-fetch)
1502        (uri (string-append "https://hackage.haskell.org/package/"
1503                            "hxt-regex-xmlschema/hxt-regex-xmlschema-"
1504                            version ".tar.gz"))
1505        (sha256
1506         (base32
1507          "0ynrf65m7abq2fjnarlwq6i1r99pl89npibxx05rlplcgpybrdmr"))))
1508     (build-system haskell-build-system)
1509     (inputs
1510      (list ghc-hxt-charproperties ghc-hunit))
1511     (home-page "https://wiki.haskell.org/Regular_expressions_for_XML_Schema")
1512     (synopsis "Regular expression library for W3C XML Schema regular expressions")
1513     (description
1514      "This library supports full W3C XML Schema regular expressions inclusive
1515 all Unicode character sets and blocks.  It is implemented by the technique of
1516 derivations of regular expressions.")
1517     (license license:expat)))
1518
1519 (define-public ghc-hxt
1520   (package
1521     (name "ghc-hxt")
1522     (version "9.3.1.22")
1523     (source
1524      (origin
1525        (method url-fetch)
1526        (uri (string-append
1527              "https://hackage.haskell.org/package/hxt/hxt-"
1528              version
1529              ".tar.gz"))
1530        (sha256
1531         (base32
1532          "1n9snbdl46x23ka7bbsls1vsn0plpmfmbpbl0msjfm92fkk2yq7g"))))
1533     (build-system haskell-build-system)
1534     (outputs '("out" "static" "doc"))
1535     (inputs
1536      (list ghc-hxt-charproperties ghc-hxt-unicode ghc-hxt-regex-xmlschema
1537            ghc-network-uri))
1538     (home-page "https://github.com/UweSchmidt/hxt")
1539     (synopsis "Collection of tools for processing XML with Haskell")
1540     (description
1541      "The Haskell XML Toolbox bases on the ideas of HaXml and HXML, but
1542 introduces a more general approach for processing XML with Haskell.")
1543     (license license:expat)))
1544
1545 (define-public ghc-hxt-xpath
1546   (package
1547     (name "ghc-hxt-xpath")
1548     (version "9.1.2.2")
1549     (source (origin
1550               (method url-fetch)
1551               (uri (hackage-uri "hxt-xpath" version))
1552               (sha256
1553                (base32
1554                 "0wlq9s01icalnvjkkilx5zaqp3ff4v5limj1xy8i18qpzjspqdsh"))))
1555     (build-system haskell-build-system)
1556     (inputs (list ghc-hxt))
1557     (home-page "https://github.com/UweSchmidt/hxt")
1558     (synopsis "The XPath modules for HXT.")
1559     (description
1560      "This extension for the Haskell XML Toolbox defines data types to
1561 represent XPath, navigation trees and primitives to select and edit subtrees
1562 from them.  Some primitives have both a functional and an arrow interface.")
1563     (license license:expat)))
1564
1565 (define-public ghc-http-common
1566   (package
1567     (name "ghc-http-common")
1568     (version "0.8.3.4")
1569     (source
1570      (origin
1571        (method url-fetch)
1572        (uri (string-append "https://hackage.haskell.org/package/"
1573                            "http-common/http-common-" version ".tar.gz"))
1574        (sha256
1575         (base32
1576          "1xpbnfac0fqa5r670ggwm4kq3cmz9jpaw9bx40j9w9qiw6xi4i28"))))
1577     (build-system haskell-build-system)
1578     (inputs
1579      (list ghc-base64-bytestring
1580            ghc-blaze-builder
1581            ghc-case-insensitive
1582            ghc-network
1583            ghc-random
1584            ghc-unordered-containers))
1585     (home-page "https://github.com/afcowie/http-streams/")
1586     (synopsis "Common types for HTTP clients and servers")
1587     (description "Base types used by a variety of HTTP clients and
1588 servers.  See http-streams @code{Network.Http.Client} or pipes-http
1589 @code{Pipes.Http.Client} for full documentation.  You can import
1590 @code{Network.Http.Types} if you like, but both http-streams and
1591 pipes-http re-export this package's types and functions.")
1592     (license license:bsd-3)))
1593
1594 (define-public ghc-http-streams
1595   (package
1596     (name "ghc-http-streams")
1597     (version "0.8.9.4")
1598     (source
1599      (origin
1600        (method url-fetch)
1601        (uri (string-append "https://hackage.haskell.org/package/"
1602                            "http-streams/http-streams-" version ".tar.gz"))
1603        (sha256
1604         (base32
1605          "03xdcb0v735xdrkjlm1w56mskh3x08cbsjrcd7wn4li65ixc20xa"))))
1606     (build-system haskell-build-system)
1607     (inputs
1608      (list ghc-attoparsec
1609            ghc-base64-bytestring
1610            ghc-blaze-builder
1611            ghc-case-insensitive
1612            ghc-io-streams
1613            ghc-hsopenssl
1614            ghc-openssl-streams
1615            ghc-unordered-containers
1616            ghc-aeson
1617            ghc-http-common
1618            ghc-network-uri
1619            ghc-network))
1620     (arguments
1621      `(#:tests? #f)) ; tests rely on an outdated version of snap-server
1622     (home-page "https://github.com/afcowie/http-streams/")
1623     (synopsis "HTTP client using io-streams")
1624     (description "An HTTP client using the Snap Framework's io-streams
1625 library to handle the streaming IO.  The API is optimized for ease of
1626 use for the rather common case of code needing to query web services and
1627 deal with the result.")
1628     (license license:bsd-3)))
1629
1630 (define-public ghc-snap-core
1631   (package
1632     (name "ghc-snap-core")
1633     (version "1.0.4.2")
1634     (source
1635      (origin
1636        (method url-fetch)
1637        (uri (string-append "https://hackage.haskell.org/package/"
1638                            "snap-core/snap-core-" version ".tar.gz"))
1639        (sha256
1640         (base32
1641          "0zxdhx4wk70bkn71574lyz3zhq79yy98rv05r4564rd100xw3fqs"))))
1642     (build-system haskell-build-system)
1643     (arguments
1644      `(#:tests? #f ; TODO: Fail to compile.
1645        #:cabal-revision
1646        ("1" "065v61clskzikywv0gy9n4fjaszi2fnjklal83kqbzhzzgkf83ng")))
1647     (inputs
1648      (list ghc-old-locale
1649            ghc-hunit
1650            ghc-attoparsec
1651            ghc-bytestring-builder
1652            ghc-case-insensitive
1653            ghc-lifted-base
1654            ghc-io-streams
1655            ghc-hashable
1656            ghc-monad-control
1657            ghc-random
1658            ghc-readable
1659            ghc-regex-posix
1660            ghc-transformers-base
1661            ghc-unix-compat
1662            ghc-unordered-containers
1663            ghc-vector
1664            ghc-network-uri
1665            ghc-network))
1666     (native-inputs
1667      (list ghc-quickcheck
1668            ghc-parallel
1669            ghc-test-framework
1670            ghc-test-framework-hunit
1671            ghc-test-framework-quickcheck2
1672            ghc-zlib))
1673     (home-page "http://snapframework.com/")
1674     (synopsis "Haskell Web Framework (core interfaces and types)")
1675     (description "Snap is a simple and fast web development framework
1676 and server written in Haskell.  For more information, you can visit the
1677 Snap project website at @uref{http://snapframework.com/}.  This library
1678 contains the core definitions and types for the Snap framework.")
1679     (license license:bsd-3)))
1680
1681 (define-public ghc-snap-server
1682   (package
1683     (name "ghc-snap-server")
1684     (version "1.1.2.0")
1685     (source
1686      (origin
1687        (method url-fetch)
1688        (uri (string-append "https://hackage.haskell.org/package/"
1689                            "snap-server/snap-server-" version ".tar.gz"))
1690        (sha256
1691         (base32
1692          "0w4yv9a5ilpma0335ariwap2iscmdbaaif88lq3cm7px910nyc4j"))))
1693     (build-system haskell-build-system)
1694     (inputs
1695      (list ghc-attoparsec
1696            ghc-blaze-builder
1697            ghc-bytestring-builder
1698            ghc-case-insensitive
1699            ghc-clock
1700            ghc-io-streams
1701            ghc-io-streams-haproxy
1702            ghc-lifted-base
1703            ghc-network
1704            ghc-old-locale
1705            ghc-snap-core
1706            ghc-unix-compat
1707            ghc-vector))
1708     (native-inputs
1709      (list ghc-base16-bytestring
1710            ghc-monad-control
1711            ghc-random
1712            ghc-threads
1713            ghc-hunit
1714            ghc-quickcheck
1715            ghc-http-streams
1716            ghc-http-common
1717            ghc-parallel
1718            ghc-test-framework
1719            ghc-test-framework-hunit
1720            ghc-test-framework-quickcheck2))
1721     (home-page "http://snapframework.com/")
1722     (synopsis "Web server for the Snap Framework")
1723     (description "Snap is a simple and fast web development framework
1724 and server written in Haskell.  For more information, you can visit the
1725 Snap project website at @uref{http://snapframework.com/}.  The Snap HTTP
1726 server is a high performance web server library written in Haskell.
1727 Together with the snap-core library upon which it depends, it provides a
1728 clean and efficient Haskell programming interface to the HTTP
1729 protocol.")
1730     (license license:bsd-3)))
1731
1732 (define-public ghc-js-jquery
1733   (package
1734     (name "ghc-js-jquery")
1735     (version "3.3.1")
1736     (source
1737      (origin
1738        (method url-fetch)
1739        (uri
1740         (string-append
1741          "https://hackage.haskell.org/package/js-jquery/js-jquery-"
1742          version ".tar.gz"))
1743        (sha256
1744         (base32
1745          "16q68jzbs7kp07dnq8cprdcc8fd41rim38039vg0w4x11lgniq70"))))
1746     (build-system haskell-build-system)
1747     (arguments `(#:tests? #f)) ; tests do network IO
1748     (home-page "https://github.com/ndmitchell/js-jquery")
1749     (synopsis "Obtain minified jQuery code")
1750     (description "This package bundles the minified
1751 @url{http://jquery.com/, jQuery} code into a Haskell package, so it can
1752 be depended upon by Cabal packages.  The first three components of the
1753 version number match the upstream jQuery version.  The package is
1754 designed to meet the redistribution requirements of downstream
1755 users (e.g. Debian).")
1756     (license license:expat)))
1757
1758 (define-public ghc-js-flot
1759   (package
1760     (name "ghc-js-flot")
1761     (version "0.8.3")
1762     (source
1763      (origin
1764        (method url-fetch)
1765        (uri
1766         (string-append
1767          "https://hackage.haskell.org/package/js-flot/js-flot-"
1768          version ".tar.gz"))
1769        (sha256
1770         (base32
1771          "0yjyzqh3qzhy5h3nql1fckw0gcfb0f4wj9pm85nafpfqp2kg58hv"))))
1772     (build-system haskell-build-system)
1773     (inputs
1774      (list ghc-http))
1775     (home-page "https://github.com/ndmitchell/js-flot")
1776     (synopsis "Obtain minified flot code")
1777     (description "This package bundles the minified
1778 @url{http://www.flotcharts.org/, Flot} code (a jQuery plotting library)
1779 into a Haskell package, so it can be depended upon by Cabal packages.
1780 The first three components of the version number match the upstream flot
1781 version.  The package is designed to meet the redistribution
1782 requirements of downstream users (e.g. Debian).")
1783     (license license:expat)))
1784
1785 (define-public ghc-happstack-server
1786   (package
1787     (name "ghc-happstack-server")
1788     (version "7.7.1.1")
1789     (source
1790      (origin
1791        (method url-fetch)
1792        (uri (string-append
1793              "https://hackage.haskell.org/package/happstack-server/happstack-server-"
1794              version ".tar.gz"))
1795        (sha256
1796         (base32
1797          "0nc5rnvrzl9m3pinmdq234m80qkf4jszbdqnd567f7lh09yiqw9n"))))
1798     (build-system haskell-build-system)
1799     (inputs
1800      (list ghc-network
1801            ghc-network-bsd
1802            ghc-network-uri
1803            ghc-base64-bytestring
1804            ghc-blaze-html
1805            ghc-exceptions
1806            ghc-extensible-exceptions
1807            ghc-hslogger
1808            ghc-html
1809            ghc-monad-control
1810            ghc-old-locale
1811            ghc-semigroups
1812            ghc-sendfile
1813            ghc-system-filepath
1814            ghc-syb
1815            ghc-threads
1816            ghc-transformers-base
1817            ghc-transformers-compat
1818            ghc-utf8-string
1819            ghc-zlib))
1820     (native-inputs (list ghc-hunit))
1821     (home-page "http://happstack.com")
1822     (synopsis "Web related tools and services for Haskell")
1823     (description
1824      "Happstack Server provides an HTTP server and a rich set of functions for
1825 routing requests, handling query parameters, generating responses, working with
1826 cookies, serving files, and more.")
1827     (license license:bsd-3)))
1828
1829 (define-public ghc-sendfile
1830   (package
1831     (name "ghc-sendfile")
1832     (version "0.7.11.1")
1833     (source
1834      (origin
1835        (method url-fetch)
1836        (uri (string-append
1837              "https://hackage.haskell.org/package/sendfile/sendfile-"
1838              version ".tar.gz"))
1839        (sha256
1840         (base32
1841          "0988snmx3bylpw3kcq8hsgji8idc6xcrcfp275qjv3apfdgc9rp0"))))
1842     (build-system haskell-build-system)
1843     (inputs (list ghc-network))
1844     (home-page
1845      "https://hub.darcs.net/stepcut/sendfile")
1846     (synopsis "Portable sendfile library for Haskell")
1847     (description
1848      "Haskell library which exposes zero-copy sendfile functionality in a portable way.")
1849     (license license:bsd-3)))
1850
1851 (define-public ghc-scalpel-core
1852   (package
1853     (name "ghc-scalpel-core")
1854     (version "0.6.2")
1855     (source
1856       (origin
1857         (method url-fetch)
1858         (uri (string-append
1859                "https://hackage.haskell.org/package/scalpel-core/"
1860                "scalpel-core-" version ".tar.gz"))
1861         (sha256
1862          (base32
1863           "07mjff8aqwabx8yhq8bd7jpnarkkrjqss8h8s2wkfmfj808fllmf"))))
1864     (build-system haskell-build-system)
1865     (inputs
1866      (list ghc-data-default
1867            ghc-fail
1868            ghc-pointedlist
1869            ghc-regex-base
1870            ghc-regex-tdfa
1871            ghc-tagsoup
1872            ghc-vector))
1873     (native-inputs (list ghc-hunit))
1874     (home-page "https://github.com/fimad/scalpel")
1875     (synopsis
1876      "High level web scraping library for Haskell")
1877     (description
1878      "Scalpel core provides a subset of the scalpel web scraping library
1879 that is intended to have lightweight dependencies and to be free of all
1880 non-Haskell dependencies.")
1881     (license license:asl2.0)))
1882
1883 (define-public ghc-scalpel
1884   (package
1885     (name "ghc-scalpel")
1886     (version "0.6.2")
1887     (source
1888       (origin
1889         (method url-fetch)
1890         (uri (string-append
1891                "https://hackage.haskell.org/package/scalpel/"
1892                "scalpel-" version ".tar.gz"))
1893         (sha256
1894          (base32
1895           "04hhvk0yjxha3yg6n9fxivrz97hpjjiiblnj0bvs5myax1ggkjch"))))
1896     (build-system haskell-build-system)
1897     (inputs
1898      (list ghc-scalpel-core
1899            ghc-case-insensitive
1900            ghc-data-default
1901            ghc-http-client
1902            ghc-http-client-tls
1903            ghc-tagsoup))
1904     (home-page "https://github.com/fimad/scalpel")
1905     (synopsis
1906      "High level web scraping library for Haskell")
1907     (description
1908      "Scalpel is a web scraping library inspired by libraries like Parsec
1909 and Perl's @code{Web::Scraper}.  Scalpel builds on top of TagSoup to provide a
1910 declarative and monadic interface.")
1911     (license license:asl2.0)))
1912
1913 (define-public ghc-sourcemap
1914   (package
1915     (name "ghc-sourcemap")
1916     (version "0.1.6.1")
1917     (source
1918      (origin
1919        (method url-fetch)
1920        (uri (string-append
1921              "https://hackage.haskell.org/package/sourcemap/sourcemap-"
1922              version
1923              ".tar.gz"))
1924        (sha256
1925         (base32
1926          "0kz8xpcd5syg5s4qa2qq8ylaxjhabj127w42may46vv6i0q1bf8a"))))
1927     (build-system haskell-build-system)
1928     (inputs
1929      (list ghc-aeson ghc-unordered-containers ghc-attoparsec
1930            ghc-utf8-string))
1931     (arguments
1932      `(#:tests? #f ; FIXME: Fail to compile
1933        #:cabal-revision
1934        ("1" "1f7q44ar6qfip8fsllg43jyn7r15ifn2r0vz32cbmx0sb0d38dax")))
1935     (home-page
1936      "http://hackage.haskell.org/package/sourcemap")
1937     (synopsis
1938      "Implementation of source maps as proposed by Google and Mozilla")
1939     (description
1940      "Sourcemap provides an implementation of source maps, revision 3,
1941 proposed by Google and Mozilla here
1942 @url{https://wiki.mozilla.org/DevTools/Features/SourceMap}.")
1943     (license license:bsd-3)))
1944
1945 (define-public ghc-language-javascript
1946   (package
1947     (name "ghc-language-javascript")
1948     (version "0.7.1.0")
1949     (source
1950      (origin
1951        (method url-fetch)
1952        (uri (string-append
1953              "https://hackage.haskell.org/package/language-javascript/language-javascript-"
1954              version
1955              ".tar.gz"))
1956        (sha256
1957         (base32
1958          "0s6igb54cxm2jywgc3sq53f52gcsc39wd3g78yisfzvl9jm3d86i"))))
1959     (build-system haskell-build-system)
1960     (inputs
1961      (list ghc-blaze-builder ghc-utf8-string))
1962     (native-inputs
1963      (list ghc-alex ghc-quickcheck ghc-happy ghc-hspec ghc-utf8-light))
1964     (home-page
1965      "https://github.com/erikd/language-javascript")
1966     (synopsis "Parser for JavaScript")
1967     (description
1968      "Parses Javascript into an Abstract Syntax Tree (AST).  Initially intended
1969 as frontend to hjsmin.")
1970     (license license:bsd-3)))
1971
1972 (define-public ghc-bower-json
1973   (package
1974     (name "ghc-bower-json")
1975     (version "1.0.0.1")
1976     (source
1977      (origin
1978        (method url-fetch)
1979        (uri (string-append
1980              "mirror://hackage/package/bower-json/bower-json-"
1981              version
1982              ".tar.gz"))
1983        (sha256
1984         (base32
1985          "0wvygg3rdbxzrmr61a9w6ddv9pfric85ih8hnxyk0ydzn7i59abs"))))
1986     (build-system haskell-build-system)
1987     (inputs
1988      (list ghc-aeson ghc-aeson-better-errors ghc-scientific
1989            ghc-transformers ghc-unordered-containers))
1990     (native-inputs
1991      (list ghc-tasty ghc-tasty-hunit))
1992     (home-page "https://github.com/hdgarrood/bower-json")
1993     (synopsis "Read bower.json from Haskell")
1994     (description
1995      "This package provides a data type and ToJSON/FromJSON instances for
1996 Bower's package manifest file, bower.json.")
1997     (license license:expat)))
1998
1999 (define-public ghc-dav
2000   (package
2001     (name "ghc-dav")
2002     (version "1.3.4")
2003     (source
2004      (origin
2005        (method url-fetch)
2006        (uri (string-append "https://hackage.haskell.org/package/DAV/DAV-"
2007                            version ".tar.gz"))
2008        (sha256
2009         (base32 "1isvi4fahq70lzxfz23as7qzkc01g7kba568l6flrgd0j1984fsy"))))
2010     (build-system haskell-build-system)
2011     (inputs
2012      (list ghc-case-insensitive
2013            ghc-data-default
2014            ghc-exceptions
2015            ghc-http-client
2016            ghc-http-client-tls
2017            ghc-http-types
2018            ghc-lens
2019            ghc-transformers-base
2020            ghc-transformers-compat
2021            ghc-utf8-string
2022            ghc-xml-conduit
2023            ghc-xml-hamlet
2024            ghc-network
2025            ghc-network-uri
2026            ghc-optparse-applicative))
2027     (home-page "http://floss.scru.org/hDAV")
2028     (synopsis "RFC 4918 WebDAV support")
2029     (description "This package provides a library for the Web Distributed
2030 Authoring and Versioning (WebDAV) extensions to HTTP as well an executable,
2031 @command{hdav}, for command-line operation.")
2032     (license license:gpl3)))
2033
2034 (define-public ghc-yesod-test
2035   (package
2036     (name "ghc-yesod-test")
2037     (version "1.6.12")
2038     (source
2039      (origin
2040        (method url-fetch)
2041        (uri (string-append "https://hackage.haskell.org/package/"
2042                            "yesod-test/yesod-test-" version ".tar.gz"))
2043        (sha256
2044         (base32
2045          "1xgy7dzhqjgllqcpyyxs0spdg6vlz2c1sjvni7w7qnsf0ckyw2l8"))))
2046     (build-system haskell-build-system)
2047     (inputs
2048      (list ghc-hunit
2049            ghc-aeson
2050            ghc-attoparsec
2051            ghc-blaze-builder
2052            ghc-blaze-html
2053            ghc-case-insensitive
2054            ghc-conduit
2055            ghc-cookie
2056            ghc-hspec-core
2057            ghc-html-conduit
2058            ghc-http-types
2059            ghc-network
2060            ghc-memory
2061            ghc-pretty-show
2062            ghc-semigroups
2063            ghc-wai
2064            ghc-wai-extra
2065            ghc-xml-conduit
2066            ghc-xml-types
2067            ghc-yesod-core))
2068     (native-inputs
2069      (list ghc-hspec ghc-yesod-form ghc-unliftio ghc-unliftio-core))
2070     (home-page "https://www.yesodweb.com")
2071     (synopsis "Integration testing for WAI/Yesod Applications")
2072     (description "This package's main goal is to encourage integration
2073 and system testing of web applications by making everything easy to
2074 test.  Tests are like browser sessions that keep track of cookies and
2075 the last visited page.  You can perform assertions on the content of
2076 HTML responses using CSS selectors.")
2077     (license license:expat)))
2078
2079 (define-public ghc-wai-app-static
2080   (package
2081     (name "ghc-wai-app-static")
2082     (version "3.1.7.2")
2083     (source
2084      (origin
2085        (method url-fetch)
2086        (uri (string-append "https://hackage.haskell.org/package/"
2087                            "wai-app-static/wai-app-static-"
2088                            version ".tar.gz"))
2089        (sha256
2090         (base32
2091          "138gd5482psq0wbm8s1az672lksi7vbavq6ayiyjkliivf6xpry8"))))
2092     (build-system haskell-build-system)
2093     (inputs
2094      (list ghc-wai
2095            ghc-http-types
2096            ghc-unix-compat
2097            ghc-old-locale
2098            ghc-file-embed
2099            ghc-cryptonite
2100            ghc-memory
2101            ghc-http-date
2102            ghc-blaze-html
2103            ghc-blaze-markup
2104            ghc-mime-types
2105            ghc-unordered-containers
2106            ghc-zlib
2107            ghc-wai-extra
2108            ghc-optparse-applicative
2109            ghc-warp))
2110     (native-inputs
2111      (list ghc-hspec ghc-network ghc-temporary ghc-mockery))
2112     (arguments
2113      `(#:cabal-revision
2114        ("1" "1q7zwjasysgbp9rdp75535igd7s6mhi2bnl4pzsn6vbyfw3qnsxd")))
2115     (home-page "https://www.yesodweb.com/book/web-application-interface")
2116     (synopsis "WAI application for static serving")
2117     (description "This package provides a Web Application
2118 Interface (WAI) application for static serving.  It also provides some
2119 helper functions and datatypes for use outside of WAI.")
2120     (license license:expat)))
2121
2122 (define-public ghc-hjsmin
2123   (package
2124     (name "ghc-hjsmin")
2125     (version "0.2.0.4")
2126     (source
2127      (origin
2128        (method url-fetch)
2129        (uri (string-append "https://hackage.haskell.org/package/"
2130                            "hjsmin/hjsmin-" version ".tar.gz"))
2131        (sha256
2132         (base32
2133          "1r2p5rjdjr25j3w4s57q5hxw2c3ymw12x7ms18yvglnq2ivr9fc1"))))
2134     (build-system haskell-build-system)
2135     (arguments
2136      `(#:phases
2137        (modify-phases %standard-phases
2138          (add-before 'build 'fix-dist-directory-for-tests
2139            (lambda _
2140              (substitute* '("test/test-cli.hs" "test/cli/core/runner")
2141                (("dist-newstyle") "dist")))))))
2142     (inputs
2143      (list ghc-language-javascript ghc-optparse-applicative))
2144     (native-inputs
2145      (list ghc-extra))
2146     (home-page "https://github.com/erikd/hjsmin")
2147     (synopsis "Haskell implementation of a JavaScript minifier")
2148     (description "This library provides tools reduce the size of
2149 JavaScript files by stripping out extraneous whitespace and other
2150 syntactic elements, without changing the semantics.")
2151     (license license:bsd-3)))
2152
2153 (define-public ghc-yesod-static
2154   (package
2155     (name "ghc-yesod-static")
2156     (version "1.6.1.0")
2157     (source
2158      (origin
2159        (method url-fetch)
2160        (uri (string-append "https://hackage.haskell.org/package/"
2161                            "yesod-static/yesod-static-" version ".tar.gz"))
2162        (sha256
2163         (base32
2164          "18f5hm9ncvkzl8bkn39cg841z0k5iqs5w45afsyk9y6k98pjd54p"))))
2165     (build-system haskell-build-system)
2166     (inputs
2167      (list ghc-async
2168            ghc-attoparsec
2169            ghc-base64-bytestring
2170            ghc-blaze-builder
2171            ghc-conduit
2172            ghc-cryptonite
2173            ghc-cryptonite-conduit
2174            ghc-css-text
2175            ghc-data-default
2176            ghc-file-embed
2177            ghc-hashable
2178            ghc-hjsmin
2179            ghc-http-types
2180            ghc-memory
2181            ghc-mime-types
2182            ghc-unix-compat
2183            ghc-unordered-containers
2184            ghc-wai
2185            ghc-wai-app-static
2186            ghc-yesod-core))
2187     (native-inputs
2188      (list ghc-hspec ghc-yesod-test ghc-wai-extra ghc-hunit ghc-rio))
2189     (home-page "https://www.yesodweb.com/")
2190     (synopsis "Static file serving subsite for Yesod")
2191     (description "This package provides a static file serving subsite
2192 for the Yesod Web Framework.")
2193     (license license:expat)))
2194
2195 (define-public ghc-wai-handler-launch
2196   (package
2197     (name "ghc-wai-handler-launch")
2198     (version "3.0.3.1")
2199     (source
2200      (origin
2201        (method url-fetch)
2202        (uri (string-append "https://hackage.haskell.org/package/"
2203                            "wai-handler-launch/wai-handler-launch-"
2204                            version ".tar.gz"))
2205        (sha256
2206         (base32
2207          "1ifqgyc1ccig5angh5l1iq7vyms4lvi8wzvysg5dw82nml49n02m"))))
2208     (build-system haskell-build-system)
2209     (inputs
2210      (list ghc-wai ghc-warp ghc-http-types ghc-streaming-commons
2211            ghc-async))
2212     (home-page "https://hackage.haskell.org/package/wai-handler-launch")
2213     (synopsis "Launch a Web application in the default browser")
2214     (description "This package handles cross-platform Web browser
2215 launching and inserts JavaScript code to ping the server.  When the
2216 server no longer receives pings, it shuts down.")
2217     (license license:expat)))
2218
2219 (define-public ghc-wai-cors
2220   (package
2221     (name "ghc-wai-cors")
2222     (version "0.2.7")
2223     (source
2224      (origin
2225        (method url-fetch)
2226        (uri (string-append "https://hackage.haskell.org/package/"
2227                            "wai-cors/wai-cors-" version ".tar.gz"))
2228        (sha256
2229         (base32
2230          "10gv3jjlkcb13031frr818p56v2s0qf6dqjsfpwlhwdxdssvx5r5"))))
2231     (build-system haskell-build-system)
2232     (arguments
2233      `(#:phases
2234        (modify-phases %standard-phases
2235          ;; As of version 0.2.7, there are two test suites: "unit-tests"
2236          ;; and "phantomjs".  Since we do not have a PhantomJS package,
2237          ;; we only run the unit tests.
2238          (replace 'check
2239            (lambda _
2240              (invoke "runhaskell" "Setup.hs" "test" "unit-tests"))))))
2241     (inputs
2242      (list ghc-attoparsec ghc-base-unicode-symbols ghc-case-insensitive
2243            ghc-http-types ghc-wai))
2244     (native-inputs
2245      (list ghc-network
2246            ghc-wai-websockets
2247            ghc-warp
2248            ghc-websockets
2249            ghc-tasty
2250            ghc-tasty-hunit
2251            ghc-wai-extra
2252            ghc-wai-websockets
2253            ghc-warp
2254            ghc-websockets))
2255     (home-page "https://github.com/larskuhtz/wai-cors")
2256     (synopsis "Cross-Origin Resource Sharing (CORS) for WAI")
2257     (description "This package provides an implementation of Cross-Origin
2258 Resource Sharing (CORS) for the Web Application Framework (WAI) that
2259 aims to be compliant with @url{https://www.w3.org/TR/cors}.")
2260     (license license:expat)))
2261
2262 (define-public ghc-network-run
2263   (package
2264     (name "ghc-network-run")
2265     (version "0.2.4")
2266     (source
2267       (origin
2268         (method url-fetch)
2269         (uri (string-append
2270                "https://hackage.haskell.org/package/network-run/network-run-"
2271                version
2272                ".tar.gz"))
2273         (sha256
2274           (base32 "0w3dmwk03j4n01xkiq8m4sqa27bskh239mpw7m4ihjmkxqcwc5gl"))))
2275     (build-system haskell-build-system)
2276     (inputs (list ghc-network))
2277     (home-page "https://hackage.haskell.org/package/network-run")
2278     (synopsis "Simple network runner library")
2279     (description
2280      "This package provides a simple network runner library in Haskell.")
2281     (license license:bsd-3)))
2282