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