;;; Copyright © 2015 Federico Beffa <beffa@fbengineering.ch>
;;; Copyright © 2015 Siniša Biđin <sinisa@bidin.eu>
;;; Copyright © 2015 Paul van der Walt <paul@denknerd.org>
+;;; Copyright © 2015 Eric Bavier <bavier@member.fsf.org>
;;;
;;; This file is part of GNU Guix.
;;;
(define-module (gnu packages haskell)
#:use-module (ice-9 regex)
- #:use-module ((guix licenses) #:select (bsd-3 lgpl2.1 lgpl2.1+ gpl3+ expat))
+ #:use-module ((guix licenses) #:select (bsd-3
+ lgpl2.1 lgpl2.1+ gpl2+ gpl3+
+ public-domain
+ expat))
#:use-module (guix packages)
#:use-module (guix download)
#:use-module (guix utils)
#:use-module (gnu packages perl)
#:use-module (gnu packages compression)
#:use-module (gnu packages elf)
+ #:use-module (gnu packages gl)
+ #:use-module (gnu packages sdl)
#:use-module (gnu packages bootstrap)
#:use-module (gnu packages zip)
#:use-module (gnu packages gcc)
#:use-module (gnu packages ghostscript)
#:use-module (gnu packages libffi)
#:use-module (gnu packages libedit)
+ #:use-module (gnu packages lua)
#:use-module (gnu packages multiprecision)
#:use-module (gnu packages ncurses)
#:use-module (gnu packages python)
#:use-module (gnu packages pcre)
+ #:use-module ((gnu packages xml) #:select (libxml2))
#:use-module (gnu packages xorg))
(define ghc-bootstrap-x86_64-7.8.4
interactive environment for the functional language Haskell.")
(license bsd-3)))
+(define-public ghc-hostname
+ (package
+ (name "ghc-hostname")
+ (version "1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/hostname/"
+ "hostname-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0p6gm4328946qxc295zb6vhwhf07l1fma82vd0siylnsnsqxlhwv"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/hostname")
+ (synopsis "Hostname in Haskell")
+ (description "Network.HostName is a simple package providing a means to
+determine the hostname.")
+ (license bsd-3)))
+
+(define-public ghc-libxml
+ (package
+ (name "ghc-libxml")
+ (version "0.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/libxml/"
+ "libxml-" version ".tar.gz"))
+ (sha256
+ (base32
+ "01zvk86kg726lf2vnlr7dxiz7g3xwi5a4ak9gcfbwyhynkzjmsfi"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("libxml2" ,libxml2)))
+ (arguments
+ `(#:configure-flags
+ `(,(string-append "--extra-include-dirs="
+ (assoc-ref %build-inputs "libxml2")
+ "/include/libxml2"))))
+ (home-page "http://hackage.haskell.org/package/libxml")
+ (synopsis "Haskell bindings to libxml2")
+ (description
+ "This library provides minimal Haskell binding to libxml2.")
+ (license bsd-3)))
+
(define-public ghc-prelude-extras
(package
(name "ghc-prelude-extras")
documentation-generation tool for Haskell libraries.")
(license bsd-3)))
+(define-public ghc-haddock
+ (package
+ (name "ghc-haddock")
+ (version "2.16.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/haddock/haddock-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1mnnvc5jqp6n6rj7xw8wdm0z2xp9fndkz11c8p3vbljsrcqd3v26"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: Tests break with GHC 7.10.2, fixed
+ ; upstream. See
+ ; <https://github.com/haskell/haddock/issues/427>
+ (inputs `(("ghc-haddock-api" ,ghc-haddock-api)))
+ (home-page "http://www.haskell.org/haddock/")
+ (synopsis
+ "Documentation-generation tool for Haskell libraries")
+ (description
+ "Haddock is a documentation-generation tool for Haskell libraries.")
+ (license bsd-3)))
+
(define-public ghc-simple-reflect
(package
(name "ghc-simple-reflect")
them.")
(license bsd-3)))
+(define-public ghc-multipart
+ (package
+ (name "ghc-multipart")
+ (version "0.1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/multipart/multipart-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-parsec" ,ghc-parsec)))
+ (home-page
+ "http://www.github.com/silkapp/multipart")
+ (synopsis
+ "HTTP multipart library")
+ (description
+ "HTTP multipart split out of the cgi package, for Haskell.")
+ (license bsd-3)))
+
+(define-public ghc-html
+ (package
+ (name "ghc-html")
+ (version "1.0.1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/html/html-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c"))))
+ (build-system haskell-build-system)
+ (home-page
+ "http://hackage.haskell.org/package/html")
+ (synopsis "HTML combinator library")
+ (description
+ "This package contains a combinator library for constructing HTML
+documents.")
+ (license bsd-3)))
+
+(define-public ghc-xhtml
+ (package
+ (name "ghc-xhtml")
+ (version "3000.2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/xhtml/xhtml-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1n6wgzxbj8xf0wf1il827qidphnffb5vzhwzqlxhh70c2y10f0ik"))))
+ (build-system haskell-build-system)
+ (home-page "https://github.com/haskell/xhtml")
+ (synopsis "XHTML combinator library")
+ (description
+ "This package provides combinators for producing XHTML 1.0, including the
+Strict, Transitional and Frameset variants.")
+ (license bsd-3)))
+
+(define-public ghc-haskell-src
+ (package
+ (name "ghc-haskell-src")
+ (version "1.0.2.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/haskell-src/haskell-src-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "19lilhpwnjb7cks9fq1ipnc8f7dwxy0ri3dgjkdxs3i355byw99a"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-happy" ,ghc-happy)
+ ("ghc-syb" ,ghc-syb)))
+ (home-page
+ "http://hackage.haskell.org/package/haskell-src")
+ (synopsis
+ "Support for manipulating Haskell source code")
+ (description
+ "The 'haskell-src' package provides support for manipulating Haskell
+source code. The package provides a lexer, parser and pretty-printer, and a
+definition of a Haskell abstract syntax tree (AST). Common uses of this
+package are to parse or generate Haskell 98 code.")
+ (license bsd-3)))
+
+(define-public ghc-alex
+ (package
+ (name "ghc-alex")
+ (version "3.1.4")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/alex/alex-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "17x13nbbr79xgdlzywjqw19vcl6iygjnssjnxnajgijkv764wknn"))))
+ (build-system haskell-build-system)
+ (arguments `(#:tests? #f)) ; FIXME: Tests broken for GHC 7.10. Fixed
+ ; upstream, see
+ ; <https://github.com/simonmar/alex/issues/62>
+ (inputs `(("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "http://www.haskell.org/alex/")
+ (synopsis
+ "Tool for generating lexical analysers in Haskell")
+ (description
+ "Alex is a tool for generating lexical analysers in Haskell. It takes a
+description of tokens based on regular expressions and generates a Haskell
+module containing code for scanning text efficiently. It is similar to the
+tool lex or flex for C/C++.")
+ (license bsd-3)))
+
+(define-public ghc-cgi
+ (package
+ (name "ghc-cgi")
+ (version "3001.2.2.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/cgi/cgi-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0q1pxpa8gi42c0hsidcdkhk5xr5anfrvhqsn3iksr9c0rllhz193"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-parsec" ,ghc-parsec)
+ ("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-old-time" ,ghc-old-time)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-multipart" ,ghc-multipart)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-network" ,ghc-network)
+ ("ghc-mtl" ,ghc-mtl)))
+ (home-page
+ "https://github.com/cheecheeo/haskell-cgi")
+ (synopsis "Library for writing CGI programs")
+ (description
+ "This is a Haskell library for writing CGI programs.")
+ (license bsd-3)))
+
(define-public ghc-cmdargs
(package
(name "ghc-cmdargs")
(base32
"1h8gjw5g92rvvzadqzpscg73x7ajvs1wlphrh27afim3scdd8frz"))))
(build-system haskell-build-system)
- (inputs
+ (propagated-inputs
`(("cpphs" ,cpphs)
("ghc-mtl" ,ghc-mtl)
- ("ghc-smallcheck" ,ghc-smallcheck)
- ("ghc-tasty" ,ghc-tasty)
("ghc-happy" ,ghc-happy)
- ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
- ("ghc-tasty-golden" ,ghc-tasty-golden)
("ghc-syb" ,ghc-syb)))
+ (native-inputs
+ `(("ghc-smallcheck" ,ghc-smallcheck)
+ ("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
+ ("ghc-tasty-golden" ,ghc-tasty-golden)))
(home-page "https://github.com/haskell-suite/haskell-src-exts")
(synopsis "Library for manipulating Haskell source")
(description "Haskell-Source with Extensions (HSE, haskell-src-exts) is an
attacks.")
(license bsd-3)))
-(define-public ghc-streaming-commons
+(define-public ghc-objectname
(package
- (name "ghc-streaming-commons")
- (version "0.1.14.2")
+ (name "ghc-objectname")
+ (version "1.1.0.0")
(source
(origin
(method url-fetch)
(uri (string-append
- "http://hackage.haskell.org/package/streaming-commons/streaming-commons-"
+ "http://hackage.haskell.org/package/ObjectName/ObjectName-"
version
".tar.gz"))
(sha256
(base32
- "12nw9bwvy6zrabkgvbp371klca3ds6qjlfncg1b8pbwx1y7m8c8h"))))
+ "0kh5fb9ykag6rfsm3f0bx3w323s18w2cyry34w5xgli5ncqimadg"))))
+ (build-system haskell-build-system)
+ (home-page "https://hackage.haskell.org/package/ObjectName")
+ (synopsis "Helper library for Haskell OpenGL")
+ (description "This tiny package contains the class ObjectName, which
+corresponds to the general notion of explicitly handled identifiers for API
+objects, e.g. a texture object name in OpenGL or a buffer object name in
+OpenAL.")
+ (license bsd-3)))
+
+(define-public ghc-sdl
+ (package
+ (name "ghc-sdl")
+ (version "0.6.5.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/SDL/SDL-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1sa3zx3vrs1gbinxx33zwq0x2bsf3i964bff7419p7vzidn36k46"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("sdl" ,sdl)))
+ (home-page "https://hackage.haskell.org/package/SDL")
+ (synopsis "LibSDL for Haskell")
+ (description "Simple DirectMedia Layer (libSDL) is a cross-platform
+multimedia library designed to provide low level access to audio, keyboard,
+mouse, joystick, 3D hardware via OpenGL, and 2D video framebuffer. It is used
+by MPEG playback software, emulators, and many popular games, including the
+award winning Linux port of \"Civilization: Call To Power.\"")
+ (license bsd-3)))
+
+(define-public ghc-sdl-mixer
+ (package
+ (name "ghc-sdl-mixer")
+ (version "0.6.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/SDL-mixer/SDL-mixer-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0md3238hx79mxb9a7l43kg3b3d28x4mqvj0hjsbsh15ajnvy9x2z"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:configure-flags
+ (let* ((sdl-mixer (assoc-ref %build-inputs "sdl-mixer"))
+ (sdl-mixer-include (string-append sdl-mixer "/include/SDL")))
+ (list (string-append "--extra-include-dirs=" sdl-mixer-include)))))
(propagated-inputs
- `(("ghc-random" ,ghc-random)))
+ `(("ghc-sdl" ,ghc-sdl)))
(inputs
- `(("ghc-quickcheck" ,ghc-quickcheck)
- ("ghc-async" ,ghc-async)
- ("ghc-blaze-builder" ,ghc-blaze-builder)
- ("ghc-hspec" ,ghc-hspec)
- ("ghc-stm" ,ghc-stm)
- ("ghc-text" ,ghc-text)
- ("ghc-network" ,ghc-network)
- ("ghc-zlib" ,ghc-zlib)))
- (home-page "https://hackage.haskell.org/package/streaming-commons")
- (synopsis "Conduit and pipes needed by some streaming data libraries")
- (description "Provides low-dependency functionality commonly needed by
-various Haskell streaming data libraries, such as @code{conduit} and
-@code{pipe}s.")
+ `(("sdl-mixer" ,sdl-mixer)))
+ (home-page "http://hackage.haskell.org/package/SDL-mixer")
+ (synopsis "Haskell bindings to libSDL_mixer")
+ (description "SDL_mixer is a sample multi-channel audio mixer library. It
+supports any number of simultaneously playing channels of 16 bit stereo audio,
+plus a single channel of music, mixed by the popular MikMod MOD, Timidity
+MIDI, Ogg Vorbis, and SMPEG MP3 libraries.")
(license bsd-3)))
-(define-public cpphs
+(define-public ghc-sdl-image
(package
- (name "cpphs")
- (version "1.19.3")
+ (name "ghc-sdl-image")
+ (version "0.6.1.1")
(source
(origin
(method url-fetch)
(uri (string-append
- "http://hackage.haskell.org/package/" name "/"
- name "-" version ".tar.gz"))
+ "http://hackage.haskell.org/package/SDL-image/SDL-image-"
+ version
+ ".tar.gz"))
(sha256
(base32
- "1njpmxgpah5pcqppcl1cxb5xicf6xlqrd162qm12khp9hainlm72"))))
+ "1m02q2426qp8m8pzz2jkk4srk2vb3j3ickiaga5jx9rkkhz732zq"))))
(build-system haskell-build-system)
+ (arguments
+ `(#:configure-flags
+ (let* ((sdl-image (assoc-ref %build-inputs "sdl-image"))
+ (sdl-image-include (string-append sdl-image "/include/SDL")))
+ (list (string-append "--extra-include-dirs=" sdl-image-include)))))
(propagated-inputs
- `(("ghc-polyparse" ,ghc-polyparse)
- ("ghc-old-locale" ,ghc-old-locale)
- ("ghc-old-time" ,ghc-old-time)))
- (home-page "http://projects.haskell.org/cpphs/")
- (synopsis "Liberalised re-implementation of cpp, the C pre-processor")
- (description "Cpphs is a re-implementation of the C pre-processor that is
-both more compatible with Haskell, and itself written in Haskell so that it
-can be distributed with compilers. This version of the C pre-processor is
-pretty-much feature-complete and compatible with traditional (K&R)
-pre-processors. Additional features include: a plain-text mode; an option to
-unlit literate code files; and an option to turn off macro-expansion.")
- (license (list lgpl2.1+ gpl3+))))
+ `(("ghc-sdl" ,ghc-sdl)))
+ (inputs
+ `(("sdl-image" ,sdl-image)))
+ (home-page "http://hackage.haskell.org/package/SDL-image")
+ (synopsis "Haskell bindings to libSDL_image")
+ (description "SDL_image is an image file loading library. It loads images
+as SDL surfaces, and supports the following formats: BMP, GIF, JPEG, LBM, PCX,
+PNG, PNM, TGA, TIFF, XCF, XPM, XV.")
+ (license bsd-3)))
-(define-public ghc-reflection
+(define-public ghc-half
(package
- (name "ghc-reflection")
- (version "2.1")
+ (name "ghc-half")
+ (version "0.2.2.1")
(source
(origin
(method url-fetch)
(uri (string-append
- "http://hackage.haskell.org/package/reflection/reflection-"
+ "http://hackage.haskell.org/package/half/half-"
version
".tar.gz"))
(sha256
(base32
- "10w3m6v3g6am203wbrikdbp57x9vw6b4jsh7bxdzsss4nmpm81zg"))))
+ "0zhwc6ps5w4ccnxl8sy623z4rjsafmnry69jpkw4hrbq11l402f1"))))
(build-system haskell-build-system)
- (inputs `(("ghc-tagged" ,ghc-tagged)))
- (home-page "http://github.com/ekmett/reflection")
- (synopsis "Reify arbitrary terms into types that can be reflected back
-into terms")
- (description "This package addresses the 'configuration problem' which is
-propogating configurations that are available at run-time, allowing multiple
-configurations to coexist without resorting to mutable global variables or
-@code{System.IO.Unsafe.unsafePerformIO}.")
+ (home-page "http://github.com/ekmett/half")
+ (synopsis "Half-precision floating-point computations")
+ (description "This library provides a half-precision floating-point
+computation library for Haskell.")
(license bsd-3)))
-(define-public ghc-old-locale
+(define-public ghc-openglraw
(package
- (name "ghc-old-locale")
- (version "1.0.0.7")
+ (name "ghc-openglraw")
+ (version "2.5.1.0")
(source
(origin
(method url-fetch)
(uri (string-append
- "http://hackage.haskell.org/package/old-locale/old-locale-"
+ "http://hackage.haskell.org/package/OpenGLRaw/OpenGLRaw-"
version
".tar.gz"))
(sha256
- (base32 "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv"))))
+ (base32
+ "1kfq24mxg922ml3kkmym2qfpc56jbmrfbiix4rc2cxlwv05i191k"))))
(build-system haskell-build-system)
- (home-page "http://hackage.haskell.org/package/old-locale")
- (synopsis "Adapt to locale conventions")
- (description
- "This package provides the ability to adapt to locale conventions such as
-date and time formats.")
+ (inputs
+ `(("ghc-half" ,ghc-half)
+ ("glu" ,glu)
+ ("ghc-text" ,ghc-text)))
+ (home-page "http://www.haskell.org/haskellwiki/Opengl")
+ (synopsis "Raw Haskell bindings for the OpenGL graphics system")
+ (description "OpenGLRaw is a raw Haskell binding for the OpenGL 4.5
+graphics system and lots of OpenGL extensions. It is basically a 1:1 mapping
+of OpenGL's C API, intended as a basis for a nicer interface. OpenGLRaw
+offers access to all necessary functions, tokens and types plus a general
+facility for loading extension entries. The module hierarchy closely mirrors
+the naming structure of the OpenGL extensions, making it easy to find the
+right module to import. All API entries are loaded dynamically, so no special
+C header files are needed for building this package. If an API entry is not
+found at runtime, a userError is thrown.")
(license bsd-3)))
-(define-public ghc-old-time
+(define-public ghc-glut
(package
- (name "ghc-old-time")
- (version "1.1.0.3")
+ (name "ghc-glut")
+ (version "2.7.0.3")
(source
(origin
(method url-fetch)
(uri (string-append
- "http://hackage.haskell.org/package/old-time/old-time-"
+ "http://hackage.haskell.org/package/GLUT/GLUT-"
version
".tar.gz"))
(sha256
(base32
- "1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw"))))
+ "1qfilpc10jm47anan44c20y8mh76f2dv09m5d22gk0f7am7hg4k2"))))
(build-system haskell-build-system)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-/bin/sh
- (lambda _
- (setenv "CONFIG_SHELL" "sh"))))))
(propagated-inputs
- `(("ghc-old-locale" ,ghc-old-locale)))
- (home-page "http://hackage.haskell.org/package/old-time")
- (synopsis "Time compatibility library for Haskell")
- (description "Old-time is a package for backwards compatibility with the
-old @code{time} library. For new projects, the newer
-@uref{http://hackage.haskell.org/package/time, time library} is recommended.")
+ `(("ghc-statevar" ,ghc-statevar)
+ ("ghc-openglraw" ,ghc-openglraw)
+ ("freeglut" ,freeglut)))
+ (inputs
+ `(("ghc-opengl" ,ghc-opengl)))
+ (home-page "http://www.haskell.org/haskellwiki/Opengl")
+ (synopsis "Haskell bindings for the OpenGL Utility Toolkit")
+ (description "This library provides Haskell bindings for the OpenGL
+Utility Toolkit, a window system-independent toolkit for writing OpenGL
+programs.")
(license bsd-3)))
-(define-public ghc-data-default-instances-old-locale
+(define-public ghc-gluraw
(package
- (name "ghc-data-default-instances-old-locale")
- (version "0.0.1")
+ (name "ghc-gluraw")
+ (version "1.5.0.2")
(source
- (origin
- (method url-fetch)
- (uri (string-append
- "http://hackage.haskell.org/package/"
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/GLURaw/GLURaw-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0gscd9lhp9mb10q8s716nx26m8qng9xbb4h6b3f48zzgkc1sy96x"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-openglraw" ,ghc-openglraw)))
+ (home-page "http://www.haskell.org/haskellwiki/Opengl")
+ (synopsis "Raw Haskell bindings GLU")
+ (description "GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL
+utility library. It is basically a 1:1 mapping of GLU's C API, intended as a
+basis for a nicer interface.")
+ (license bsd-3)))
+
+(define-public ghc-opengl
+ (package
+ (name "ghc-opengl")
+ (version "2.12.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/OpenGL/OpenGL-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1mcfb167jl75qc2hgylh83vf2jqizvyvkvhhb72adi2crc3zqz4b"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-text" ,ghc-text)
+ ("ghc-objectname" ,ghc-objectname)
+ ("ghc-gluraw" ,ghc-gluraw)
+ ("ghc-statevar" ,ghc-statevar)
+ ("ghc-openglraw" ,ghc-openglraw)))
+ (home-page "http://www.haskell.org/haskellwiki/Opengl")
+ (synopsis "Haskell bindings for the OpenGL graphics system")
+ (description "This package provides Haskell bindings for the OpenGL
+graphics system (GL, version 4.5) and its accompanying utility library (GLU,
+version 1.3).")
+ (license bsd-3)))
+
+(define-public ghc-streaming-commons
+ (package
+ (name "ghc-streaming-commons")
+ (version "0.1.14.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/streaming-commons/streaming-commons-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "12nw9bwvy6zrabkgvbp371klca3ds6qjlfncg1b8pbwx1y7m8c8h"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-random" ,ghc-random)))
+ (inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-async" ,ghc-async)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-stm" ,ghc-stm)
+ ("ghc-text" ,ghc-text)
+ ("ghc-network" ,ghc-network)
+ ("ghc-zlib" ,ghc-zlib)))
+ (home-page "https://hackage.haskell.org/package/streaming-commons")
+ (synopsis "Conduit and pipes needed by some streaming data libraries")
+ (description "Provides low-dependency functionality commonly needed by
+various Haskell streaming data libraries, such as @code{conduit} and
+@code{pipe}s.")
+ (license bsd-3)))
+
+(define-public cpphs
+ (package
+ (name "cpphs")
+ (version "1.19.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/" name "/"
+ name "-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1njpmxgpah5pcqppcl1cxb5xicf6xlqrd162qm12khp9hainlm72"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-polyparse" ,ghc-polyparse)
+ ("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-old-time" ,ghc-old-time)))
+ (home-page "http://projects.haskell.org/cpphs/")
+ (synopsis "Liberalised re-implementation of cpp, the C pre-processor")
+ (description "Cpphs is a re-implementation of the C pre-processor that is
+both more compatible with Haskell, and itself written in Haskell so that it
+can be distributed with compilers. This version of the C pre-processor is
+pretty-much feature-complete and compatible with traditional (K&R)
+pre-processors. Additional features include: a plain-text mode; an option to
+unlit literate code files; and an option to turn off macro-expansion.")
+ (license (list lgpl2.1+ gpl3+))))
+
+(define-public ghc-reflection
+ (package
+ (name "ghc-reflection")
+ (version "2.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/reflection/reflection-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "10w3m6v3g6am203wbrikdbp57x9vw6b4jsh7bxdzsss4nmpm81zg"))))
+ (build-system haskell-build-system)
+ (inputs `(("ghc-tagged" ,ghc-tagged)))
+ (home-page "http://github.com/ekmett/reflection")
+ (synopsis "Reify arbitrary terms into types that can be reflected back
+into terms")
+ (description "This package addresses the 'configuration problem' which is
+propogating configurations that are available at run-time, allowing multiple
+configurations to coexist without resorting to mutable global variables or
+@code{System.IO.Unsafe.unsafePerformIO}.")
+ (license bsd-3)))
+
+(define-public ghc-old-locale
+ (package
+ (name "ghc-old-locale")
+ (version "1.0.0.7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/old-locale/old-locale-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32 "0l3viphiszvz5wqzg7a45zp40grwlab941q5ay29iyw8p3v8pbyv"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/old-locale")
+ (synopsis "Adapt to locale conventions")
+ (description
+ "This package provides the ability to adapt to locale conventions such as
+date and time formats.")
+ (license bsd-3)))
+
+(define-public ghc-old-time
+ (package
+ (name "ghc-old-time")
+ (version "1.1.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/old-time/old-time-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1h9b26s3kfh2k0ih4383w90ibji6n0iwamxp6rfp2lbq1y5ibjqw"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-old-locale" ,ghc-old-locale)))
+ (home-page "http://hackage.haskell.org/package/old-time")
+ (synopsis "Time compatibility library for Haskell")
+ (description "Old-time is a package for backwards compatibility with the
+old @code{time} library. For new projects, the newer
+@uref{http://hackage.haskell.org/package/time, time library} is recommended.")
+ (license bsd-3)))
+
+(define-public ghc-data-default-instances-old-locale
+ (package
+ (name "ghc-data-default-instances-old-locale")
+ (version "0.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/"
"data-default-instances-old-locale/"
"data-default-instances-old-locale-" version ".tar.gz"))
(sha256
"X11-" version ".tar.gz"))
(sha256
(base32 "1kzjcynm3rr83ihqx2y2d852jc49da4p18gv6jzm7g87z22x85jj"))))
- (arguments
- `(#:phases (modify-phases %standard-phases
- (add-before 'configure 'set-sh
- (lambda _
- (setenv "CONFIG_SHELL" "sh")
- #t)))))
(build-system haskell-build-system)
(inputs
`(("libx11" ,libx11)
"This package provides various primitive memory-related operations.")
(license bsd-3)))
+(define-public ghc-test-framework
+ (package
+ (name "ghc-test-framework")
+ (version "0.8.1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/test-framework/"
+ "test-framework-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0wxjgdvb1c4ykazw774zlx86550848wbsvgjgcrdzcgbb9m650vq"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-libxml" ,ghc-libxml)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (propagated-inputs
+ `(("ghc-ansi-terminal" ,ghc-ansi-terminal)
+ ("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
+ ("ghc-hostname" ,ghc-hostname)
+ ("ghc-old-locale" ,ghc-old-locale)
+ ("ghc-random" ,ghc-random)
+ ("ghc-regex-posix" ,ghc-regex-posix)
+ ("ghc-xml" ,ghc-xml)))
+ (home-page "https://batterseapower.github.io/test-framework/")
+ (synopsis "Framework for running and organising tests")
+ (description
+ "This package allows tests such as QuickCheck properties and HUnit test
+cases to be assembled into test groups, run in parallel (but reported in
+deterministic order, to aid diff interpretation) and filtered and controlled
+by command line options. All of this comes with colored test output, progress
+reporting and test statistics output.")
+ (license bsd-3)))
+
+(define-public ghc-test-framework-hunit
+ (package
+ (name "ghc-test-framework-hunit")
+ (version "0.3.0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "test-framework-hunit/test-framework-hunit-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1h0h55kf6ff25nbfx1mhliwyknc0glwv3zi78wpzllbjbs7gvyfk"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)))
+ (home-page "https://batterseapower.github.io/test-framework/")
+ (synopsis "HUnit support for test-framework")
+ (description
+ "This package provides HUnit support for the test-framework package.")
+ (license bsd-3)))
+
+(define-public ghc-test-framework-quickcheck2
+ (package
+ (name "ghc-test-framework-quickcheck2")
+ (version "0.3.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "test-framework-quickcheck2/"
+ "test-framework-quickcheck2-" version ".tar.gz"))
+ (sha256
+ (base32
+ "12p1zwrsz35r3j5gzbvixz9z1h5643rhihf5gqznmc991krwd5nc"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; The Hackage page and the cabal file linked there for this package
+ ;; both list 2.9 as the upper version limit, but the source tarball
+ ;; specifies 2.8. Assume the Hackage page is correct.
+ '(substitute* "test-framework-quickcheck2.cabal"
+ (("QuickCheck >= 2.4 && < 2.8") "QuickCheck >= 2.4 && < 2.9")))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-extensible-exceptions" ,ghc-extensible-exceptions)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-random" ,ghc-random)
+ ("ghc-test-framework" ,ghc-test-framework)))
+ (home-page "https://batterseapower.github.io/test-framework/")
+ (synopsis "QuickCheck2 support for test-framework")
+ (description
+ "This packages provides QuickCheck2 support for the test-framework
+package.")
+ (license bsd-3)))
+
(define-public ghc-tf-random
(package
(name "ghc-tf-random")
"0dyvyxwaffb94bgri1wc4b9wqaasy32pyjn0lww3dqblxv8fn5ax"))))
(build-system haskell-build-system)
(arguments
- `(#:tests? #f ; FIXME: Test fails with "System.Time not found". This is
- ; weird, that should be provided by GHC 7.10.2.
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-/bin/sh
- (lambda _
- (setenv "CONFIG_SHELL" "sh"))))))
+ `(#:tests? #f)) ; FIXME: Test fails with "System.Time not found". This
+ ; is weird, that should be provided by GHC 7.10.2.
(propagated-inputs
`(("ghc-old-time" ,ghc-old-time)
("ghc-old-locale" ,ghc-old-locale)))
regex-posix, regex-pcre, regex-parsec, regex-tdfa, regex-dfa.")
(license bsd-3)))
+(define-public ghc-regex-posix
+ (package
+ (name "ghc-regex-posix")
+ (version "0.95.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/regex-posix/regex-posix-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0gkhzhj8nvfn1ija31c7xnl6p0gadwii9ihyp219ck2arlhrj0an"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-regex-base" ,ghc-regex-base)))
+ (home-page "http://sourceforge.net/projects/lazy-regex")
+ (synopsis "POSIX regular expressions for Haskell")
+ (description "This library provides the POSIX regex backend used by the
+Haskell library @code{regex-base}.")
+ (license bsd-3)))
+
+(define-public ghc-regex-compat
+ (package
+ (name "ghc-regex-compat")
+ (version "0.95.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://hackage.haskell.org/package/regex-compat/regex-compat-"
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "0fwmima3f04p9y4h3c23493n1xj629ia2dxaisqm6rynljjv2z6m"))))
+ (build-system haskell-build-system)
+ (inputs
+ `(("ghc-regex-base" ,ghc-regex-base)
+ ("ghc-regex-posix" ,ghc-regex-posix)))
+ (home-page "http://sourceforge.net/projects/lazy-regex")
+ (synopsis "Replaces/Enhances Text.Regex")
+ (description "This library provides one module layer over
+@code{regex-posix} to replace @code{Text.Regex}.")
+ (license bsd-3)))
+
(define-public ghc-regex-tdfa-rc
(package
(name "ghc-regex-tdfa-rc")
(base32
"0cprkr7bl4lrr80pz8mryb4rbfwdgpsrl7g0fbcaybhl8p5hm26f"))))
(build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: ghc-test-framework unavailable
(propagated-inputs
`(("ghc-scientific" ,ghc-scientific)))
(inputs
- `(("ghc-text" ,ghc-text)
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-unicode" ,ghc-quickcheck-unicode)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-text" ,ghc-text)
("ghc-vector" ,ghc-vector)))
(home-page "https://github.com/bos/attoparsec")
(synopsis "Fast combinator parsing for bytestrings and text")
encourages inductive, recursive definitions of graph algorithms.")
(license bsd-3)))
-(define-public ghc-unordered-containers
+(define-public ghc-chasingbottoms
(package
- (name "ghc-unordered-containers")
- (version "0.2.5.1")
- (outputs '("out" "doc"))
+ (name "ghc-chasingbottoms")
+ (version "1.3.0.13")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/ChasingBottoms/"
+ "ChasingBottoms-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1fb86jd6cdz4rx3fj3r9n8d60kx824ywwy7dw4qnrdran46ja3pl"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; The Hackage page and the cabal file linked there for this package
+ ;; both list 0.7 as the upper version limit, but the source tarball
+ ;; specifies 0.6. Assume the Hackage page is correct.
+ '(substitute* "ChasingBottoms.cabal"
+ (("syb >= 0.1.0.2 && < 0.6") "syb >= 0.1.0.2 && < 0.7")))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-random" ,ghc-random)
+ ("ghc-syb" ,ghc-syb)))
+ (home-page "http://hackage.haskell.org/package/ChasingBottoms")
+ (synopsis "Testing of partial and infinite values in Haskell")
+ (description
+ ;; FIXME: There should be a @comma{} in the uref text, but it is not
+ ;; rendered properly.
+ "This is a library for testing code involving bottoms or infinite values.
+For the underlying theory and a larger example involving use of QuickCheck,
+see the article
+@uref{http://www.cse.chalmers.se/~nad/publications/danielsson-jansson-mpc2004.html,
+\"Chasing Bottoms A Case Study in Program Verification in the Presence of
+Partial and Infinite Values\"}.")
+ (license expat)))
+
+(define-public ghc-unordered-containers
+ (package
+ (name "ghc-unordered-containers")
+ (version "0.2.5.1")
+ (outputs '("out" "doc"))
(source
(origin
(method url-fetch)
"06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f"))))
(build-system haskell-build-system)
(inputs
- `(("ghc-hunit" ,ghc-hunit)
- ("ghc-quickcheck" ,ghc-quickcheck)))
+ `(("ghc-chasingbottoms" ,ghc-chasingbottoms)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
;; these inputs are necessary to use this library
(propagated-inputs `(("ghc-hashable" ,ghc-hashable)))
- (arguments
- `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
(home-page
"https://github.com/tibbe/unordered-containers")
(synopsis
(inputs
`(("ghc-hunit" ,ghc-hunit)))
(arguments
- `(#:tests? #f ; FIXME: currently missing libraries used for tests.
- #:phases
- (modify-phases %standard-phases
- (add-before 'configure 'set-sh
- (lambda _ (setenv "CONFIG_SHELL" "sh"))))))
+ `(#:tests? #f)) ; FIXME: currently missing libraries used for tests.
(home-page "https://github.com/haskell/network")
(synopsis "Low-level networking interface")
(description
Haskell, inspired by the Ruby library RSpec.")
(license expat)))
+(define-public ghc-hspec-contrib
+ (package
+ (name "ghc-hspec-contrib")
+ (version "0.3.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "hspec-contrib/hspec-contrib-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "006syw8xagfhsx06ws9ywig1qx5lk4cgl7sq6pbid1s64c72mxn4"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-hspec-core" ,ghc-hspec-core)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "http://hspec.github.io/")
+ (synopsis "Contributed functionality for Hspec")
+ (description
+ "This package provides contributed Hspec extensions.")
+ (license expat)))
+
(define-public ghc-hspec-expectations
(package
(name "ghc-hspec-expectations")
(base32
"0azx4qk65a9a2gvqsfmz3w89m6shzr2iz0i5lly2zvly4n2d6m6v"))))
(build-system haskell-build-system)
- (arguments `(#:tests? #f)) ; FIXME: testing libraries are missing.
+ (inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
(propagated-inputs
`(("ghc-stm" ,ghc-stm)))
(home-page "https://github.com/simonmar/async")
(synopsis "Library to run IO operations asynchronously")
(description "Async provides a library to run IO operations
-asynchronously, and wait for their results. It is a higher-level interface
+asynchronously, and wait for their results. It is a higher-level interface
over threads in Haskell, in which @code{Async a} is a concurrent thread that
will eventually deliver a value of type @code{a}.")
(license bsd-3)))
("ghc-mtl" ,ghc-mtl)
("ghc-scientific" ,ghc-scientific)
("ghc-syb" ,ghc-syb)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-vector" ,ghc-vector)))
(inputs
`(("ghc-hashable" ,ghc-hashable)
("ghc-text" ,ghc-text)
- ("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://github.com/bos/aeson")
functionality.")
(license expat)))
+(define-public ghc-deepseq-generics
+ (package
+ (name "ghc-deepseq-generics")
+ (version "0.1.1.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "deepseq-generics/deepseq-generics-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "01pvigx8n9p8hwbzp2qiq6kzf7cxiam843jz2sjgliacmmp1v7l3"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'relax-ghc-prim-dependency
+ (lambda _
+ (substitute* "deepseq-generics.cabal"
+ (("< 0.4") "< 0.5"))
+ #t)))))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)))
+ (home-page "https://github.com/hvr/deepseq-generics")
+ (synopsis "Generic RNF implementation")
+ (description
+ "This package provides a @code{GHC.Generics}-based
+@code{Control.DeepSeq.Generics.genericRnf} function which can be used for
+providing an 'rnf' implementation.")
+ (license bsd-3)))
+
+(define-public ghc-pandoc-types
+ (package
+ (name "ghc-pandoc-types")
+ (version "1.12.4.7")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "pandoc-types/pandoc-types-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "108n11kbdaj2ii3cyf0xczhsx90p1gjbxwqp1f0wyn2m3cls632n"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-syb" ,ghc-syb)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-deepseq-generics" ,ghc-deepseq-generics)))
+ (home-page "http://johnmacfarlane.net/pandoc")
+ (synopsis "Types for representing a structured document")
+ (description
+ "This module defines the @code{Pandoc} data structure, which is used by
+pandoc to represent structured documents. It also provides functions for
+building up, manipulating and serialising @code{Pandoc} structures.")
+ (license bsd-3)))
+
+(define-public ghc-texmath
+ (package
+ (name "ghc-texmath")
+ (version "0.8.4")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "texmath/texmath-" version ".tar.gz"))
+ (sha256
+ (base32
+ "15821jg64fbr4rwaglp5ksah6q8qqz1vkjxlqp6d3bbb1rj8v2ri"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-syb" ,ghc-syb)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-split" ,ghc-split)
+ ("ghc-temporary" ,ghc-temporary)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-xml" ,ghc-xml)
+ ("ghc-parsec" ,ghc-parsec)
+ ("ghc-mtl" ,ghc-mtl)
+ ("ghc-pandoc-types" ,ghc-pandoc-types)))
+ (home-page "http://github.com/jgm/texmath")
+ (synopsis "Conversion between formats used to represent mathematics")
+ (description
+ "The texmath library provides functions to read and write TeX math,
+presentation MathML, and OMML (Office Math Markup Language, used in Microsoft
+Office). Support is also included for converting math formats to pandoc's
+native format (allowing conversion, via pandoc, to a variety of different
+markup formats). The TeX reader supports basic LaTeX and AMS extensions, and
+it can parse and apply LaTeX macros.")
+ (license gpl2+)))
+
+(define-public ghc-regex-pcre-builtin
+ (package
+ (name "ghc-regex-pcre-builtin")
+ (version "0.94.4.8.8.35")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "regex-pcre-builtin/regex-pcre-builtin-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0y7as9wqlkykpipka2cfdhmcnin345q01pp0wsva8fwmvsavdl8b"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-regex-base" ,ghc-regex-base)))
+ (home-page "http://hackage.haskell.org/package/regex-pcre")
+ (synopsis "Enhancement of the builtin Text.Regex library")
+ (description
+ "This package is an enhancement of the @code{Text.Regex} library,
+providing the PCRE backend to accompany regex-base, with bundled code from
+@url{http://www.pcre.org}.")
+ (license bsd-3)))
+
+(define-public ghc-diff
+ (package
+ (name "ghc-diff")
+ (version "0.3.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "Diff/Diff-" version ".tar.gz"))
+ (sha256
+ (base32
+ "13iqqmpadcm7fvqwbfrz94w030rvjh66w2bdls1253128ac2n0vz"))))
+ (build-system haskell-build-system)
+ (home-page "http://hub.darcs.net/sterlingclover/Diff")
+ (synopsis "O(ND) diff algorithm in Haskell")
+ (description
+ "This package provides an implementation of the standard diff algorithm,
+and utilities for pretty printing.")
+ (license bsd-3)))
+
+(define-public ghc-highlighting-kate
+ (package
+ (name "ghc-highlighting-kate")
+ (version "0.6")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "highlighting-kate/highlighting-kate-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "16334fbiyq6017zbgc59qc00h0bk24xh4dcrbqx63dvf72ac37dk"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-diff" ,ghc-diff)
+ ("ghc-regex-pcre-builtin" ,ghc-regex-pcre-builtin)))
+ (native-inputs
+ `(("ghc-parsec" ,ghc-parsec)
+ ("ghc-blaze-html" ,ghc-blaze-html)
+ ("ghc-utf8-string" ,ghc-utf8-string)
+ ("ghc-mtl" ,ghc-mtl)))
+ (home-page "http://github.com/jgm/highlighting-kate")
+ (synopsis "Syntax highlighting library")
+ (description
+ "Highlighting-kate is a syntax highlighting library with support for
+nearly one hundred languages. The syntax parsers are automatically generated
+from @uref{http://kate-editor.org/, Kate syntax descriptions}, so any syntax
+supported by Kate can be added. An (optional) command-line program is
+provided, along with a utility for generating new parsers from Kate XML syntax
+descriptions.")
+ (license gpl2+)))
+
+(define-public ghc-cmark
+ (package
+ (name "ghc-cmark")
+ (version "0.4.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "cmark/cmark-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0c134qh65viaq4q6pv7bnnr5wchzivg94nv0dj8pc1326sx0dw12"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-text" ,ghc-text)))
+ (native-inputs
+ `(("ghc-hunit" ,ghc-hunit)))
+ (home-page "https://github.com/jgm/commonmark-hs")
+ (synopsis "Fast, accurate CommonMark (Markdown) parser and renderer")
+ (description
+ "This package provides Haskell bindings for
+@uref{https://github.com/jgm/cmark, libcmark}, the reference parser for
+CommonMark, a fully specified variant of Markdown. It includes sources for
+libcmark (0.21.0) and does not require prior installation of the C library.")
+ (license bsd-3)))
+
+(define-public ghc-executable-path
+ (package
+ (name "ghc-executable-path")
+ (version "0.0.3")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "executable-path/executable-path-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1jg58qf19qz93c60ryglcavwdcysz4fd4qn8kpw5im9w9kniawlc"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/executable-path")
+ (synopsis "Find out the full path of the executable")
+ (description
+ "The documentation of @code{System.Environment.getProgName} says that
+\"However, this is hard-to-impossible to implement on some non-Unix OSes, so
+instead, for maximum portability, we just return the leafname of the program
+as invoked.\" This library tries to provide the missing path.")
+ (license public-domain)))
+
+(define-public ghc-enclosed-exceptions
+ (package
+ (name "ghc-enclosed-exceptions")
+ (version "1.0.1.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "enclosed-exceptions/enclosed-exceptions-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "16ax1kqdsk4apg642qxkm2hf9vb5hzmkd14zmkxra8ssp8rn28z5"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-async" ,ghc-async)
+ ("ghc-transformers-base" ,ghc-transformers-base)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "https://github.com/jcristovao/enclosed-exceptions")
+ (synopsis "Catch all exceptions from within an enclosed computation")
+ (description
+ "This library implements a technique to catch all exceptions raised
+within an enclosed computation, while remaining responsive to (external)
+asynchronous exceptions.")
+ (license expat)))
+
+(define-public ghc-packedstring
+ (package
+ (name "ghc-packedstring")
+ (version "0.1.0.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "packedstring/packedstring-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1x78pzzdlnpcmh9p37rlf8m5cxf3yqm2alf3whl4zpr9w25r0qj8"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'enable-extension
+ (lambda _
+ ;; This package won't compile without the StandaloneDeriving
+ ;; extension.
+ (substitute* "packedstring.cabal"
+ (("CPP") "CPP, StandaloneDeriving"))
+ #t)))))
+ (home-page "http://hackage.haskell.org/package/packedstring")
+ (synopsis "Library for packed strings")
+ (description
+ "This deprecated library provides an implementation of packed strings.")
+ (license bsd-3)))
+
+(define-public ghc-th-lift
+ (package
+ (name "ghc-th-lift")
+ (version "0.7.5")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "th-lift/th-lift-" version ".tar.gz"))
+ (sha256
+ (base32
+ "13xdkk1chdghf059sfx8d3d8r0mj1dbzdi5kf2zf0mjmz3qq7m7k"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-packedstring" ,ghc-packedstring)))
+ (home-page "http://github.com/mboes/th-lift")
+ (synopsis "Derive Template Haskell's Lift class for datatypes")
+ (description
+ "This is a Haskell library to derive Template Haskell's Lift class for
+datatypes.")
+ (license bsd-3)))
+
+(define-public ghc-th-expand-syns
+ (package
+ (name "ghc-th-expand-syns")
+ (version "0.3.0.6")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "th-expand-syns/th-expand-syns-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "03qv93pyqk8all39knsf0mzmbfdck5x61kqnyn8rbisw5c1ymx6j"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-syb" ,ghc-syb)))
+ (home-page "http://hackage.haskell.org/package/th-expand-syns")
+ (synopsis "Expands type synonyms in Template Haskell ASTs")
+ (description
+ "This package enables users to expand type synonyms in Template Haskell
+@dfn{abstract syntax trees} (ASTs).")
+ (license bsd-3)))
+
+(define-public ghc-th-reify-many
+ (package
+ (name "ghc-th-reify-many")
+ (version "0.1.3")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "th-reify-many/th-reify-many-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "00hryljcs434wcv1vaamfdbjk857f46djxv7mlwplkl3zsmfhlfx"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-safe" ,ghc-safe)
+ ("ghc-th-expand-syns" ,ghc-th-expand-syns)))
+ (home-page "http://github.com/mgsloan/th-reify-many")
+ (synopsis "Recurseively reify template haskell datatype info")
+ (description
+ "th-reify-many provides functions for recursively reifying top level
+declarations. The main intended use case is for enumerating the names of
+datatypes reachable from an initial datatype, and passing these names to some
+function which generates instances.")
+ (license bsd-3)))
+
+(define-public ghc-th-orphans
+ (package
+ (name "ghc-th-orphans")
+ (version "0.13.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "th-orphans/th-orphans-" version ".tar.gz"))
+ (sha256
+ (base32
+ "105y03bxh0a2r69l603i7md17gg1vxs1jj1n40pn5q486lmfxbmx"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-th-lift" ,ghc-th-lift)
+ ("ghc-th-reify-many" ,ghc-th-reify-many)
+ ("ghc-mtl" ,ghc-mtl)
+ ("ghc-generic-deriving" ,ghc-generic-deriving)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "http://hackage.haskell.org/package/th-orphans")
+ (synopsis "Orphan instances for TH datatypes")
+ (description
+ "This package provides orphan instances for Template Haskell datatypes. In particular,
+instances for @code{Ord} and @code{Lift}, as well as a few missing @code{Show}
+and @code{Eq} instances. These instances used to live in the haskell-src-meta
+package, and that's where the version number started.")
+ (license bsd-3)))
+
+(define-public ghc-haskell-src-meta
+ (package
+ (name "ghc-haskell-src-meta")
+ (version "0.6.0.12")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "haskell-src-meta/haskell-src-meta-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1mzbfrfvl6pj8068w3m6alzry1403ir1gmz3czg66n5z198l4dql"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-haskell-src-exts" ,ghc-haskell-src-exts)
+ ("ghc-syb" ,ghc-syb)
+ ("ghc-th-orphans" ,ghc-th-orphans)))
+ (home-page "http://hackage.haskell.org/package/haskell-src-meta")
+ (synopsis "Parse source to template-haskell abstract syntax")
+ (description
+ "This package provides tools to parse Haskell sources to the
+template-haskell abstract syntax.")
+ (license bsd-3)))
+
+(define-public ghc-aeson-qq
+ (package
+ (name "ghc-aeson-qq")
+ (version "0.8.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "aeson-qq/aeson-qq-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1z8kh3qjc4khadz1ijdqm7fbk7dh17sisqhpwd3c9aibj2927k9d"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-base-compat" ,ghc-base-compat)
+ ("ghc-text" ,ghc-text)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-parsec" ,ghc-parsec)
+ ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "http://github.com/zalora/aeson-qq")
+ (synopsis "JSON quasiquoter for Haskell")
+ (description
+ "aeson-qq provides a JSON quasiquoter for Haskell. This package exposes
+the function @code{aesonQQ} that compile-time converts a string representation
+of a JSON value into a @code{Data.Aeson.Value}.")
+ (license expat)))
+
+(define-public ghc-conduit
+ (package
+ (name "ghc-conduit")
+ (version "1.2.5.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "conduit/conduit-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0aq6wswd5dkhdmy7sjhd99mldpq33dqpgbdcwpm94ahvckqxs7v5"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-lifted-base" ,ghc-lifted-base)
+ ("ghc-mmorph" ,ghc-mmorph)
+ ("ghc-mtl" ,ghc-mtl)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-transformers-base" ,ghc-transformers-base)
+ ("ghc-void" ,ghc-void)))
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-hspec" ,ghc-hspec)
+ ("ghc-safe" ,ghc-safe)))
+ (home-page "https://github.com/snoyberg/conduit")
+ (synopsis "Streaming data library ")
+ (description
+ "conduit is a solution to the streaming data problem, allowing for
+production, transformation, and consumption of streams of data in constant
+memory. It is an alternative to lazy I/O which guarantees deterministic
+resource handling, and fits in the same general solution space as
+enumerator/iteratee and pipes." )
+ (license expat)))
+
+(define-public ghc-logging-facade
+ (package
+ (name "ghc-logging-facade")
+ (version "0.1.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "logging-facade/logging-facade-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0zhdbjyj0j9by19rma9alxysrxnnl3s4kks4zk4bx0dg5xa0264y"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "http://hackage.haskell.org/package/logging-facade")
+ (synopsis "Simple logging abstraction that allows multiple back-ends")
+ (description
+ "This package provides a simple logging abstraction that allows multiple
+back-ends.")
+ (license expat)))
+
+(define-public ghc-mockery
+ (package
+ (name "ghc-mockery")
+ (version "0.3.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "mockery/mockery-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0m0lp2z63sgkylz5318j53r5hnrkp705qh7nqbb149ir4gy7g1bg"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-temporary" ,ghc-temporary)
+ ("ghc-logging-facade" ,ghc-logging-facade)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "http://hackage.haskell.org/package/mockery")
+ (synopsis "Support functions for automated testing")
+ (description
+ "The mockery package provides support functions for automated testing.")
+ (license expat)))
+
+(define-public ghc-yaml
+ (package
+ (name "ghc-yaml")
+ (version "0.8.15.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "yaml/yaml-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0v6c435xmgm99zxb30pqr7lhkb2a56wxqp70g4hjz8p7rj0vichx"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-conduit" ,ghc-conduit)
+ ("ghc-resourcet" ,ghc-resourcet)
+ ("ghc-aeson" ,ghc-aeson)
+ ("ghc-unordered-containers" ,ghc-unordered-containers)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-text" ,ghc-text)
+ ("ghc-attoparsec" ,ghc-attoparsec)
+ ("ghc-scientific" ,ghc-scientific)
+ ("ghc-enclosed-exceptions" ,ghc-enclosed-exceptions)
+ ("ghc-aeson-qq" ,ghc-aeson-qq)
+ ("ghc-base-compat" ,ghc-base-compat)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-mockery" ,ghc-mockery)))
+ (home-page "http://github.com/snoyberg/yaml/")
+ (synopsis "Parsing and rendering YAML documents")
+ (description
+ "This package provides a library to parse and render YAML documents.")
+ (license bsd-3)))
+
+(define-public ghc-filemanip
+ (package
+ (name "ghc-filemanip")
+ (version "0.3.6.3")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "filemanip/filemanip-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0ilqr8jv41zxcj5qyicg29m8s30b9v70x6f9h2h2rw5ap8bxldl8"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-unix-compat" ,ghc-unix-compat)))
+ (home-page "https://github.com/bos/filemanip")
+ (synopsis "File and directory manipulation for Haskell")
+ (description
+ "This package provides a Haskell library for working with files and
+directories. It includes code for pattern matching, finding files, modifying
+file contents, and more.")
+ (license bsd-3)))
+
+(define-public ghc-mmap
+ (package
+ (name "ghc-mmap")
+ (version "0.5.9")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "mmap/mmap-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1y5mk3yf4b8r6rzmlx1xqn4skaigrqnv08sqq0v7r3nbw42bpz2q"))))
+ (build-system haskell-build-system)
+ (home-page "http://hackage.haskell.org/package/mmap")
+ (synopsis "Memory mapped files for Haskell")
+ (description
+ "This library provides a wrapper to @code{mmap}, allowing files or
+devices to be lazily loaded into memory as strict or lazy @code{ByteStrings},
+@code{ForeignPtrs} or plain @code{Ptrs}, using the virtual memory subsystem to
+do on-demand loading.")
+ (license bsd-3)))
+
+(define-public ghc-juicypixels
+ (package
+ (name "ghc-juicypixels")
+ (version "3.2.6.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "JuicyPixels/JuicyPixels-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0hxa57cdknz86zywpjwfbdhac5lmk7j0wd5hy4mcnb8mw6r2m592"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-zlib" ,ghc-zlib)
+ ("ghc-vector" ,ghc-vector)
+ ("ghc-primitive" ,ghc-primitive)
+ ("ghc-mmap" ,ghc-mmap)))
+ (home-page "https://github.com/Twinside/Juicy.Pixels")
+ (synopsis "Picture loading and serialization library")
+ (description
+ "This library can load and store images in PNG, Bitmap, JPEG, Radiance,
+TIFF and GIF formats.")
+ (license bsd-3)))
+
+(define-public ghc-sha
+ (package
+ (name "ghc-sha")
+ (version "1.6.4.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "SHA/SHA-" version ".tar.gz"))
+ (sha256
+ (base32
+ "134ajm87fm4lpsw86m9q8apv20dw4bpk46raa389zr6bcdpifw64"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
+ (home-page "http://hackage.haskell.org/package/SHA")
+ (synopsis "SHA suite of message digest functions")
+ (description
+ "This library implements the SHA suite of message digest functions,
+according to NIST FIPS 180-2 (with the SHA-224 addendum), as well as the
+SHA-based HMAC routines. The functions have been tested against most of the
+NIST and RFC test vectors for the various functions. While some attention has
+been paid to performance, these do not presently reach the speed of well-tuned
+libraries, like OpenSSL.")
+ (license bsd-3)))
+
+(define-public ghc-hslua
+ (package
+ (name "ghc-hslua")
+ (version "0.4.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "hslua/hslua-" version ".tar.gz"))
+ (sha256
+ (base32
+ "0gqp6qhp4v24kzv2j49kgk7bxqzw0w10x0zr0r2j9wkfavqb9wid"))))
+ (build-system haskell-build-system)
+ (arguments
+ `(#:configure-flags '("-fsystem-lua")))
+ (inputs
+ `(("lua" ,lua-5.1)))
+ (propagated-inputs
+ `(("ghc-text" ,ghc-text)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)
+ ("ghc-hspec-contrib" ,ghc-hspec-contrib)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)
+ ("ghc-quickcheck-instances" ,ghc-quickcheck-instances)))
+ (home-page "http://hackage.haskell.org/package/hslua")
+ (synopsis "Lua language interpreter embedding in Haskell")
+ (description
+ "The Scripting.Lua module is a wrapper of the Lua language interpreter as
+described in @url{http://www.lua.org/}.")
+ (license expat)))
+
+(define-public ghc-mime-types
+ (package
+ (name "ghc-mime-types")
+ (version "0.1.0.6")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "mime-types/mime-types-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "090z3dp928243amnc6s8g10rk2h2bprk9y138q6wj3cpflzr72pw"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-text" ,ghc-text)))
+ (home-page "https://github.com/yesodweb/wai")
+ (synopsis "Basic MIME type handling types and functions")
+ (description
+ "This library provides basic MIME type handling types and functions.")
+ (license expat)))
+
+(define-public ghc-http-client
+ (package
+ (name "ghc-http-client")
+ (version "0.4.24")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "http-client/http-client-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0xz133kdfiyy2rm6z95bmvjj6y2540xzd86cfmdv9s6kz4p1ir4k"))))
+ (build-system haskell-build-system)
+ ;; Tests require access to the web.
+ (arguments `(#:tests? #f))
+ (propagated-inputs
+ `(("ghc-text" ,ghc-text)
+ ("ghc-http-types" ,ghc-http-types)
+ ("ghc-blaze-builder" ,ghc-blaze-builder)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-network" ,ghc-network)
+ ("ghc-streaming-commons" ,ghc-streaming-commons)
+ ("ghc-case-insensitive" ,ghc-case-insensitive)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)
+ ("ghc-cookie" ,ghc-cookie)
+ ("ghc-exceptions" ,ghc-exceptions)
+ ("ghc-random" ,ghc-random)
+ ("ghc-mime-types" ,ghc-mime-types)
+ ("ghc-network-uri" ,ghc-network-uri)
+ ("ghc-monad-control" ,ghc-monad-control)
+ ("ghc-zlib" ,ghc-zlib)
+ ("ghc-async" ,ghc-async)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://github.com/snoyberg/http-client")
+ (synopsis "HTTP client engine")
+ (description
+ "This package provides an HTTP client engine, intended as a base layer
+for more user-friendly packages.")
+ (license expat)))
+
+(define-public ghc-byteable
+ (package
+ (name "ghc-byteable")
+ (version "0.1.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "byteable/byteable-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1qizg0kxxjqnd3cbrjhhidk5pbbciz0pb3z5kzikjjxnnnhk8fr4"))))
+ (build-system haskell-build-system)
+ (home-page "http://github.com/vincenthz/hs-byteable")
+ (synopsis "Type class for sequence of bytes")
+ (description
+ "This package provides an abstract class to manipulate sequence of bytes.
+The use case of this class is abstracting manipulation of types that are just
+wrapping a bytestring with stronger and more meaniful name.")
+ (license bsd-3)))
+
+(define-public ghc-hourglass
+ (package
+ (name "ghc-hourglass")
+ (version "0.2.9")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "hourglass/hourglass-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1xha17nwzxdjizbcp63d2142c6q051y77facs7xribgcl5iz2m4v"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-old-locale" ,ghc-old-locale)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/vincenthz/hs-hourglass")
+ (synopsis "Simple time-related library for Haskell")
+ (description
+ "This is a simple time library providing a simple but powerful and
+performant API. The backbone of the library are the @code{Timeable} and
+@code{Time} type classes. Each @code{Timeable} instances can be converted to
+a type that has a @code{Time} instances, and thus are different
+representations of current time.")
+ (license bsd-3)))
+
+(define-public ghc-pem
+ (package
+ (name "ghc-pem")
+ (version "0.2.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "pem/pem-" version ".tar.gz"))
+ (sha256
+ (base32
+ "162sk5sg22w21wqz5qv8kx6ibxp99v5p20g3nknhm1kddk3hha1p"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-base64-bytestring" ,ghc-base64-bytestring)))
+ (native-inputs
+ `(("ghc-test-framework" ,ghc-test-framework)
+ ("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)
+ ("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
+ ("ghc-hunit" ,ghc-hunit)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "http://github.com/vincenthz/hs-pem")
+ (synopsis "Privacy Enhanced Mail (PEM) format reader and writer")
+ (description
+ "This library provides readers and writers for the @dfn{Privacy Enhanced
+Mail} (PEM) format.")
+ (license bsd-3)))
+
+(define-public ghc-asn1-types
+ (package
+ (name "ghc-asn1-types")
+ (version "0.3.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "asn1-types/asn1-types-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1iif9yrh4mmj249gyvam0zb2vb3jnlz777gahh2z9sx00dsx9rja"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-memory" ,ghc-memory)
+ ("ghc-hourglass" ,ghc-hourglass)))
+ (home-page "http://github.com/vincenthz/hs-asn1-types")
+ (synopsis "ASN.1 types for Haskell")
+ (description
+ "The package provides the standard types for dealing with the ASN.1
+format.")
+ (license bsd-3)))
+
+(define-public ghc-asn1-encoding
+ (package
+ (name "ghc-asn1-encoding")
+ (version "0.9.3")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "asn1-encoding/asn1-encoding-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "01ki5msrpccgdbdiaaa5a9zw0icp1hki4hca8qx6hzlp0rcf1mwh"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-hourglass" ,ghc-hourglass)
+ ("ghc-asn1-types" ,ghc-asn1-types)
+ ("ghc-text" ,ghc-text)
+ ("ghc-mtl" ,ghc-mtl)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "http://github.com/vincenthz/hs-asn1")
+ (synopsis "ASN1 data reader and writer in RAW, BER and DER forms")
+ (description
+ "This package provides a reader and writer for ASN1 data in raw form with
+supports for high level forms of ASN1 (BER, and DER).")
+ (license bsd-3)))
+
+(define-public ghc-asn1-parse
+ (package
+ (name "ghc-asn1-parse")
+ (version "0.9.4")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "asn1-parse/asn1-parse-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "025prsihk5g6rdv9xlfmj0zpa0wa3qjzj5i4ilzvg7f6f3sji8y6"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-asn1-types" ,ghc-asn1-types)
+ ("ghc-asn1-encoding" ,ghc-asn1-encoding)))
+ (home-page "https://github.com/vincenthz/hs-asn1")
+ (synopsis "Simple monadic parser for ASN1 stream types")
+ (description
+ "This package provides a simple monadic parser for ASN1 stream types,
+when ASN1 pattern matching is not convenient.")
+ (license bsd-3)))
+
+(define-public ghc-tasty-kat
+ (package
+ (name "ghc-tasty-kat")
+ (version "0.0.3")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "tasty-kat/tasty-kat-" version ".tar.gz"))
+ (sha256
+ (base32
+ "14yvlpli6cv6bn3kh8mlfp4x1l6ns4fvmfv6hmj75cvxyzq029d7"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-mtl" ,ghc-mtl)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/vincenthz/tasty-kat")
+ (synopsis "Known Answer Tests (KAT) framework for tasty")
+ (description
+ "This package provides a @dfn{Known Answer Tests} (KAT) framework for
+tasty.")
+ (license expat)))
+
+(define-public ghc-cryptonite
+ (package
+ (name "ghc-cryptonite")
+ (version "0.9")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "cryptonite/cryptonite-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1h22x22lq2m8h456v5j50xm0l25bcm3h1pchsk83br909hjxql4z"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-memory" ,ghc-memory)
+ ("ghc-byteable" ,ghc-byteable)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)
+ ("ghc-tasty-kat" ,ghc-tasty-kat)))
+ (home-page "https://github.com/haskell-crypto/cryptonite")
+ (synopsis "Cryptography primitives")
+ (description
+ "This package is a repository of cryptographic primitives for Haskell.
+It strives to be a cryptographic kitchen sink that provides cryptography for
+everyone.
+
+Supported symmetric ciphers: AES, DES, 3DES, Blowfish, Camellia, RC4, Salsa,
+ChaCha; supported hash functions: SHA1, SHA2, SHA3, MD2, MD4, MD5, Keccak,
+Skein, Ripemd, Tiger, Whirlpool, Blake2; MAC: HMAC, Poly1305; assymmetric
+crypto: DSA, RSA, DH, ECDH, ECDSA, ECC, Curve25519, Ed25519; key derivation
+functions: PBKDF2, Scrypt; cryptographic random number generation: system
+entropy, deterministic random generator; data-related features:
+@dfn{anti-forensic information splitter} (AFIS).")
+ (license bsd-3)))
+
+(define-public ghc-memory
+ (package
+ (name "ghc-memory")
+ (version "0.10")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "memory/memory-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1xqs9zmjbjihb7gfbk25f2q00m2lsi4kc3jv672175ac8a36pgag"))))
+ (build-system haskell-build-system)
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-tasty-hunit" ,ghc-tasty-hunit)))
+ (home-page "https://github.com/vincenthz/hs-memory")
+ (synopsis "Memory abstractions for Haskell")
+ (description
+ "This package provides memory abstractions, such as chunk of memory,
+polymorphic byte array management and manipulation functions. It contains a
+polymorphic byte array abstraction and functions similar to strict ByteString,
+different type of byte array abstraction, raw memory IO operations (memory
+set, memory copy, ..) and more")
+ (license bsd-3)))
+
+(define-public ghc-x509
+ (package
+ (name "ghc-x509")
+ (version "1.6.3")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "x509/x509-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1pmsby29abn485fvnymsgipvb3p1ch9c591xj5ncszkf0ivjiiin"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-memory" ,ghc-memory)
+ ("ghc-mtl" ,ghc-mtl)
+ ("ghc-hourglass" ,ghc-hourglass)
+ ("ghc-pem" ,ghc-pem)
+ ("ghc-asn1-types" ,ghc-asn1-types)
+ ("ghc-asn1-encoding" ,ghc-asn1-encoding)
+ ("ghc-asn1-parse" ,ghc-asn1-parse)
+ ("ghc-cryptonite" ,ghc-cryptonite)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
+ (home-page "http://github.com/vincenthz/hs-certificate")
+ (synopsis "X509 reader and writer")
+ (description
+ "This library provides functions to read and write X509 certificates.")
+ (license bsd-3)))
+
+(define-public ghc-x509-store
+ (package
+ (name "ghc-x509-store")
+ (version "1.6.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "x509-store/x509-store-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "01abx528i9f7djq2772xyna8x2mykrnwqkcfrapcx7z3bhprvml3"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-pem" ,ghc-pem)
+ ("ghc-asn1-types" ,ghc-asn1-types)
+ ("ghc-asn1-encoding" ,ghc-asn1-encoding)
+ ("ghc-cryptonite" ,ghc-cryptonite)
+ ("ghc-x509" ,ghc-x509)))
+ (home-page "http://github.com/vincenthz/hs-certificate")
+ (synopsis "X.509 collection accessing and storing methods")
+ (description
+ "This package provides functions for accessing and storing X.509
+collections, certificates, revocation lists, and exception lists.")
+ (license bsd-3)))
+
+(define-public ghc-x509-validation
+ (package
+ (name "ghc-x509-validation")
+ (version "1.6.3")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "x509-validation/x509-validation-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "1qr1v561hdlhjgqjv9pj9mbk0q1xf2mr1j67ghy93nlxxyzd7dw0"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-memory" ,ghc-memory)
+ ("ghc-byteable" ,ghc-byteable)
+ ("ghc-mtl" ,ghc-mtl)
+ ("ghc-hourglass" ,ghc-hourglass)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-pem" ,ghc-pem)
+ ("ghc-asn1-types" ,ghc-asn1-types)
+ ("ghc-asn1-encoding" ,ghc-asn1-encoding)
+ ("ghc-x509" ,ghc-x509)
+ ("ghc-x509-store" ,ghc-x509-store)
+ ("ghc-cryptonite" ,ghc-cryptonite)))
+ (home-page "http://github.com/vincenthz/hs-certificate")
+ (synopsis "X.509 certificate and revocation list validation")
+ (description
+ "This package provides functions for X.509 certificate and revocation
+list validation.")
+ (license bsd-3)))
+
+(define-public ghc-x509-system
+ (package
+ (name "ghc-x509-system")
+ (version "1.6.1")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "x509-system/x509-system-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "10qf60d2f9jqwnbrhsb2cwpi86xg66m6dxndlxw967v1cdb3h6gf"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-pem" ,ghc-pem)
+ ("ghc-x509" ,ghc-x509)
+ ("ghc-x509-store" ,ghc-x509-store)))
+ (home-page "http://github.com/vincenthz/hs-certificate")
+ (synopsis "Handle system X.509 accessors and storage")
+ (description
+ "This package provides a library to handle system accessors and storage
+for X.509 certificates.")
+ (license bsd-3)))
+
+(define-public ghc-tls
+ (package
+ (name "ghc-tls")
+ (version "1.3.3")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "tls/tls-" version ".tar.gz"))
+ (sha256
+ (base32
+ "096ay54bwy6qi9z8ypncww3ls853zj37yaficvcg7qcqj42zn0wz"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-mtl" ,ghc-mtl)
+ ("ghc-cereal" ,ghc-cereal)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-memory" ,ghc-memory)
+ ("ghc-cryptonite" ,ghc-cryptonite)
+ ("ghc-asn1-types" ,ghc-asn1-types)
+ ("ghc-asn1-encoding" ,ghc-asn1-encoding)
+ ("ghc-x509" ,ghc-x509)
+ ("ghc-x509-store" ,ghc-x509-store)
+ ("ghc-x509-validation" ,ghc-x509-validation)
+ ("ghc-async" ,ghc-async)
+ ("ghc-network" ,ghc-network)
+ ("ghc-hourglass" ,ghc-hourglass)))
+ (native-inputs
+ `(("ghc-tasty" ,ghc-tasty)
+ ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
+ ("ghc-quickcheck" ,ghc-quickcheck)))
+ (home-page "http://github.com/vincenthz/hs-tls")
+ (synopsis
+ "TLS/SSL protocol native implementation (Server and Client)")
+ (description
+ "Native Haskell TLS and SSL protocol implementation for server and client.
+This provides a high-level implementation of a sensitive security protocol,
+eliminating a common set of security issues through the use of the advanced
+type system, high level constructions and common Haskell features. Currently
+implement the SSL3.0, TLS1.0, TLS1.1 and TLS1.2 protocol, and support RSA and
+Ephemeral (Elliptic curve and regular) Diffie Hellman key exchanges, and many
+extensions.")
+ (license bsd-3)))
+
+(define-public ghc-socks
+ (package
+ (name "ghc-socks")
+ (version "0.5.4")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "socks/socks-" version ".tar.gz"))
+ (sha256
+ (base32
+ "1nmldlwxqasmg359i2aa3a903gi3lmnlspvf12xk49jrg3mf3dg9"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-cereal" ,ghc-cereal)
+ ("ghc-network" ,ghc-network)))
+ (home-page "http://github.com/vincenthz/hs-socks")
+ (synopsis "SOCKS proxy (version 5) implementation.")
+ (description
+ "This library provides a SOCKS proxy (version 5) implementation.")
+ (license bsd-3)))
+
+(define-public ghc-connection
+ (package
+ (name "ghc-connection")
+ (version "0.2.5")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "connection/connection-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "090il95jnm7ihwvcx3s9v6iwnp37nnsdx15q7722l845g51d95c8"))))
+ (build-system haskell-build-system)
+ (propagated-inputs
+ `(("ghc-byteable" ,ghc-byteable)
+ ("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-network" ,ghc-network)
+ ("ghc-tls" ,ghc-tls)
+ ("ghc-socks" ,ghc-socks)
+ ("ghc-x509" ,ghc-x509)
+ ("ghc-x509-store" ,ghc-x509-store)
+ ("ghc-x509-system" ,ghc-x509-system)
+ ("ghc-x509-validation" ,ghc-x509-validation)))
+ (home-page "http://github.com/vincenthz/hs-connection")
+ (synopsis "Simple and easy network connections API")
+ (description
+ "This package provides a simple network library for all your connection
+needs. It provides a very simple API to create sockets to a destination with
+the choice of SSL/TLS, and SOCKS.")
+ (license bsd-3)))
+
+(define-public ghc-http-client-tls
+ (package
+ (name "ghc-http-client-tls")
+ (version "0.2.2")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "http://hackage.haskell.org/package/"
+ "http-client-tls/http-client-tls-"
+ version ".tar.gz"))
+ (sha256
+ (base32
+ "0a01r05h5fxswyn6k6cgqgak4scqjan72hyy5wbdqzzhl4rmh7j5"))))
+ (build-system haskell-build-system)
+ ;; Tests require Internet access
+ (arguments `(#:tests? #f))
+ (propagated-inputs
+ `(("ghc-data-default-class" ,ghc-data-default-class)
+ ("ghc-http-client" ,ghc-http-client)
+ ("ghc-connection" ,ghc-connection)
+ ("ghc-network" ,ghc-network)
+ ("ghc-tls" ,ghc-tls)
+ ("ghc-http-types" ,ghc-http-types)))
+ (native-inputs
+ `(("ghc-hspec" ,ghc-hspec)))
+ (home-page "https://github.com/snoyberg/http-client")
+ (synopsis "Backend for http-client using the TLS library")
+ (description
+ "This package provides a backend for the http-client package using the
+connection and TLS libraries. It is intended for use by higher-level
+libraries, such as http-conduit.")
+ (license expat)))
+
(define-public idris
(package
(name "idris")