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-xss-sanitize
 659   (package
 660     (name "ghc-xss-sanitize")
 661     (version "0.3.6")
 662     (source
 663      (origin
 664        (method url-fetch)
 665        (uri (string-append
 666              "https://hackage.haskell.org/package/xss-sanitize/xss-sanitize-"
 667              version ".tar.gz"))
 668        (sha256
 669         (base32
 670          "1d72s3a6520iwwc1wbn9v2znqgbw6a5wwzb23iq8ny9ccnjyx1dk"))))
 671     (build-system haskell-build-system)
 672     (inputs
 673      `(("ghc-tagsoup" ,ghc-tagsoup)
 674        ("ghc-utf8-string" ,ghc-utf8-string)
 675        ("ghc-css-text" ,ghc-css-text)
 676        ("ghc-network-uri" ,ghc-network-uri)))
 677     (native-inputs
 678      `(("ghc-attoparsec" ,ghc-attoparsec)
 679        ("ghc-hspec" ,ghc-hspec)
 680        ("ghc-hunit" ,ghc-hunit)))
 681     (home-page "https://github.com/yesodweb/haskell-xss-sanitize")
 682     (synopsis "Sanitize untrusted HTML to prevent XSS attacks")
 683     (description "This library provides @code{sanitizeXSS}.  Run untrusted
 684 HTML through @code{Text.HTML.SanitizeXSS.sanitizeXSS} to prevent XSS
 685 attacks.")
 686     (license license:bsd-3)))
 687
 688 (define-public ghc-css-text
 689   (package
 690     (name "ghc-css-text")
 691     (version "0.1.3.0")
 692     (source
 693      (origin
 694        (method url-fetch)
 695        (uri (string-append
 696              "https://hackage.haskell.org/package/css-text/css-text-"
 697              version
 698              ".tar.gz"))
 699        (sha256
 700         (base32
 701          "0ynd9f4hn2sfwqzbsa0y7phmxq8za7jiblpjwx0ry8b372zhgxaz"))))
 702     (build-system haskell-build-system)
 703     (inputs
 704      `(("ghc-attoparsec" ,ghc-attoparsec)
 705        ("ghc-hspec" ,ghc-hspec)
 706        ("ghc-quickcheck" ,ghc-quickcheck)))
 707     (home-page "http://www.yesodweb.com/")
 708     (synopsis "CSS parser and renderer")
 709     (description "This package provides a CSS parser and renderer for
 710 Haskell.")
 711     (license license:bsd-3)))
 712
 713 (define-public ghc-mime-types
 714   (package
 715     (name "ghc-mime-types")
 716     (version "0.1.0.9")
 717     (source (origin
 718               (method url-fetch)
 719               (uri (string-append "https://hackage.haskell.org/package/"
 720                                   "mime-types/mime-types-"
 721                                   version ".tar.gz"))
 722               (sha256
 723                (base32
 724                 "1lkipa4v73z3l5lqs6sdhl898iq41kyxv2jb9agsajzgd58l6cha"))))
 725     (build-system haskell-build-system)
 726     (home-page "https://github.com/yesodweb/wai")
 727     (synopsis "Basic MIME type handling types and functions")
 728     (description
 729      "This library provides basic MIME type handling types and functions.")
 730     (license license:expat)))
 731
 732 (define-public ghc-html
 733   (package
 734     (name "ghc-html")
 735     (version "1.0.1.2")
 736     (source
 737      (origin
 738        (method url-fetch)
 739        (uri (string-append
 740              "https://hackage.haskell.org/package/html/html-"
 741              version
 742              ".tar.gz"))
 743        (sha256
 744         (base32
 745          "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c"))))
 746     (build-system haskell-build-system)
 747     (home-page
 748      "https://hackage.haskell.org/package/html")
 749     (synopsis "HTML combinator library")
 750     (description
 751      "This package contains a combinator library for constructing HTML
 752 documents.")
 753     (license license:bsd-3)))
 754
 755 (define-public ghc-html-conduit
 756   (package
 757     (name "ghc-html-conduit")
 758     (version "1.3.2.1")
 759     (source
 760      (origin
 761        (method url-fetch)
 762        (uri (string-append
 763              "https://hackage.haskell.org/package/html-conduit/"
 764              "html-conduit-" version ".tar.gz"))
 765        (sha256
 766         (base32
 767          "196c8zcnjp1pc5qvqxd8arx3xkw0a90rvg9mmiw2l4zwnx65709n"))))
 768     (build-system haskell-build-system)
 769     (inputs
 770      `(("ghc-resourcet" ,ghc-resourcet)
 771        ("ghc-conduit" ,ghc-conduit)
 772        ("ghc-xml-conduit" ,ghc-xml-conduit)
 773        ("ghc-xml-types" ,ghc-xml-types)
 774        ("ghc-attoparsec" ,ghc-attoparsec)
 775        ("ghc-conduit-extra" ,ghc-conduit-extra)))
 776     (native-inputs
 777      `(("ghc-hspec" ,ghc-hspec)
 778        ("ghc-hunit" ,ghc-hunit)))
 779     (home-page "https://github.com/snoyberg/xml")
 780     (synopsis "Parse HTML documents using xml-conduit datatypes")
 781     (description
 782      "This package provides a parser for HTML documents that uses
 783 tagstream-conduit.  It automatically balances mismatched tags, so that
 784 there shouldn't be any parse failures.  It does not handle a full HTML
 785 document rendering, such as adding missing html and head tags.  Note that,
 786 since version 1.3.1, it uses an inlined copy of tagstream-conduit with
 787 entity decoding bugfixes applied.")
 788     (license license:expat)))
 789
 790 (define-public ghc-blaze-html
 791   (package
 792     (name "ghc-blaze-html")
 793     (version "0.9.1.2")
 794     (source
 795      (origin
 796        (method url-fetch)
 797        (uri (string-append "https://hackage.haskell.org/package/"
 798                            "blaze-html/blaze-html-"
 799                            version ".tar.gz"))
 800        (sha256
 801         (base32
 802          "0k1r1hddjgqighazcazxrx6xfhvy2gm8il8l82ainv3cai13yl30"))))
 803     (build-system haskell-build-system)
 804     (inputs
 805      `(("ghc-blaze-builder" ,ghc-blaze-builder)
 806        ("ghc-blaze-markup" ,ghc-blaze-markup)))
 807     (native-inputs
 808      `(("ghc-hunit" ,ghc-hunit)
 809        ("ghc-quickcheck" ,ghc-quickcheck)
 810        ("ghc-test-framework" ,ghc-test-framework)
 811        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
 812        ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
 813     (home-page "http://jaspervdj.be/blaze")
 814     (synopsis "Fast HTML combinator library")
 815     (description "This library provides HTML combinators for Haskell.")
 816     (license license:bsd-3)))
 817
 818 (define-public ghc-aeson
 819   (package
 820     (name "ghc-aeson")
 821     (version "1.4.5.0")
 822     (source
 823      (origin
 824        (method url-fetch)
 825        (uri (string-append
 826              "https://hackage.haskell.org/package/aeson/aeson-"
 827              version
 828              ".tar.gz"))
 829        (sha256
 830         (base32
 831          "1jhabz1lbbv6yqxqiybifi86cb5xlsadrn368n5dd0wzzc7ja4iz"))))
 832     (build-system haskell-build-system)
 833     (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
 834     (inputs
 835      `(("ghc-attoparsec" ,ghc-attoparsec)
 836        ("ghc-base-compat" ,ghc-base-compat)
 837        ("ghc-dlist" ,ghc-dlist)
 838        ("ghc-hashable" ,ghc-hashable)
 839        ("ghc-scientific" ,ghc-scientific)
 840        ("ghc-tagged" ,ghc-tagged)
 841        ("ghc-th-abstraction" ,ghc-th-abstraction)
 842        ("ghc-time-locale-compat" ,ghc-time-locale-compat)
 843        ("ghc-unordered-containers" ,ghc-unordered-containers)
 844        ("ghc-uuid-types" ,ghc-uuid-types)
 845        ("ghc-vector" ,ghc-vector)
 846        ("ghc-hunit" ,ghc-hunit)
 847        ("ghc-quickcheck" ,ghc-quickcheck)
 848        ("ghc-integer-logarithms" ,ghc-integer-logarithms)
 849        ("ghc-base-orphans" ,ghc-base-orphans)
 850        ("ghc-base16-bytestring" ,ghc-base16-bytestring)
 851        ("ghc-generic-deriving" ,ghc-generic-deriving)
 852        ("ghc-test-framework" ,ghc-test-framework)
 853        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
 854        ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
 855        ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
 856        ("ghc-hashable-time" ,ghc-hashable-time)))
 857     (home-page "https://github.com/bos/aeson")
 858     (synopsis "Fast JSON parsing and encoding")
 859     (description "This package provides a JSON parsing and encoding library
 860 for Haskell, optimized for ease of use and high performance.  (A note on
 861 naming: in Greek mythology, Aeson was the father of Jason.)")
 862     (license license:bsd-3)))
 863
 864 (define-public ghc-aeson-pretty
 865   (package
 866     (name "ghc-aeson-pretty")
 867     (version "0.8.8")
 868     (source (origin
 869               (method url-fetch)
 870               (uri (string-append
 871                     "https://hackage.haskell.org/package/aeson-pretty/aeson-pretty-"
 872                     version ".tar.gz"))
 873               (sha256
 874                (base32
 875                 "09n7gs91y1fbw6gjszrd2na3isnvk3y5rsi90lzjrwywnqfadkl1"))))
 876     (build-system haskell-build-system)
 877     (inputs
 878      `(("ghc-aeson" ,ghc-aeson)
 879        ("ghc-base-compat" ,ghc-base-compat)
 880        ("ghc-scientific" ,ghc-scientific)
 881        ("ghc-vector" ,ghc-vector)
 882        ("ghc-unordered-containers" ,ghc-unordered-containers)
 883        ("ghc-attoparsec" ,ghc-attoparsec)
 884        ("ghc-cmdargs" ,ghc-cmdargs)))
 885     (home-page "https://github.com/informatikr/aeson-pretty")
 886     (synopsis "JSON pretty-printing library and command-line tool")
 887     (description
 888      "This package provides a JSON pretty-printing library compatible with aeson
 889 as well as a command-line tool to improve readability of streams of JSON data.
 890 The library provides the function @code{encodePretty}.  It is a drop-in
 891 replacement for aeson's @code{encode} function, producing JSON-ByteStrings for
 892 human readers.  The command-line tool reads JSON from stdin and writes
 893 prettified JSON to stdout.  It also offers a complementary \"compact\"-mode,
 894 essentially the opposite of pretty-printing.")
 895     (license license:bsd-3)))
 896
 897 (define-public ghc-aeson-qq
 898   (package
 899     (name "ghc-aeson-qq")
 900     (version "0.8.2")
 901     (source (origin
 902               (method url-fetch)
 903               (uri (string-append "https://hackage.haskell.org/package/"
 904                                   "aeson-qq/aeson-qq-" version ".tar.gz"))
 905               (sha256
 906                (base32
 907                 "0ln13jqyfh5726hdrk1rad9a6cgrrj201plmwcfcpvq18v4m5ckd"))))
 908     (build-system haskell-build-system)
 909     (inputs
 910      `(("ghc-base-compat" ,ghc-base-compat)
 911        ("ghc-attoparsec" ,ghc-attoparsec)
 912        ("ghc-scientific" ,ghc-scientific)
 913        ("ghc-vector" ,ghc-vector)
 914        ("ghc-aeson" ,ghc-aeson)
 915        ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
 916     (native-inputs
 917      `(("ghc-hspec" ,ghc-hspec)
 918        ("hspec-discover" ,hspec-discover)))
 919     (home-page "https://github.com/zalora/aeson-qq")
 920     (synopsis "JSON quasiquoter for Haskell")
 921     (description
 922      "aeson-qq provides a JSON quasiquoter for Haskell.  This package exposes
 923 the function @code{aesonQQ} that compile-time converts a string representation
 924 of a JSON value into a @code{Data.Aeson.Value}.")
 925     (license license:expat)))
 926
 927 (define-public ghc-multipart
 928   (package
 929     (name "ghc-multipart")
 930     (version "0.1.3")
 931     (source
 932      (origin
 933        (method url-fetch)
 934        (uri (string-append
 935              "https://hackage.haskell.org/package/multipart/multipart-"
 936              version
 937              ".tar.gz"))
 938        (sha256
 939         (base32
 940          "1x4n4yyva22dhfr1pg5ki112qvvzb4hyd7bwpm189iq4gcp52q4z"))))
 941     (build-system haskell-build-system)
 942     (inputs
 943      `(("ghc-stringsearch" ,ghc-stringsearch)))
 944     (home-page
 945      "http://www.github.com/silkapp/multipart")
 946     (synopsis
 947      "HTTP multipart library")
 948     (description
 949      "HTTP multipart split out of the cgi package, for Haskell.")
 950     (license license:bsd-3)))
 951
 952 (define-public ghc-uri-encode
 953   (package
 954     (name "ghc-uri-encode")
 955     (version "1.5.0.5")
 956     (source
 957      (origin
 958        (method url-fetch)
 959        (uri (string-append
 960              "https://hackage.haskell.org/package/uri-encode/uri-encode-"
 961              version ".tar.gz"))
 962        (sha256
 963         (base32
 964          "11miwb5vvnn17m92ykz1pzg9x6s8fbpz3mmsyqs2s4b3mn55haz8"))))
 965     (build-system haskell-build-system)
 966     (inputs
 967      `(("ghc-utf8-string" ,ghc-utf8-string)
 968        ("ghc-network-uri" ,ghc-network-uri)))
 969     (home-page "https://hackage.haskell.org/package/uri-encode")
 970     (synopsis "Unicode aware uri-encoding")
 971     (description "Unicode aware uri-encoding for Haskell.")
 972     (license license:bsd-3)))
 973
 974 (define-public ghc-path-pieces
 975   (package
 976     (name "ghc-path-pieces")
 977     (version "0.2.1")
 978     (source
 979      (origin
 980        (method url-fetch)
 981        (uri (string-append "https://hackage.haskell.org/package/"
 982                            "path-pieces-" version "/"
 983                            "path-pieces-" version ".tar.gz"))
 984        (sha256
 985         (base32
 986          "0vx3sivcsld76058925hym2j6hm3g71f0qjr7v59f1g2afgx82q8"))))
 987     (build-system haskell-build-system)
 988     (native-inputs `(("ghc-hunit" ,ghc-hunit)
 989                      ("ghc-hspec" ,ghc-hspec)
 990                      ("ghc-quickcheck" ,ghc-quickcheck)))
 991     (home-page "https://github.com/yesodweb/path-pieces")
 992     (synopsis "Used in Yesod to automatically marshall data in the request path")
 993     (description  "This Haskell package provides two typeclasses for converting
 994 Haskell data types to and from route pieces.")
 995     (license license:bsd-3)))
 996
 997 (define-public ghc-skein
 998   (package
 999     (name "ghc-skein")
1000     (version "1.0.9.4")
1001     (source
1002      (origin
1003        (method url-fetch)
1004        (uri (string-append "https://hackage.haskell.org/package/"
1005                            "skein-" version "/"
1006                            "skein-" version ".tar.gz"))
1007        (sha256
1008         (base32
1009          "1jdqdk0rz2wnvw735clnj8jh0a9rkrbqjg7vk3w6wczdql6cm0pq"))))
1010     (build-system haskell-build-system)
1011     (inputs `(("ghc-cereal" ,ghc-cereal)
1012               ("ghc-tagged" ,ghc-tagged)
1013               ("ghc-crpto-api" ,ghc-crypto-api)))
1014     (native-inputs `(("ghc-hspec" ,ghc-hspec)))
1015     (home-page "https://github.com/yesodweb/path-pieces")
1016     (synopsis "Skein family of cryptographic hash functions for Haskell")
1017     (description "@uref{(http://www.skein-hash.info, Skein} is a family of
1018 fast secure cryptographic hash functions designed by Niels Ferguson, Stefan
1019 Lucks, Bruce Schneier, Doug Whiting, Mihir Bellare, Tadayoshi Kohno, Jon
1020 Callas and Jesse Walker.
1021
1022 This Haskell package uses bindings to the optimized C implementation of Skein.")
1023     (license license:bsd-3)))
1024
1025 (define-public ghc-clientsession
1026   (package
1027     (name "ghc-clientsession")
1028     (version "0.9.1.2")
1029     (source
1030      (origin
1031        (method url-fetch)
1032        (uri (string-append "https://hackage.haskell.org/package/"
1033                            "clientsession-" version "/"
1034                            "clientsession-" version ".tar.gz"))
1035        (sha256
1036         (base32
1037          "0s6h4ykj16mpf7nlw2iqn2ji0p8g1fn5ni0s7yqaili6vv2as5ar"))))
1038     (build-system haskell-build-system)
1039     (inputs `(("ghc-cereal" ,ghc-cereal)
1040               ("ghc-tagged" ,ghc-tagged)
1041               ("ghc-crypto-api" ,ghc-crypto-api)
1042               ("ghc-skein" ,ghc-skein)
1043               ("ghc-base64-bytestring" ,ghc-base64-bytestring)
1044               ("ghc-entropy" ,ghc-entropy)
1045               ("ghc-cprng-aes" ,ghc-cprng-aes)
1046               ("ghc-cipher-aes" ,ghc-cipher-aes)
1047               ("ghc-crypto-random" ,ghc-crypto-random)
1048               ("ghc-setenv" ,ghc-setenv)))
1049     (native-inputs `(("ghc-hunit" ,ghc-hunit)
1050                      ("ghc-hspec" ,ghc-hspec)
1051                      ("ghc-quickcheck" ,ghc-quickcheck)))
1052     (home-page "https://github.com/yesodweb/clientsession/tree/master")
1053     (synopsis "Haskell library for securely store session data in a
1054 client-side cookie")
1055     (description "This Haskell package achieves security through AES-CTR
1056 encryption and Skein-MAC-512-256 authentication.  Uses Base64 encoding to
1057 avoid any issues with characters.")
1058     (license license:expat)))
1059
1060 (define-public ghc-yesod-core
1061   (package
1062     (name "ghc-yesod-core")
1063     (version "1.6.16.1")
1064     (source
1065      (origin
1066        (method url-fetch)
1067        (uri (string-append "https://hackage.haskell.org/package/"
1068                            "yesod-core-" version "/"
1069                            "yesod-core-" version ".tar.gz"))
1070        (sha256
1071         (base32
1072          "0a0yv7wkwvb0n6iia532y9nzrirgnm09pjc8hpm0lx4ff609pgd2"))))
1073     (build-system haskell-build-system)
1074     (inputs `(("ghc-wai" ,ghc-wai)
1075               ("ghc-extra" ,ghc-extra)
1076               ("ghc-shakespeare" ,ghc-shakespeare)
1077               ("ghc-blaze-builder" ,ghc-blaze-builder)
1078               ("ghc-clientsession" ,ghc-clientsession)
1079               ("ghc-random" ,ghc-random)
1080               ("ghc-cereal" ,ghc-cereal)
1081               ("ghc-old-locale" ,ghc-old-locale)
1082               ("ghc-unliftio" ,ghc-unliftio)
1083               ("ghc-unordered-containers" ,ghc-unordered-containers)
1084               ("ghc-monad-control" ,ghc-monad-control)
1085               ("ghc-transformers-base" ,ghc-transformers-base)
1086               ("ghc-cookie" ,ghc-cookie)
1087               ("ghc-http-types" ,ghc-http-types)
1088               ("ghc-case-insensitive" ,ghc-case-insensitive)
1089               ("ghc-vector" ,ghc-vector)
1090               ("ghc-aeson" ,ghc-aeson)
1091               ("ghc-fast-logger" ,ghc-fast-logger)
1092               ("ghc-wai-logger" ,ghc-wai-logger)
1093               ("ghc-monad-logger" ,ghc-monad-logger)
1094               ("ghc-conduit" ,ghc-conduit)
1095               ("ghc-resourcet" ,ghc-resourcet)
1096               ("ghc-rio" ,ghc-rio)
1097               ("ghc-lifted-base" ,ghc-lifted-base)
1098               ("ghc-blaze-html" ,ghc-blaze-html)
1099               ("ghc-blaze-markup" ,ghc-blaze-markup)
1100               ("ghc-data-default" ,ghc-data-default)
1101               ("ghc-safe" ,ghc-safe)
1102               ("ghc-warp" ,ghc-warp)
1103               ("ghc-unix-compat" ,ghc-unix-compat)
1104               ("ghc-conduit-extra" ,ghc-conduit-extra)
1105               ("ghc-exceptions" ,ghc-exceptions)
1106               ("ghc-deepseq-generics" ,ghc-deepseq-generics)
1107               ("ghc-mwc-random" ,ghc-mwc-random)
1108               ("ghc-primitive" ,ghc-primitive)
1109               ("ghc-word8" ,ghc-word8)
1110               ("ghc-auto-update" ,ghc-auto-update)
1111               ("ghc-semigroups" ,ghc-semigroups)
1112               ("ghc-byteable" ,ghc-byteable)))
1113     (native-inputs `(("ghc-hspec" ,ghc-hspec)
1114                      ("ghc-path-pieces" ,ghc-path-pieces)
1115                      ("ghc-hunit" ,ghc-hunit)
1116                      ("ghc-hspec-expectations" ,ghc-hspec-expectations)
1117                      ("ghc-quickcheck" ,ghc-quickcheck)
1118                      ("ghc-network" ,ghc-network)
1119                      ("ghc-async" ,ghc-async)
1120                      ("ghc-streaming-commons" ,ghc-streaming-commons)
1121                      ("ghc-wai-extra" ,ghc-wai-extra)))
1122     (home-page "https://www.yesodweb.com")
1123     (synopsis "Core package for the Yesod web framework")
1124     (description "This Haskell package provides all core functionality, for
1125 Yesod, on which other packages can be built.  It provides dispatch, handler
1126 functions, widgets, etc.")
1127     (license license:expat)))
1128
1129 (define-public ghc-yesod-persistent
1130   (package
1131     (name "ghc-yesod-persistent")
1132     (version "1.6.0.4")
1133     (source
1134      (origin
1135        (method url-fetch)
1136        (uri (string-append "https://hackage.haskell.org/package/"
1137                            "yesod-persistent-" version "/"
1138                            "yesod-persistent-" version ".tar.gz"))
1139        (sha256
1140         (base32
1141          "1gsiw2zx6z7za7a164h0fxfggkrdqz6fn0qyb2zn9qr7r2jbg1c0"))))
1142     (build-system haskell-build-system)
1143     (arguments `(#:tests? #f)) ; FIXME: hspec-discover not available in PATH.
1144     (inputs `(("ghc-yesod-core" ,ghc-yesod-core)
1145               ("ghc-persistent" ,ghc-persistent)
1146               ("ghc-persistent-template" ,ghc-persistent-template)
1147               ("ghc-blaze-builder" ,ghc-blaze-builder)
1148               ("ghc-conduit" ,ghc-conduit)
1149               ("ghc-resourcet" ,ghc-resourcet)
1150               ("ghc-resource-pool" ,ghc-resource-pool)))
1151     (native-inputs `(("ghc-hspec" ,ghc-hspec)
1152                      ("ghc-wai-extra" ,ghc-wai-extra)
1153                      ("ghc-yesod-core" ,ghc-yesod-core)
1154                      ("ghc-persistent-sqlite" ,ghc-persistent-sqlite)))
1155     (home-page "http://www.yesodweb.com/")
1156     (synopsis "Helpers for using Persistent from Yesod")
1157     (description "This Haskell package provides helpers for using Persistent
1158 from Yesod.")
1159     (license license:expat)))
1160
1161 (define-public ghc-yesod-form
1162     (package
1163     (name "ghc-yesod-form")
1164     (version "1.6.7")
1165     (source
1166       (origin
1167         (method url-fetch)
1168         (uri (string-append
1169                "https://hackage.haskell.org/package/yesod-form/yesod-form-"
1170                version
1171                ".tar.gz"))
1172         (sha256
1173           (base32
1174             "0mny71dyp6cp5akyp5wvmrhmip5rkqi8ibdn3lipvmajx9h58r5d"))))
1175     (build-system haskell-build-system)
1176     (inputs
1177       `(("ghc-yesod-core" ,ghc-yesod-core)
1178         ("ghc-yesod-persistent" ,ghc-yesod-persistent)
1179         ("ghc-shakespeare" ,ghc-shakespeare)
1180         ("ghc-persistent" ,ghc-persistent)
1181         ("ghc-data-default" ,ghc-data-default)
1182         ("ghc-xss-sanitize" ,ghc-xss-sanitize)
1183         ("ghc-blaze-builder" ,ghc-blaze-builder)
1184         ("ghc-email-validate" ,ghc-email-validate)
1185         ("ghc-wai" ,ghc-wai)
1186         ("ghc-blaze-html" ,ghc-blaze-html)
1187         ("ghc-blaze-markup" ,ghc-blaze-markup)
1188         ("ghc-attoparsec" ,ghc-attoparsec)
1189         ("ghc-byteable" ,ghc-byteable)
1190         ("ghc-aeson" ,ghc-aeson)
1191         ("ghc-resourcet" ,ghc-resourcet)
1192         ("ghc-semigroups" ,ghc-semigroups)
1193         ("ghc-network-uri" ,ghc-network-uri)
1194         ("ghc-hspec" ,ghc-hspec)))
1195     (home-page "https://www.yesodweb.com")
1196     (synopsis "Form handling support for Yesod Web Framework")
1197     (description "This Haskell package provies a set of basic form inputs such
1198 as text, number, time, checkbox, select, textarea, etc through the
1199 @code{Yesod.Form.Fields} module.  Also, there is @code{Yesod.Form.Nic} module
1200 providing richtext field using Nic editor. ")
1201     (license license:expat)))
1202
1203 (define-public ghc-yesod
1204   (package
1205     (name "ghc-yesod")
1206     (version "1.6.0")
1207     (source
1208      (origin
1209        (method url-fetch)
1210        (uri (string-append
1211              "https://hackage.haskell.org/package/yesod/yesod-"
1212              version ".tar.gz"))
1213        (sha256
1214         (base32
1215          "0wx77nbpzdh40p1bm527kimfj48vs9d2avpvvz2w42zi3pz2y94a"))))
1216     (build-system haskell-build-system)
1217     (inputs
1218      `(("ghc-yesod-core" ,ghc-yesod-core)
1219        ("ghc-yesod-persistent" ,ghc-yesod-persistent)
1220        ("ghc-yesod-form" ,ghc-yesod-form)
1221        ("ghc-monad-control" ,ghc-monad-control)
1222        ("ghc-wai" ,ghc-wai)
1223        ("ghc-wai-extra" ,ghc-wai-extra)
1224        ("ghc-warp" ,ghc-warp)
1225        ("ghc-blaze-html" ,ghc-blaze-html)
1226        ("ghc-blaze-markup" ,ghc-blaze-markup)
1227        ("ghc-aeson" ,ghc-aeson)
1228        ("ghc-data-default-class" ,ghc-data-default-class)
1229        ("ghc-unordered-containers" ,ghc-unordered-containers)
1230        ("ghc-yaml" ,ghc-yaml)
1231        ("ghc-monad-logger" ,ghc-monad-logger)
1232        ("ghc-fast-logger" ,ghc-fast-logger)
1233        ("ghc-conduit" ,ghc-conduit)
1234        ("ghc-conduit-extra" ,ghc-conduit-extra)
1235        ("ghc-resourcet" ,ghc-resourcet)
1236        ("ghc-shakespeare" ,ghc-shakespeare)
1237        ("ghc-streaming-commons" ,ghc-streaming-commons)
1238        ("ghc-wai-logger" ,ghc-wai-logger)
1239        ("ghc-semigroups" ,ghc-semigroups)))
1240     (home-page "https://www.yesodweb.com")
1241     (synopsis "Framework for creating type-safe, RESTful web applications")
1242     (description "The Haskell package package groups together the various
1243 Yesod related packages into one cohesive whole.  This is the version of Yesod,
1244 whereas most of the core code lives in @code{ghc-yesod-core}.")
1245     (license license:expat)))
1246
1247 (define-public ghc-hxt-charproperties
1248   (package
1249     (name "ghc-hxt-charproperties")
1250     (version "9.4.0.0")
1251     (source
1252      (origin
1253        (method url-fetch)
1254        (uri (string-append "https://hackage.haskell.org/package/"
1255                            "hxt-charproperties/hxt-charproperties-"
1256                            version ".tar.gz"))
1257        (sha256
1258         (base32
1259          "1bk88hj2pqlvcnyfncqyb9j7w9vvdxcq3cgr0w2l09c0abas23pm"))))
1260     (build-system haskell-build-system)
1261     (home-page "https://github.com/UweSchmidt/hxt")
1262     (synopsis "Character properties and classes for XML and Unicode")
1263     (description
1264      "The modules provided by this package contain predicates for Unicode
1265 blocks and char properties and character predicates defined by XML.  The
1266 supported Unicode version is 7.0.0")
1267     (license license:expat)))
1268
1269 (define-public ghc-hxt-unicode
1270   (package
1271     (name "ghc-hxt-unicode")
1272     (version "9.0.2.4")
1273     (source
1274      (origin
1275        (method url-fetch)
1276        (uri (string-append
1277              "https://hackage.haskell.org/package/hxt-unicode/hxt-unicode-"
1278              version
1279              ".tar.gz"))
1280        (sha256
1281         (base32
1282          "0rj48cy8z4fl3zpg5bpa458kqr83adav6jnqv4i71dclpprj6n3v"))))
1283     (build-system haskell-build-system)
1284     (inputs
1285      `(("ghc-hxt-charproperties" ,ghc-hxt-charproperties)))
1286     (home-page
1287      "http://www.fh-wedel.de/~si/HXmlToolbox/index.html https://github.com/UweSchmidt/hxt")
1288     (synopsis
1289      "Unicode en-/decoding functions for utf8, iso-latin-* and other encodings")
1290     (description
1291      "This package provides Unicode encoding and decoding functions for
1292 encodings used in the Haskell XML Toolbox.  ISO Latin 1-16, utf8, utf16, ASCII
1293 are supported. Decoding is done with lazy functions, errors may be detected or
1294 ignored.")
1295     (license license:expat)))
1296
1297 (define-public ghc-hxt-regex-xmlschema
1298   (package
1299     (name "ghc-hxt-regex-xmlschema")
1300     (version "9.2.0.3")
1301     (source
1302      (origin
1303        (method url-fetch)
1304        (uri (string-append "https://hackage.haskell.org/package/"
1305                            "hxt-regex-xmlschema/hxt-regex-xmlschema-"
1306                            version ".tar.gz"))
1307        (sha256
1308         (base32
1309          "1c4jr0439f5yc05h7iz53fa47g6l2wrvqp6gvwf01mlqajk3nx7l"))))
1310     (build-system haskell-build-system)
1311     (inputs
1312      `(("ghc-hxt-charproperties" ,ghc-hxt-charproperties)
1313        ("ghc-hunit" ,ghc-hunit)))
1314     (home-page "http://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema")
1315     (synopsis "Regular expression library for W3C XML Schema regular expressions")
1316     (description
1317      "This library supports full W3C XML Schema regular expressions inclusive
1318 all Unicode character sets and blocks.  It is implemented by the technique of
1319 derivations of regular expressions.")
1320     (license license:expat)))
1321
1322 (define-public ghc-hxt
1323   (package
1324     (name "ghc-hxt")
1325     (version "9.3.1.18")
1326     (source
1327      (origin
1328        (method url-fetch)
1329        (uri (string-append
1330              "https://hackage.haskell.org/package/hxt/hxt-"
1331              version
1332              ".tar.gz"))
1333        (sha256
1334         (base32
1335          "0836k65px3w9c5h1h2bmzq5a7mp6ajxwvfg3pfr2kbxwkgc0j63j"))))
1336     (build-system haskell-build-system)
1337     (inputs
1338      `(("ghc-hxt-charproperties" ,ghc-hxt-charproperties)
1339        ("ghc-hxt-unicode" ,ghc-hxt-unicode)
1340        ("ghc-hxt-regex-xmlschema" ,ghc-hxt-regex-xmlschema)
1341        ("ghc-network-uri" ,ghc-network-uri)))
1342     (home-page "https://github.com/UweSchmidt/hxt")
1343     (synopsis "Collection of tools for processing XML with Haskell")
1344     (description
1345      "The Haskell XML Toolbox bases on the ideas of HaXml and HXML, but
1346 introduces a more general approach for processing XML with Haskell.")
1347     (license license:expat)))
1348
1349 (define-public ghc-http-common
1350   (package
1351     (name "ghc-http-common")
1352     (version "0.8.2.0")
1353     (source
1354      (origin
1355        (method url-fetch)
1356        (uri (string-append "https://hackage.haskell.org/package/"
1357                            "http-common/http-common-" version ".tar.gz"))
1358        (sha256
1359         (base32
1360          "14s5a178sb2vm5k00rs21760mds5dz2gs10k9iyn22h01mxyf599"))))
1361     (build-system haskell-build-system)
1362     (inputs
1363      `(("ghc-base64-bytestring" ,ghc-base64-bytestring)
1364        ("ghc-blaze-builder" ,ghc-blaze-builder)
1365        ("ghc-case-insensitive" ,ghc-case-insensitive)
1366        ("ghc-network" ,ghc-network)
1367        ("ghc-unordered-containers" ,ghc-unordered-containers)))
1368     (home-page "https://github.com/afcowie/http-streams/")
1369     (synopsis "Common types for HTTP clients and servers")
1370     (description "Base types used by a variety of HTTP clients and
1371 servers.  See http-streams @code{Network.Http.Client} or pipes-http
1372 @code{Pipes.Http.Client} for full documentation.  You can import
1373 @code{Network.Http.Types} if you like, but both http-streams and
1374 pipes-http re-export this package's types and functions.")
1375     (license license:bsd-3)))
1376
1377 (define-public ghc-http-streams
1378   (package
1379     (name "ghc-http-streams")
1380     (version "0.8.6.1")
1381     (source
1382      (origin
1383        (method url-fetch)
1384        (uri (string-append "https://hackage.haskell.org/package/"
1385                            "http-streams/http-streams-" version ".tar.gz"))
1386        (sha256
1387         (base32
1388          "18vxd35n7s3z4gjvad94bknc8z1w9d7ccgphnhsxlz5cackizmxq"))))
1389     (build-system haskell-build-system)
1390     (inputs
1391      `(("ghc-attoparsec" ,ghc-attoparsec)
1392        ("ghc-base64-bytestring" ,ghc-base64-bytestring)
1393        ("ghc-blaze-builder" ,ghc-blaze-builder)
1394        ("ghc-case-insensitive" ,ghc-case-insensitive)
1395        ("ghc-io-streams" ,ghc-io-streams)
1396        ("ghc-hsopenssl" ,ghc-hsopenssl)
1397        ("ghc-openssl-streams" ,ghc-openssl-streams)
1398        ("ghc-unordered-containers" ,ghc-unordered-containers)
1399        ("ghc-aeson" ,ghc-aeson)
1400        ("ghc-http-common" ,ghc-http-common)
1401        ("ghc-network-uri" ,ghc-network-uri)
1402        ("ghc-network" ,ghc-network)))
1403     (arguments
1404      `(#:tests? #f)) ; tests rely on an outdated version of snap-server
1405     (home-page "https://github.com/afcowie/http-streams/")
1406     (synopsis "HTTP client using io-streams")
1407     (description "An HTTP client using the Snap Framework's io-streams
1408 library to handle the streaming IO.  The API is optimized for ease of
1409 use for the rather common case of code needing to query web services and
1410 deal with the result.")
1411     (license license:bsd-3)))
1412
1413 (define-public ghc-snap-core
1414   (package
1415     (name "ghc-snap-core")
1416     (version "1.0.4.0")
1417     (source
1418      (origin
1419        (method url-fetch)
1420        (uri (string-append "https://hackage.haskell.org/package/"
1421                            "snap-core/snap-core-" version ".tar.gz"))
1422        (sha256
1423         (base32
1424          "0dklxgrbqhnb6bc4ic358g4fyj11ywmjrkxxhqcjmci2hhpn00mr"))))
1425     (build-system haskell-build-system)
1426     (inputs
1427      `(("ghc-old-locale" ,ghc-old-locale)
1428        ("ghc-hunit" ,ghc-hunit)
1429        ("ghc-attoparsec" ,ghc-attoparsec)
1430        ("ghc-bytestring-builder" ,ghc-bytestring-builder)
1431        ("ghc-case-insensitive" ,ghc-case-insensitive)
1432        ("ghc-lifted-base" ,ghc-lifted-base)
1433        ("ghc-io-streams" ,ghc-io-streams)
1434        ("ghc-hashable" ,ghc-hashable)
1435        ("ghc-monad-control" ,ghc-monad-control)
1436        ("ghc-random" ,ghc-random)
1437        ("ghc-readable" ,ghc-readable)
1438        ("ghc-regex-posix" ,ghc-regex-posix)
1439        ("ghc-transformers-base" ,ghc-transformers-base)
1440        ("ghc-unix-compat" ,ghc-unix-compat)
1441        ("ghc-unordered-containers" ,ghc-unordered-containers)
1442        ("ghc-vector" ,ghc-vector)
1443        ("ghc-network-uri" ,ghc-network-uri)
1444        ("ghc-network" ,ghc-network)))
1445     (native-inputs
1446      `(("ghc-quickcheck" ,ghc-quickcheck)
1447        ("ghc-parallel" ,ghc-parallel)
1448        ("ghc-test-framework" ,ghc-test-framework)
1449        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
1450        ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
1451        ("ghc-zlib" ,ghc-zlib)))
1452     (home-page "http://snapframework.com/")
1453     (synopsis "Haskell Web Framework (core interfaces and types)")
1454     (description "Snap is a simple and fast web development framework
1455 and server written in Haskell.  For more information, you can visit the
1456 Snap project website at @uref{http://snapframework.com/}.  This library
1457 contains the core definitions and types for the Snap framework.")
1458     (license license:bsd-3)))
1459
1460 (define-public ghc-snap-server
1461   (package
1462     (name "ghc-snap-server")
1463     (version "1.1.1.1")
1464     (source
1465      (origin
1466        (method url-fetch)
1467        (uri (string-append "https://hackage.haskell.org/package/"
1468                            "snap-server/snap-server-" version ".tar.gz"))
1469        (sha256
1470         (base32
1471          "0lw475wp0lnrbgc3jcfif3qjjc3pmrh2k74d8cgpnc1304g6a2s5"))))
1472     (build-system haskell-build-system)
1473     (inputs
1474      `(("ghc-attoparsec" ,ghc-attoparsec)
1475        ("ghc-blaze-builder" ,ghc-blaze-builder)
1476        ("ghc-bytestring-builder" ,ghc-bytestring-builder)
1477        ("ghc-case-insensitive" ,ghc-case-insensitive)
1478        ("ghc-clock" ,ghc-clock)
1479        ("ghc-io-streams" ,ghc-io-streams)
1480        ("ghc-io-streams-haproxy" ,ghc-io-streams-haproxy)
1481        ("ghc-lifted-base" ,ghc-lifted-base)
1482        ("ghc-network" ,ghc-network)
1483        ("ghc-old-locale" ,ghc-old-locale)
1484        ("ghc-snap-core" ,ghc-snap-core)
1485        ("ghc-unix-compat" ,ghc-unix-compat)
1486        ("ghc-vector" ,ghc-vector)))
1487     (native-inputs
1488      `(("ghc-base16-bytestring" ,ghc-base16-bytestring)
1489        ("ghc-monad-control" ,ghc-monad-control)
1490        ("ghc-random" ,ghc-random)
1491        ("ghc-threads" ,ghc-threads)
1492        ("ghc-hunit" ,ghc-hunit)
1493        ("ghc-quickcheck" ,ghc-quickcheck)
1494        ("ghc-http-streams" ,ghc-http-streams)
1495        ("ghc-http-common" ,ghc-http-common)
1496        ("ghc-parallel" ,ghc-parallel)
1497        ("ghc-test-framework" ,ghc-test-framework)
1498        ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
1499        ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
1500     (arguments
1501      `(#:cabal-revision
1502        ("1" "094b7ll47lxd4lvr6kd59jyw0vz686gw5cx16w758d6fli0cy3x3")))
1503     (home-page "http://snapframework.com/")
1504     (synopsis "Web server for the Snap Framework")
1505     (description "Snap is a simple and fast web development framework
1506 and server written in Haskell.  For more information, you can visit the
1507 Snap project website at @uref{http://snapframework.com/}.  The Snap HTTP
1508 server is a high performance web server library written in Haskell.
1509 Together with the snap-core library upon which it depends, it provides a
1510 clean and efficient Haskell programming interface to the HTTP
1511 protocol.")
1512     (license license:bsd-3)))
1513
1514 (define-public ghc-js-jquery
1515   (package
1516     (name "ghc-js-jquery")
1517     (version "3.3.1")
1518     (source
1519      (origin
1520        (method url-fetch)
1521        (uri
1522         (string-append
1523          "https://hackage.haskell.org/package/js-jquery/js-jquery-"
1524          version ".tar.gz"))
1525        (sha256
1526         (base32
1527          "16q68jzbs7kp07dnq8cprdcc8fd41rim38039vg0w4x11lgniq70"))))
1528     (build-system haskell-build-system)
1529     (arguments `(#:tests? #f)) ; tests do network IO
1530     (home-page "https://github.com/ndmitchell/js-jquery")
1531     (synopsis "Obtain minified jQuery code")
1532     (description "This package bundles the minified
1533 @url{http://jquery.com/, jQuery} code into a Haskell package, so it can
1534 be depended upon by Cabal packages.  The first three components of the
1535 version number match the upstream jQuery version.  The package is
1536 designed to meet the redistribution requirements of downstream
1537 users (e.g. Debian).")
1538     (license license:expat)))
1539
1540 (define-public ghc-js-flot
1541   (package
1542     (name "ghc-js-flot")
1543     (version "0.8.3")
1544     (source
1545      (origin
1546        (method url-fetch)
1547        (uri
1548         (string-append
1549          "https://hackage.haskell.org/package/js-flot/js-flot-"
1550          version ".tar.gz"))
1551        (sha256
1552         (base32
1553          "0yjyzqh3qzhy5h3nql1fckw0gcfb0f4wj9pm85nafpfqp2kg58hv"))))
1554     (build-system haskell-build-system)
1555     (inputs
1556      `(("ghc-http" ,ghc-http)))
1557     (home-page "https://github.com/ndmitchell/js-flot")
1558     (synopsis "Obtain minified flot code")
1559     (description "This package bundles the minified
1560 @url{http://www.flotcharts.org/, Flot} code (a jQuery plotting library)
1561 into a Haskell package, so it can be depended upon by Cabal packages.
1562 The first three components of the version number match the upstream flot
1563 version.  The package is designed to meet the redistribution
1564 requirements of downstream users (e.g. Debian).")
1565     (license license:expat)))
1566
1567 (define-public ghc-happstack-server
1568   (package
1569     (name "ghc-happstack-server")
1570     (version "7.5.4")
1571     (source
1572      (origin
1573        (method url-fetch)
1574        (uri (string-append
1575              "https://hackage.haskell.org/package/happstack-server/happstack-server-"
1576              version ".tar.gz"))
1577        (sha256
1578         (base32
1579          "0i7csvmwv7n68gkwqzi985p2mjdgzipjnlj873sdiknhx9pfmq70"))))
1580     (build-system haskell-build-system)
1581     (inputs
1582      `(("ghc-network" ,ghc-network)
1583        ("ghc-network-bsd" ,ghc-network-bsd)
1584        ("ghc-network-uri" ,ghc-network-uri)
1585        ("ghc-base64-bytestring" ,ghc-base64-bytestring)
1586        ("ghc-blaze-html" ,ghc-blaze-html)
1587        ("ghc-exceptions" ,ghc-exceptions)
1588        ("ghc-extensible-exceptions"
1589         ,ghc-extensible-exceptions)
1590        ("ghc-hslogger" ,ghc-hslogger)
1591        ("ghc-html" ,ghc-html)
1592        ("ghc-monad-control" ,ghc-monad-control)
1593        ("ghc-old-locale" ,ghc-old-locale)
1594        ("ghc-semigroups" ,ghc-semigroups)
1595        ("ghc-sendfile" ,ghc-sendfile)
1596        ("ghc-system-filepath" ,ghc-system-filepath)
1597        ("ghc-syb" ,ghc-syb)
1598        ("ghc-threads" ,ghc-threads)
1599        ("ghc-transformers-base" ,ghc-transformers-base)
1600        ("ghc-transformers-compat"
1601         ,ghc-transformers-compat)
1602        ("ghc-utf8-string" ,ghc-utf8-string)
1603        ("ghc-zlib" ,ghc-zlib)))
1604     (native-inputs `(("ghc-hunit" ,ghc-hunit)))
1605     (home-page "http://happstack.com")
1606     (synopsis "Web related tools and services for Haskell")
1607     (description
1608      "Happstack Server provides an HTTP server and a rich set of functions for
1609 routing requests, handling query parameters, generating responses, working with
1610 cookies, serving files, and more.")
1611     (license license:bsd-3)))
1612
1613 (define-public ghc-sendfile
1614   (package
1615     (name "ghc-sendfile")
1616     (version "0.7.11.1")
1617     (source
1618      (origin
1619        (method url-fetch)
1620        (uri (string-append
1621              "https://hackage.haskell.org/package/sendfile/sendfile-"
1622              version ".tar.gz"))
1623        (sha256
1624         (base32
1625          "0988snmx3bylpw3kcq8hsgji8idc6xcrcfp275qjv3apfdgc9rp0"))))
1626     (build-system haskell-build-system)
1627     (inputs `(("ghc-network" ,ghc-network)))
1628     (home-page
1629      "https://hub.darcs.net/stepcut/sendfile")
1630     (synopsis "Portable sendfile library for Haskell")
1631     (description
1632      "Haskell library which exposes zero-copy sendfile functionality in a portable way.")
1633     (license license:bsd-3)))
1634
1635 (define-public ghc-scalpel-core
1636   (package
1637     (name "ghc-scalpel-core")
1638     (version "0.6.0")
1639     (source
1640       (origin
1641         (method url-fetch)
1642         (uri (string-append
1643                "https://hackage.haskell.org/package/scalpel-core/"
1644                "scalpel-core-" version ".tar.gz"))
1645         (sha256
1646          (base32
1647           "1qf0gnidyh8zk0acj99vn6hsj37m410lrm50sqpiv1i36rpmmsqh"))))
1648     (build-system haskell-build-system)
1649     (inputs
1650      `(("ghc-data-default" ,ghc-data-default)
1651        ("ghc-fail" ,ghc-fail)
1652        ("ghc-pointedlist" ,ghc-pointedlist)
1653        ("ghc-regex-base" ,ghc-regex-base)
1654        ("ghc-regex-tdfa" ,ghc-regex-tdfa)
1655        ("ghc-tagsoup" ,ghc-tagsoup)
1656        ("ghc-vector" ,ghc-vector)))
1657     (native-inputs `(("ghc-hunit" ,ghc-hunit)))
1658     (home-page "https://github.com/fimad/scalpel")
1659     (synopsis
1660      "High level web scraping library for Haskell")
1661     (description
1662      "Scalpel core provides a subset of the scalpel web scraping library
1663 that is intended to have lightweight dependencies and to be free of all
1664 non-Haskell dependencies.")
1665     (license license:asl2.0)))
1666
1667 (define-public ghc-scalpel
1668   (package
1669     (name "ghc-scalpel")
1670     (version "0.6.0")
1671     (source
1672       (origin
1673         (method url-fetch)
1674         (uri (string-append
1675                "https://hackage.haskell.org/package/scalpel/"
1676                "scalpel-" version ".tar.gz"))
1677         (sha256
1678          (base32
1679           "0jbrfcgljl8kbcwi2zqx1jp3c3dpxrkc94za44x56kcz68n89hlz"))))
1680     (build-system haskell-build-system)
1681     (inputs
1682      `(("ghc-scalpel-core" ,ghc-scalpel-core)
1683        ("ghc-case-insensitive" ,ghc-case-insensitive)
1684        ("ghc-data-default" ,ghc-data-default)
1685        ("ghc-http-client" ,ghc-http-client)
1686        ("ghc-http-client-tls" ,ghc-http-client-tls)
1687        ("ghc-tagsoup" ,ghc-tagsoup)))
1688     (home-page "https://github.com/fimad/scalpel")
1689     (synopsis
1690      "High level web scraping library for Haskell")
1691     (description
1692      "Scalpel is a web scraping library inspired by libraries like Parsec
1693 and Perl's @code{Web::Scraper}.  Scalpel builds on top of TagSoup to provide a
1694 declarative and monadic interface.")
1695     (license license:asl2.0)))