gnu/packages/haskell-web.scm

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