3241 lines
108 KiB
Scheme
3241 lines
108 KiB
Scheme
;;; Copyright © 2022 Anders Ågren Thuné <anders.agren-thune@it.uu.se>
|
|
;;; Copyright © 2024-present Hashirama Senju
|
|
|
|
(define-module (ajatt packages haskell)
|
|
#:use-module ((guix licenses) #:prefix license:)
|
|
#:use-module (gnu packages fontutils)
|
|
#:use-module (gnu packages glib)
|
|
#:use-module (gnu packages gtk)
|
|
#:use-module (gnu packages haskell)
|
|
#:use-module (gnu packages haskell-check)
|
|
#:use-module (gnu packages haskell-web)
|
|
#:use-module (gnu packages haskell-check)
|
|
#:use-module (gnu packages haskell-apps)
|
|
#:use-module (gnu packages haskell-xyz)
|
|
#:use-module (gnu packages pkg-config)
|
|
#:use-module (gnu packages webkit)
|
|
#:use-module (gnu packages wm)
|
|
#:use-module (gnu packages xorg)
|
|
#:use-module (gnu packages webkit)
|
|
#:use-module (gnu packages gnome)
|
|
#:use-module (gnu packages graphviz)
|
|
#:use-module (gnu packages backup)
|
|
#:use-module (gnu packages maths)
|
|
#:use-module (gnu packages file-systems)
|
|
#:use-module (guix build-system haskell)
|
|
#:use-module (guix download)
|
|
#:use-module (guix gexp)
|
|
#:use-module (guix build utils)
|
|
#:use-module (guix packages)
|
|
#:use-module (guix utils))
|
|
|
|
(define-public ghc-xml-helpers
|
|
(package
|
|
(name "ghc-xml-helpers")
|
|
(version "1.0.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/xml-helpers/xml-helpers-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0rrk0j7m8ws86hbjw0l4ryq4m9i8llhsag2sfisy5r1iv2zwa0lv"))))
|
|
(build-system haskell-build-system)
|
|
(inputs (list ghc-xml))
|
|
(home-page "http://github.com/acw/xml-helpers")
|
|
(synopsis "Some useful helper functions for the xml library.")
|
|
(description
|
|
"Included are some folds and maps I've found useful in parsing XML data.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-xdg-desktop-entry
|
|
(package
|
|
(name "ghc-xdg-desktop-entry")
|
|
(version "0.1.1.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/xdg-desktop-entry/xdg-desktop-entry-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0xlniirgj01v02dp6wx8iw038p4mx2pa3rmwfv3g7k5raa7gzapb"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-configfile
|
|
ghc-either
|
|
ghc-multimap
|
|
ghc-safe))
|
|
(home-page "http://hackage.haskell.org/package/xdg-desktop-entry")
|
|
(synopsis "Parse files conforming to the xdg desktop entry spec")
|
|
(description "")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-tuple
|
|
(package
|
|
(name "ghc-tuple")
|
|
(version "0.3.0.2")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/tuple/tuple-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "094nx29aahyrvbcn7yca9zs2a5rxz1is7510w1q43rpvza7hdjrg"))))
|
|
(build-system haskell-build-system)
|
|
(inputs (list ghc-onetuple))
|
|
(home-page "http://hackage.haskell.org/package/tuple")
|
|
(synopsis "Various functions on tuples")
|
|
(description
|
|
"Various useful functions on tuples, overloaded on tuple size.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-scotty
|
|
(package
|
|
(name "ghc-scotty")
|
|
(version "0.12")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/scotty/scotty-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1lpggpdzgjk23mq7aa64yylds5dbm4ynhcvbarqihjxabvh7xmz1"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-aeson
|
|
ghc-base-compat-batteries
|
|
ghc-blaze-builder
|
|
ghc-case-insensitive
|
|
ghc-data-default-class
|
|
ghc-fail
|
|
ghc-http-types
|
|
ghc-monad-control
|
|
ghc-nats
|
|
ghc-network
|
|
ghc-regex-compat
|
|
ghc-transformers-base
|
|
ghc-transformers-compat
|
|
ghc-wai
|
|
ghc-wai-extra
|
|
ghc-warp))
|
|
(native-inputs
|
|
(list
|
|
ghc-async
|
|
ghc-hspec
|
|
ghc-hspec-wai
|
|
ghc-lifted-base
|
|
hspec-discover))
|
|
(arguments
|
|
`(#:cabal-revision
|
|
("6" "15gwvx9gdk4vxh1x2n5xvnrix8m0wl96a4aqbdmdfrka43sywfma")))
|
|
(home-page "https://github.com/scotty-web/scotty")
|
|
(synopsis
|
|
"Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp")
|
|
(description
|
|
"A Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp. . @ {-# LANGUAGE OverloadedStrings #-} . import Web.Scotty . import Data.Monoid (mconcat) . main = scotty 3000 $   get "/:word" $ do     beam <- param "word"     html $ mconcat ["<h1>Scotty, ", beam, " me up!</h1>"] @ . . Scotty is the cheap and cheerful way to write RESTful, declarative web applications. . * A page is as simple as defining the verb, url pattern, and Text content. . * It is template-language agnostic. Anything that returns a Text value will do. . * Conforms to WAI Application interface. . * Uses very fast Warp webserver by default. . As for the name: Sinatra + Warp = Scotty. . [WAI] <http://hackage.haskell.org/package/wai> . [Warp] <http://hackage.haskell.org/package/warp>")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-time-units
|
|
(package
|
|
(name "ghc-time-units")
|
|
(version "1.0.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/time-units/time-units-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "16g0i6r6vj9w4lbn12jqrhgbbjjca8wbzq6546dz08aks1yrk0g1"))))
|
|
(build-system haskell-build-system)
|
|
(home-page "http://github.com/acw/time-units")
|
|
(synopsis "A basic library for defining units of time as types.")
|
|
(description
|
|
"In many cases, it is useful (either for error checking or documentation reasons) to define input and output types as having a particular unit of time. In addition, by creating a type class defining type units, this library should make it easier to separate the units of time the developer wants to think in versus the units of time the library author wants to think in.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-rate-limit
|
|
(package
|
|
(name "ghc-rate-limit")
|
|
(version "1.4.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/rate-limit/rate-limit-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0xhksvhl0cr5kfvdfnlk78jrn4kvj2h54x19ixp356b4xxijdy9x"))))
|
|
(build-system haskell-build-system)
|
|
(inputs (list ghc-time-units))
|
|
(home-page "http://github.com/acw/rate-limit")
|
|
(synopsis "A basic library for rate-limiting IO actions.")
|
|
(description
|
|
"In many cases, it is useful, necessary, or simply nice to limit how frequently you perform some action. For example, you may want to limit how often your program makes a request of some web site. This library is intended as a general-purpose mechanism for rate-limiting IO actions.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-multimap
|
|
(package
|
|
(name "ghc-multimap")
|
|
(version "1.2.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/multimap/multimap-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0d3l5q4yvmywl6i9ip96zz0fvhjdh00mfbbniphbjxsi8wlwack3"))))
|
|
(build-system haskell-build-system)
|
|
(home-page "http://hub.darcs.net/scravy/multimap")
|
|
(synopsis "A multimap.")
|
|
(description
|
|
"This is a simple implementation of a multimap, based on \"Data.Map\". . [@v1.1@] @!@ had its arguments flipped. Fixed. Also added @fromMap@. . [@v1.2@] Added \"Data.SetMap\", renamed @Multimap@ to \"Data.MultiMap\". Fixed the type of @delete@. Derive instances for @Data@ and @Typeable@. . [@v1.2.1@] Fixed typos in the documentation.")
|
|
(license license:expat)))
|
|
|
|
(define-public ghc-bytestring-to-vector
|
|
(package
|
|
(name "ghc-bytestring-to-vector")
|
|
(version "0.3.0.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/bytestring-to-vector/bytestring-to-vector-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0ji836sl72wlhy6yay11kl86w0nrcdc1lafbi94bx9c8rpf5pyyc"))))
|
|
(build-system haskell-build-system)
|
|
(inputs (list ghc-vector))
|
|
(native-inputs
|
|
(list ghc-byteorder ghc-quickcheck))
|
|
(home-page "https://github.com/sheyll/bytestring-to-vector")
|
|
(synopsis "Convert between ByteString and Vector.Storable without copying")
|
|
(description
|
|
"This library allows conversion between the types from @Data.ByteString@ (package @bytestring@) and @Data.Vector.Storable@ (package @vector@) without copying the underlying data. This is useful, for example, when @ByteString@ IO produces or consumes vectors of numbers in native byte order. . The conversion relies on the fact that @ByteString@ and @Vector@ use their respective @ForeignPtr@s in compatible ways. . This library is a fork of the @spool@ package written by Keegan McAllister.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-primitive-unaligned
|
|
(package
|
|
(name "ghc-primitive-unaligned")
|
|
(version "0.1.1.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/primitive-unaligned/primitive-unaligned-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1f3a46d9dr7x1k8b6ixnp9jzxkppx3g27qsxq4f244ndnf2jnchl"))))
|
|
(build-system haskell-build-system)
|
|
(inputs (list ghc-primitive))
|
|
(home-page "https://github.com/haskell-primitive/primitive-unaligned")
|
|
(synopsis "Unaligned access to primitive arrays")
|
|
(description
|
|
"Unaligned access to primitive arrays. The offsets are given in bytes rather than elements.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-byte-order
|
|
(package
|
|
(name "ghc-byte-order")
|
|
(version "0.1.2.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/byte-order/byte-order-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1nnq4qmqmkv61xcyxrh14s6hg7rbnjkna6mwlrqh1rr59pikn45w"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-primitive
|
|
ghc-primitive-unaligned))
|
|
(home-page "https://github.com/andrewthad/byte-order")
|
|
(synopsis "Portable big-endian and little-endian conversions")
|
|
(description
|
|
"This library provides an interface to portably work with byte arrays whose contents are known to be of a fixed endianness. There are two ways to use this module. See the `System.ByteOrder` module for more documentation.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-status-notifier-item
|
|
(package
|
|
(name "ghc-status-notifier-item")
|
|
(version "0.3.1.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/status-notifier-item/status-notifier-item-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1x3zqa2b9vl5mirfbh2bmyali47jpfcqsw4xxgbmsgz9jiffpda9"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-byte-order
|
|
ghc-bytestring-to-vector
|
|
ghc-dbus
|
|
ghc-hslogger
|
|
ghc-lens
|
|
ghc-vector
|
|
ghc-optparse-applicative
|
|
ghc-dbus-hslogger))
|
|
(home-page "https://github.com/IvanMalison/status-notifier-item#readme")
|
|
(synopsis
|
|
"A wrapper over the StatusNotifierItem/libappindicator dbus specification")
|
|
(description
|
|
"Please see the README on Github at <https://github.com/IvanMalison/status-notifier-item#readme>")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-gtk-strut
|
|
(package
|
|
(name "ghc-gtk-strut")
|
|
(version "0.1.3.2")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gtk-strut/gtk-strut-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "19p3w1zvnaazfd01yy4cl00sl53xc7kqgqhsw7l3psadmwk6x4w1"))))
|
|
(build-system haskell-build-system)
|
|
(inputs (list ghc-gi-gdk ghc-gi-gtk))
|
|
(home-page "https://github.com/IvanMalison/gtk-strut#readme")
|
|
(synopsis "Libary for creating strut windows with gi-gtk")
|
|
(description
|
|
"Please see the README on Github at <https://github.com/IvanMalison/gtk-strut#readme>")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-gi-dbusmenu
|
|
(package
|
|
(name "ghc-gi-dbusmenu")
|
|
(version "0.4.14")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-dbusmenu/gi-dbusmenu-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1n2bxi7cwj32ncalqwid3igk0ssh4pc81z132255216apryszq13"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-glib
|
|
ghc-gi-gobject
|
|
gobject-introspection
|
|
libdbusmenu
|
|
glib))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Dbusmenu bindings")
|
|
(description "Bindings for libdbusmenu, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-dbusmenugtk3
|
|
(package
|
|
(name "ghc-gi-dbusmenugtk3")
|
|
(version "0.4.15")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-dbusmenugtk3/gi-dbusmenugtk3-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1hq7v2lii8n6nn1dhdg42z2d3in8xahkhm6xk4hmfj7abzfghz7z"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-glib
|
|
ghc-gi-gobject
|
|
ghc-gi-gtk
|
|
ghc-gi-dbusmenu
|
|
ghc-gi-atk
|
|
ghc-gi-gdk
|
|
ghc-gi-gdkpixbuf
|
|
gobject-introspection
|
|
libdbusmenu
|
|
gtk+))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "DbusmenuGtk bindings")
|
|
(description "Bindings for libdbusgtk3, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gtk-sni-tray
|
|
(package
|
|
(name "ghc-gtk-sni-tray")
|
|
(version "0.1.8.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gtk-sni-tray/gtk-sni-tray-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0b8b8hvsv60zvnjidqm1qchxdgqdf5gcmm5pz8fvrvcjqq27b1xa"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-dbus
|
|
ghc-enclosed-exceptions
|
|
ghc-gi-cairo
|
|
ghc-gi-cairo-connector
|
|
ghc-gi-cairo-render
|
|
ghc-gi-dbusmenugtk3
|
|
ghc-gi-gdk
|
|
ghc-gi-gdkpixbuf
|
|
ghc-gi-glib
|
|
ghc-gi-gtk
|
|
ghc-gtk-strut
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-base
|
|
ghc-hslogger
|
|
ghc-status-notifier-item
|
|
ghc-transformers-base
|
|
ghc-dbus-hslogger
|
|
ghc-optparse-applicative
|
|
gtk+))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/IvanMalison/gtk-sni-tray#readme")
|
|
(synopsis "A standalone StatusNotifierItem/AppIndicator tray")
|
|
(description
|
|
"Please see the README on Github at <https://github.com/IvanMalison/gtk-sni-tray#readme>")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-gi-gtk-hs
|
|
(package
|
|
(name "ghc-gi-gtk-hs")
|
|
(version "0.3.16")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-gtk-hs/gi-gtk-hs-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1ph9fq2lwa16pq68vkmp2843n0hjx89zfjmxs80lsv41bkvza8qy"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-base-compat
|
|
ghc-haskell-gi-base
|
|
ghc-gi-glib
|
|
ghc-gi-gobject
|
|
ghc-gi-gdk
|
|
ghc-gi-gtk
|
|
ghc-gi-gdkpixbuf))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis
|
|
"A wrapper for gi-gtk, adding a few more idiomatic API parts on top")
|
|
(description
|
|
"A wrapper for gi-gtk, adding a few more idiomatic API parts on top")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-atk
|
|
(package
|
|
(name "ghc-gi-atk")
|
|
(version "2.0.28")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-atk/gi-atk-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0dkzchgsbb7f4b4p56ni4s1vmpp7ln722djcbcp5zazqbd0s9vfd"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-gobject
|
|
ghc-gi-glib
|
|
gobject-introspection
|
|
atk))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Atk bindings")
|
|
(description "Bindings for Atk, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-gtk
|
|
(package
|
|
(name "ghc-gi-gtk")
|
|
(version "4.0.6")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-gtk/gi-gtk-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "146x3xp12jl416gl75mdx6jgnh0ayh9s64f7nl5ccw5r7dw8fz6f"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-cairo
|
|
ghc-gi-pango
|
|
ghc-gi-gio
|
|
ghc-gi-gdk
|
|
ghc-gi-gdkpixbuf
|
|
ghc-gi-graphene
|
|
ghc-gi-gsk
|
|
ghc-gi-gobject
|
|
ghc-gi-glib
|
|
ghc-gi-atk
|
|
gobject-introspection
|
|
gtk))
|
|
(native-inputs
|
|
(list pkg-config
|
|
gtk))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Gtk bindings")
|
|
(description "Bindings for Gtk, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
|
|
|
|
|
|
(define-public ghc-gi-gtksource
|
|
(package
|
|
(name "ghc-gi-gtksource")
|
|
(version "5.0.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-gtksource/gi-gtksource-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0s5xc3d7i2a4ysa2m5kd9qsr2g78yiqj4rfjy06n0kqsmymprvj2"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-cairo
|
|
ghc-gi-pango
|
|
ghc-gi-gio
|
|
ghc-gi-gdk
|
|
ghc-gi-gdkpixbuf
|
|
ghc-gi-graphene
|
|
ghc-gi-gsk
|
|
ghc-gi-gobject
|
|
ghc-gi-glib
|
|
ghc-gi-gtk
|
|
ghc-gi-atk
|
|
ghc-transformers
|
|
ghc-bytestring-builder
|
|
gobject-introspection
|
|
gtksourceview
|
|
gtk
|
|
glib))
|
|
(native-inputs
|
|
(list pkg-config
|
|
gtk
|
|
glib
|
|
ghc-gi-glib
|
|
gtksourceview
|
|
gobject-introspection))
|
|
(arguments
|
|
'(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'configure 'set-configure-environment-variables
|
|
(lambda _
|
|
(setenv "LD_LIBRARY_PATH" (getenv "LIBRARY_PATH"))
|
|
#t)))))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Bindings for GtkSource")
|
|
(description "Bindings for GtkSource, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-xlib
|
|
(package
|
|
(name "ghc-gi-xlib")
|
|
(version "2.0.14")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-xlib/gi-xlib-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1h6kpg0mm16b5rz7ixi5qj8y0is96cwkkpgwcl8m8ycjscsgfj88"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
gobject-introspection
|
|
gdk-pixbuf
|
|
libx11))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "xlib bindings")
|
|
(description "Bindings for xlib, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-gdkx11
|
|
(package
|
|
(name "ghc-gi-gdkx11")
|
|
(version "4.0.8")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-gdkx11/gi-gdkx11-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0sfgym80d10nn4p91595xa89fnxvzhm1a1abdv89yw5dq4y5hih8"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-gobject
|
|
ghc-gi-gdk
|
|
ghc-gi-gio
|
|
ghc-gi-cairo
|
|
ghc-gi-xlib
|
|
gobject-introspection
|
|
gtk+))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "GdkX11 bindings")
|
|
(description "Bindings for GdkX11, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-gmodule
|
|
(package
|
|
(name "ghc-gi-gmodule")
|
|
(version "2.0.6")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-gmodule/gi-gmodule-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1q4a71fimdgrdfzpxf63fkjya2n624b2kyadrcpn17518hhagk7l"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-glib
|
|
gobject-introspection
|
|
glib))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "GModule bindings")
|
|
(description "Bindings for GModule, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-gdkpixbuf
|
|
(package
|
|
(name "ghc-gi-gdkpixbuf")
|
|
(version "2.0.32")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-gdkpixbuf/gi-gdkpixbuf-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1yxsrhxv5ndj60bv6djnhbmyh3a6ahmdkyfw5xbr3wy8hh9vc7l3"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
gdk-pixbuf
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-gio
|
|
ghc-gi-gobject
|
|
ghc-gi-glib
|
|
ghc-gi-gmodule
|
|
gobject-introspection))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "GdkPixbuf bindings")
|
|
(description "Bindings for GdkPixbuf, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-gio
|
|
(package
|
|
(name "ghc-gi-gio")
|
|
(version "2.0.35")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-gio/gi-gio-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "07b4gg1wbb5mz63xpvjjdbdp0z9wci5jckr1gr0qxrizyc3vv2vi"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-gobject
|
|
ghc-gi-glib
|
|
gobject-introspection
|
|
glib))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Gio bindings")
|
|
(description "Bindings for Gio, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-freetype2
|
|
(package
|
|
(name "ghc-gi-freetype2")
|
|
(version "2.0.5")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "gi-freetype2" version))
|
|
(sha256
|
|
(base32 "115yjlhb507wp21hcngygr0mrq4vdpnbx24gyfd5wwba9ny38a9j"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "gi-freetype2")))
|
|
(inputs (list ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-transformers
|
|
ghc-bytestring-builder
|
|
freetype))
|
|
(native-inputs
|
|
(list gobject-introspection
|
|
pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "freetype2 bindings")
|
|
(description "Bindings for freetype2, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-harfbuzz
|
|
(package
|
|
(name "ghc-gi-harfbuzz")
|
|
(version "0.0.10")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-harfbuzz/gi-harfbuzz-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1b7mmva40a3j1qm2155sy106wwrklj2p5fjwdzlkma8bnr6r2mqx"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
freetype
|
|
ghc-gi-freetype2
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-gobject
|
|
ghc-gi-glib
|
|
gobject-introspection
|
|
harfbuzz))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "HarfBuzz bindings")
|
|
(description "Bindings for HarfBuzz, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-glib
|
|
(package
|
|
(name "ghc-gi-glib")
|
|
(version "2.0.30")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-glib/gi-glib-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1l9lh3rkf4z6mw16g3ghrzsipbn4iv7jrqwcnv0mg12sa5y4slbp"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
gobject-introspection
|
|
glib))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "GLib bindings")
|
|
(description "Bindings for GLib, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-gobject
|
|
(package
|
|
(name "ghc-gi-gobject")
|
|
(version "2.0.31")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-gobject/gi-gobject-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1vhdbvcr33gi2cvf31q1zbgkd0gpgcrwnqi59ylrsw6xmblndhdh"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-glib
|
|
gobject-introspection
|
|
glib))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "GObject bindings")
|
|
(description "Bindings for GObject, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-pango
|
|
(package
|
|
(name "ghc-gi-pango")
|
|
(version "1.0.30")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-pango/gi-pango-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1kp3jnnjik1caiax3j548aypn77qzi1l8r9b2zki95s2yg5rpv9p"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'configure 'set-configure-environment-variables
|
|
(lambda _
|
|
(setenv "LD_LIBRARY_PATH" (getenv "LIBRARY_PATH"))
|
|
#t)))))
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-gobject
|
|
ghc-gi-glib
|
|
ghc-gi-gio
|
|
ghc-gi-harfbuzz
|
|
gobject-introspection
|
|
pango))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Pango bindings")
|
|
(description "Bindings for Pango, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-gsk
|
|
(package
|
|
(name "ghc-gi-gsk")
|
|
(version "4.0.8")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-gsk/gi-gsk-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0akmlbjapiqnn4lfh4z5b95w8ck2jlrp7abqahaxdcbj3d2kcpb4"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-gi-gdk
|
|
ghc-gi-graphene
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-cairo
|
|
ghc-gi-pango
|
|
ghc-gi-gio
|
|
ghc-gi-gdkpixbuf
|
|
ghc-gi-gobject
|
|
ghc-gi-glib
|
|
ghc-transformers
|
|
ghc-bytestring-builder
|
|
gobject-introspection
|
|
gtk))
|
|
(native-inputs
|
|
(list pkg-config
|
|
gtk))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Gdk bindings")
|
|
(description "Bindings for Gsk, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-graphene
|
|
(package
|
|
(name "ghc-gi-graphene")
|
|
(version "1.0.8")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-graphene/gi-graphene-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "189fsk72m3v7qbwyn75vradvi3y9vrbjlg95dbr65k2mm1if2n9k"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-cairo
|
|
ghc-gi-pango
|
|
ghc-gi-gio
|
|
ghc-gi-gdkpixbuf
|
|
ghc-gi-gobject
|
|
ghc-gi-glib
|
|
ghc-transformers
|
|
ghc-bytestring-builder
|
|
gobject-introspection
|
|
gtk))
|
|
(native-inputs
|
|
(list pkg-config
|
|
gtk))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Gdk bindings")
|
|
(description "Bindings for Graphene, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-gdk
|
|
(package
|
|
(name "ghc-gi-gdk")
|
|
(version "4.0.9")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-gdk/gi-gdk-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0c43wxbq4g41j107gnh8gyxjsws223p7kkm46hihjvs8pcxrab94"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
ghc-gi-cairo
|
|
ghc-gi-pango
|
|
ghc-gi-gio
|
|
ghc-gi-gdkpixbuf
|
|
ghc-gi-gobject
|
|
ghc-gi-glib
|
|
ghc-transformers
|
|
ghc-bytestring-builder
|
|
gobject-introspection
|
|
ghc-gi-graphene
|
|
gtk))
|
|
(native-inputs
|
|
(list pkg-config
|
|
gtk)) ;; was gtk+, but in guix gtk is the name for gtk-4
|
|
(arguments
|
|
'(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'configure 'set-configure-environment-variables
|
|
(lambda _
|
|
(setenv "GI_TYPELIB_PATH" (getenv "GI_TYPELIB_PATH"))
|
|
#t)))))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Gdk bindings")
|
|
(description "Bindings for Gdk, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
|
|
|
|
(define-public ghc-gi-cairo-render
|
|
(package
|
|
(name "ghc-gi-cairo-render")
|
|
(version "0.1.2")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-cairo-render/gi-cairo-render-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "07h3k8bzb6qhk7x2v68dg5gsxxpjpr7k3vvh2fyqb9zj9rq8lyfc"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-utf8-string
|
|
ghc-haskell-gi-base
|
|
cairo))
|
|
(native-inputs
|
|
(list ghc-c2hs pkg-config))
|
|
(home-page "https://github.com/cohomology/gi-cairo-render")
|
|
(synopsis "GI friendly Binding to the Cairo library.")
|
|
(description
|
|
"Cairo is a library to render high quality vector graphics. There exist various backends that allows rendering to Gtk windows, PDF, PS, PNG and SVG documents, amongst others.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-gi-cairo-connector
|
|
(package
|
|
(name "ghc-gi-cairo-connector")
|
|
(version "0.1.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-cairo-connector/gi-cairo-connector-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0jkca1x0dlyfwyywn6gmsnxhyad3j7vfwa0c4hpvx8k8m350dn3c"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-gi-cairo
|
|
ghc-gi-cairo-render))
|
|
(home-page "https://github.com/cohomology/gi-cairo-render")
|
|
(synopsis "GI friendly Binding to the Cairo library.")
|
|
(description
|
|
"This library contains glue code used to interconnect Haskell GI and Cairo")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-haskell-gi-overloading
|
|
(package
|
|
(name "ghc-haskell-gi-overloading")
|
|
(version "1.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/haskell-gi-overloading/haskell-gi-overloading-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0ak8f79ia9zlk94zr02sq8bqi5n5pd8ria8w1dj3adcdvpw9gmry"))))
|
|
(build-system haskell-build-system)
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Overloading support for haskell-gi")
|
|
(description
|
|
"Control overloading support in haskell-gi generated bindings")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-haskell-gi
|
|
(package
|
|
(name "ghc-haskell-gi")
|
|
(version "0.26.14")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/haskell-gi/haskell-gi-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1cz429xlbw7aszqz9dygy31vv0bckdxz14qlwqm57vkdd6j7gv00"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-attoparsec
|
|
ghc-pretty-show
|
|
ghc-ansi-terminal
|
|
ghc-safe
|
|
ghc-xdg-basedir
|
|
ghc-xml-conduit
|
|
ghc-regex-tdfa
|
|
glib
|
|
gobject-introspection))
|
|
(native-inputs
|
|
(list
|
|
ghc-doctest
|
|
ghc-cabal-doctest
|
|
pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis
|
|
"Generate Haskell bindings for GObject Introspection capable libraries")
|
|
(description
|
|
"Generate Haskell bindings for GObject Introspection capable libraries. This includes most notably Gtk+, but many other libraries in the GObject ecosystem provide introspection data too.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-haskell-gi-base
|
|
(package
|
|
(name "ghc-haskell-gi-base")
|
|
(version "0.26.8")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/haskell-gi-base/haskell-gi-base-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "19sp8yi9inxq7vqw6zpf2rlk56algxajkf8gyl0iqbx95kb4x1bb"))))
|
|
(build-system haskell-build-system)
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(inputs
|
|
(list glib ghc-gtk2hs-buildtools))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Foundation for libraries generated by haskell-gi")
|
|
(description "Foundation for libraries generated by haskell-gi")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-cairo
|
|
(package
|
|
(name "ghc-gi-cairo")
|
|
(version "1.0.30")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-cairo/gi-cairo-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0s0ych0fxnfaqg2q2ndfp2zj01sya0j888snd2rdbaiikxy0kvsq"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-before 'configure 'set-configure-environment-variables
|
|
(lambda _
|
|
(setenv "LD_LIBRARY_PATH" (getenv "LIBRARY_PATH"))
|
|
#t)))))
|
|
(inputs
|
|
(list
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-overloading
|
|
gobject-introspection
|
|
cairo))
|
|
(native-inputs
|
|
(list pkg-config))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Cairo bindings")
|
|
(description "Bindings for Cairo, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-io-storage
|
|
(package
|
|
(name "ghc-io-storage")
|
|
(version "0.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/io-storage/io-storage-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1ga9bd7iri6vlsxnjx765yy3bxc4lbz644wyw88yzvpjgz6ga3cs"))))
|
|
(build-system haskell-build-system)
|
|
(home-page "http://github.com/willdonnelly/io-storage")
|
|
(synopsis "A key-value store in the IO monad.")
|
|
(description
|
|
"This library allows an application to extend the 'global state' hidden inside the IO monad with semi-arbitrary data. Data is required to be 'Typeable'. The library provides an essentially unbounded number of key-value stores indexed by strings, with each key within the stores also being a string.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-dyre
|
|
(package
|
|
(name "ghc-dyre")
|
|
(version "0.9.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/dyre/dyre-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1lrpjvah57p1ld3spcrgqds3claqkd5a9ay8inihl9wws0ifhfmh"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(inputs
|
|
(list
|
|
ghc-executable-path
|
|
ghc-io-storage
|
|
ghc-xdg-basedir))
|
|
(home-page "http://github.com/willdonnelly/dyre")
|
|
(synopsis "Dynamic reconfiguration in Haskell")
|
|
(description
|
|
"Dyre implements dynamic reconfiguration facilities after the style of Xmonad. Dyre aims to be as simple as possible without sacrificing features, and places an emphasis on simplicity of integration with an application. A full introduction with a complete example project can be found in the documentation for 'Config.Dyre'")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-dbus-hslogger
|
|
(package
|
|
(name "ghc-dbus-hslogger")
|
|
(version "0.1.0.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/dbus-hslogger/dbus-hslogger-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0i2y69kagp53cmlb7p3y6ysr9k5wvfd0vcnpwsasyn1jpk6g80zi"))))
|
|
(build-system haskell-build-system)
|
|
(inputs
|
|
(list
|
|
ghc-dbus
|
|
ghc-hslogger
|
|
ghc-optparse-applicative))
|
|
(home-page "https://github.com/IvanMalison/dbus-hslogger#readme")
|
|
(synopsis "Expose a dbus server to control hslogger")
|
|
(description
|
|
"Please see the README on Github at <https://github.com/IvanMalison/dbus-hslogger#readme>")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-broadcast-chan
|
|
(package
|
|
(name "ghc-broadcast-chan")
|
|
(version "0.2.1.2")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/broadcast-chan/broadcast-chan-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1zsrafz3q9l8np8wafmrbi8ilwwsgnzkc8jfjkjfgs4kq65yglqw"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
`(#:cabal-revision
|
|
("1" "1989dc49db8cf3ca24x4hs3nirm74xl9p0dqf8kpj1dr64y6dvzj")))
|
|
(inputs
|
|
(list ghc-unliftio-core))
|
|
(home-page "https://github.com/merijn/broadcast-chan")
|
|
(synopsis
|
|
"Closable, fair, single-wakeup channel type that avoids 0 reader space leaks.")
|
|
(description
|
|
"A closable, fair, single-wakeup channel that avoids the 0 reader space leak that @\"Control.Concurrent.Chan\"@ from base suffers from. The @Chan@ type from @\"Control.Concurrent.Chan\"@ consists of both a read and write end combined into a single value. This means there is always at least 1 read end for a @Chan@, which keeps any values written to it alive. This is a problem for applications/libraries that want to have a channel that can have zero listeners. @\"BroadcastChan\"@ splits channels into separate read and write ends. Any message written to a a channel with no existing read end is immediately dropped so it can be garbage collected.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-hstringtemplate
|
|
(package
|
|
(name "ghc-hstringtemplate")
|
|
(version "0.8.8")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/HStringTemplate/HStringTemplate-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1n8ci0kzjcgnqh4dfpqwlh7mnlzyiqiqc6hc0zr65p0balbg8zbi"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
`(#:cabal-revision
|
|
("4" "0sj82pzq2hcx3yjsljwgbr1kcdgwpgfmq0n0dhz3am8ckwir0slz")))
|
|
(inputs
|
|
(list
|
|
ghc-blaze-builder
|
|
ghc-old-locale
|
|
ghc-semigroups
|
|
ghc-syb
|
|
ghc-void))
|
|
(native-inputs
|
|
(list
|
|
ghc-quickcheck
|
|
ghc-random
|
|
ghc-hunit))
|
|
(home-page "http://hackage.haskell.org/package/HStringTemplate")
|
|
(synopsis "StringTemplate implementation in Haskell.")
|
|
(description "A port of the Java library by Terrence Parr.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-configfile
|
|
(package
|
|
(name "ghc-configfile")
|
|
(version "1.1.4")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/ConfigFile/ConfigFile-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "057mw146bip9wzs7j4b5xr1x24d8w0kr4i3inri5m57jkwspn25f"))))
|
|
(build-system haskell-build-system)
|
|
(inputs (list ghc-missingh))
|
|
(home-page "http://software.complete.org/configfile")
|
|
(synopsis "Configuration file reading & writing")
|
|
(description
|
|
"Parser and writer for handling sectioned config files in Haskell. . The ConfigFile module works with configuration files in a standard format that is easy for the user to edit, easy for the programmer to work with, yet remains powerful and flexible. It is inspired by, and compatible with, Python's ConfigParser module. It uses files that resemble Windows .INI-style files, but with numerous improvements. . ConfigFile provides simple calls to both read and write config files. It's possible to make a config file parsable by this module, the Unix shell, and make.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-z-data
|
|
(package
|
|
(name "ghc-z-data")
|
|
(version "2.0.1.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "Z-Data" version))
|
|
(sha256
|
|
(base32 "17rz3yasgjvw3sbzzwc2xr4hf05nmgxcvhlqrk77w3wcf18fixj6"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(properties '((upstream-name . "Z-Data")))
|
|
(inputs (list ghc-case-insensitive
|
|
ghc-hashable
|
|
ghc-primitive
|
|
ghc-hspec-discover
|
|
ghc-quickcheck
|
|
ghc-random
|
|
ghc-scientific
|
|
ghc-tagged
|
|
ghc-unordered-containers
|
|
ghc-unicode-collation
|
|
ghc-uuid-types))
|
|
(native-inputs (list ghc-hspec ghc-hunit ghc-quickcheck-instances))
|
|
(home-page "https://github.com/ZHaskell/z-data")
|
|
(synopsis "Array, vector and text")
|
|
(description "This package provides array, slice and text operations.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-z-io
|
|
(package
|
|
(name "ghc-z-io")
|
|
(version "2.0.0.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/Z-IO/Z-IO-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1n621brs608v6kpnjxb3hgh3h0garw8k1hr1ym5l8l0v7h2gv085"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(inputs (list ghc-foldl ghc-primitive ghc-unix-time
|
|
ghc-unordered-containers ghc-z-data))
|
|
(native-inputs (list ghc-hashable
|
|
ghc-hspec
|
|
ghc-random ;; not really needed
|
|
ghc-hunit
|
|
ghc-hspec-discover
|
|
ghc-quickcheck
|
|
ghc-quickcheck-instances
|
|
ghc-scientific
|
|
ghc-zlib))
|
|
(home-page "https://github.com/ZHaskell/Z-IO")
|
|
(synopsis "Simple and high performance IO toolkit for Haskell")
|
|
(description
|
|
"Simple and high performance IO toolkit for Haskell, including file system,
|
|
network, ipc and more!")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-gi-webkit
|
|
(package
|
|
(name "ghc-gi-webkit")
|
|
(version "6.0.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-webkit/gi-webkit-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "00nzd9qzbiwrv2511z0cv4wka3haxfxry89i068qh9g08ly7jzca"))))
|
|
(build-system haskell-build-system)
|
|
(native-inputs (list
|
|
ghc-gi-atk
|
|
ghc-gi-cairo
|
|
ghc-gi-gdk
|
|
ghc-gi-gio
|
|
ghc-gi-glib
|
|
ghc-gi-gobject
|
|
gobject-introspection
|
|
ghc-gi-gtk
|
|
ghc-gi-gmodule
|
|
ghc-gi-javascriptcore
|
|
ghc-gi-soup
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi-overloading
|
|
webkitgtk
|
|
pkg-config
|
|
))
|
|
(arguments
|
|
`(#:phases
|
|
(modify-phases %standard-phases
|
|
(add-after 'unpack 'patch-cabal-file
|
|
(lambda _
|
|
(substitute* "gi-webkit.cabal"
|
|
(("gi-gtk4") "gi-gtk")
|
|
(("gi-gdk4") "gi-gdk"))
|
|
(substitute* "Setup.hs"
|
|
(("gi-gdk4") "gi-gdk")
|
|
(("gi-gtk4") "gi-gtk"))
|
|
#t)))))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Bindings for WebKit 6.x, autogenerated by haskell-gi.")
|
|
(description
|
|
"Haskell WebKit bindings.")
|
|
(license license:lgpl2.1)))
|
|
|
|
|
|
(define-public ghc-gi-soup
|
|
(package
|
|
(name "ghc-gi-soup")
|
|
(version "3.0.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-soup/gi-soup-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "154iw6689b9vhh9y82r3vc86lnvvzy1rvzadzsrp23c043gibg17"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(native-inputs (list
|
|
ghc-gi-gio
|
|
ghc-gi-glib
|
|
ghc-gi-gobject
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi-overloading
|
|
gobject-introspection
|
|
glib
|
|
libsoup
|
|
pkg-config
|
|
))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "Libsoup 3.x bindings.")
|
|
(description
|
|
"Bindings for Libsoup 3.x, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
(define-public ghc-gi-javascriptcore
|
|
(package
|
|
(name "ghc-gi-javascriptcore")
|
|
(version "6.0.4")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/gi-javascriptcore/gi-javascriptcore-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "095my50hg37g92f77336z56zc4axgf70fwqvabs0rysp39f1qnk0"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(native-inputs (list
|
|
ghc-gi-gio
|
|
ghc-gi-glib
|
|
ghc-gi-gobject
|
|
ghc-haskell-gi
|
|
ghc-haskell-gi-base
|
|
ghc-haskell-gi-overloading
|
|
gobject-introspection
|
|
webkitgtk
|
|
glib
|
|
pkg-config
|
|
))
|
|
(home-page "https://github.com/haskell-gi/haskell-gi")
|
|
(synopsis "JavaScriptCore 6.x bindings.")
|
|
(description
|
|
"Bindings for JavaScriptCore 6.x, autogenerated by haskell-gi.")
|
|
(license license:lgpl2.1)))
|
|
|
|
|
|
(define-public ghc-libzfs
|
|
(package
|
|
(name "ghc-libzfs")
|
|
(version "0.2.0.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/libzfs/libzfs-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1g3bn3dmkzalzpm645ag4vk9736in0xcszj28girpyphyiyfkk45"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
`(#:tests? #f
|
|
#:phases
|
|
(modify-phases %standard-phases
|
|
(add-after 'unpack 'patch-sources
|
|
(lambda _
|
|
;; Delete the example source file
|
|
(delete-file "example.hs")
|
|
;; Modify .cabal file to remove executable section
|
|
(substitute* "libzfs.cabal"
|
|
(("executable example.*") "")
|
|
((" main-is: example.hs.*") ""))
|
|
#t)))))
|
|
(inputs (list zfs))
|
|
(home-page "https://hackage.haskell.org/package/libzfs")
|
|
(synopsis "Bindings to libzfs, for dealing with the Z File System and Zpools.")
|
|
(description
|
|
"Bindings to libzfs, for dealing with the Z File System and Zpools.")
|
|
(license license:expat)))
|
|
|
|
|
|
(define-public ghc-lzma-static
|
|
(package
|
|
(name "ghc-lzma-static")
|
|
(version "5.2.5.5")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/lzma-static/lzma-static-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1qq0lzyfpnjdl9mh8qrr5lhhby8gxzgi1a8wiwpf3vkrziz5hh23"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(home-page "https://github.com/hasufell/lzma-static")
|
|
(synopsis "LZMA/XZ compression and decompression (static).")
|
|
(description
|
|
"This package provides a pure interface for compressing and decompressing LZMA (Lempel–Ziv–Markov chain algorithm) streams of data represented as lazy ByteStrings. A monadic incremental interface is provided as well. This package relies on the liblzma C library.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-unix-compat
|
|
(package
|
|
(name "ghc-unix-compat")
|
|
(version "0.7.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/unix-compat/unix-compat-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "11qxh9l2kqx4pqphbbmcbmc9bb2mifnjmzlcbkak5mjj163sskvs"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(home-page "https://github.com/haskell-pkg-janitors/unix-compat")
|
|
(synopsis "Portable POSIX-compatibility layer.")
|
|
(description
|
|
"This package provides portable implementations of parts of the unix package. This package re-exports the unix package when available. When it isn't available, portable implementations are used.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-composition-prelude
|
|
(package
|
|
(name "ghc-composition-prelude")
|
|
(version "3.0.1.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "composition-prelude" version))
|
|
(sha256
|
|
(base32 "068wpnviarwf3q0g8zy9sfgjarz7v73vdfapg3ji8n3xdcb24iwg"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "composition-prelude")))
|
|
(home-page "http://hackage.haskell.org/package/composition-prelude")
|
|
(synopsis "Higher-order function combinators")
|
|
(description
|
|
"Replacement for [composition](hackage.haskell.org/package/composition) or
|
|
[composition-extra](hackage.haskell.org/package/composition-extra), exporting
|
|
everything in one module.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-libarchive
|
|
(package
|
|
(name "ghc-libarchive")
|
|
(version "3.0.4.2")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/libarchive/libarchive-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1jzpp4sn3lchp68c6wrcfvg4yr8g1fhhki1s2qp2a15nyzljpq8i"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(native-inputs (list
|
|
libarchive
|
|
ghc-unix-compat
|
|
ghc-composition-prelude
|
|
ghc-dlist
|
|
ghc-c2hs
|
|
ghc-exceptions
|
|
cpphs
|
|
ghc-lzma-static
|
|
ghc-bzip2-clib
|
|
ghc-chs-cabal
|
|
ghc-bzlib
|
|
ghc-zlib
|
|
pkg-config
|
|
))
|
|
(home-page "https://github.com/vmchale/libarchive")
|
|
(synopsis "Haskell interface to libarchive.")
|
|
(description
|
|
"Haskell bindings for libarchive. Provides the ability to unpack archives, including the ability to unpack archives lazily.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-bzip2-clib
|
|
(package
|
|
(name "ghc-bzip2-clib")
|
|
(version "1.0.8")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/bzip2-clib/bzip2-clib-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0iax0fq5y24lcjkjsk66khry9s6v9hhd3zfrwg8mvgs07waq2m59"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(home-page "https://github.com/hasufell/bzip2-clib")
|
|
(synopsis "bzip2 C sources.")
|
|
(description
|
|
"Haskell bindings for libarchive. Provides the ability to unpack archives, including the ability to unpack archives lazily.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-bzlib
|
|
(package
|
|
(name "ghc-bzlib")
|
|
(version "0.5.2.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/bzlib/bzlib-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0dlrlzrixgy239kpmn451hffqvvikaydhhsl1vvxpnic0yrvi73i"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(native-inputs (list
|
|
ghc-bzip2-clib
|
|
))
|
|
(home-page "https://github.com/haskell/bzlib")
|
|
(synopsis "Compression and decompression in the bzip2 format")
|
|
(description
|
|
"This package provides a pure interface for compressing and decompressing streams of data represented as lazy ByteStrings. It uses the bz2 C library so it has high performance.
|
|
|
|
It provides a convenient high level API suitable for most tasks and for the few cases where more control is needed it provides access to the full bzip2 feature set.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-cabal
|
|
(package
|
|
(name "ghc-cabal")
|
|
(version "3.14.1.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "Cabal" version))
|
|
(sha256
|
|
(base32 "11grp5spxjmmjcvpszrzlgpv2zkad9l20rfbjd5rvnjp3wa51xan"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "Cabal")))
|
|
(inputs (list ghc-cabal-syntax
|
|
ghc-unix))
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(home-page "http://www.haskell.org/cabal/")
|
|
(synopsis "A framework for packaging Haskell software")
|
|
(description
|
|
"The Haskell Common Architecture for Building Applications and Libraries: a
|
|
framework defining a common interface for authors to more easily build their
|
|
Haskell applications in a portable way. . The Haskell Cabal is part of a larger
|
|
infrastructure for distributing, organizing, and cataloging Haskell libraries
|
|
and tools.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-filepath
|
|
(package
|
|
(name "ghc-filepath")
|
|
(version "1.5.4.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "filepath" version))
|
|
(sha256
|
|
(base32 "1bswvf1hrsslb8xlwvsccz12h5habrdpqq4zgcyjg4zm6b28dajl"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "filepath")))
|
|
(inputs (list ghc-os-string))
|
|
(native-inputs (list ghc-tasty
|
|
ghc-tasty-quickcheck
|
|
ghc-generic-random
|
|
ghc-generic-deriving
|
|
ghc-tasty
|
|
ghc-tasty-quickcheck
|
|
ghc-quickcheck-classes-base
|
|
ghc-tasty
|
|
ghc-tasty-quickcheck))
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(home-page "https://github.com/haskell/filepath/blob/master/README.md")
|
|
(synopsis "Library for manipulating FilePaths in a cross platform way.")
|
|
(description
|
|
"This package provides functionality for manipulating @code{@@FilePath}@@ values,
|
|
and is shipped with <https://www.haskell.org/ghc/ GHC>. It provides two
|
|
variants for filepaths: . 1. legacy filepaths: @@type @code{FilePath} =
|
|
String@@ . 2. operating system abstracted filepaths (@code{@@OsPath}@@):
|
|
internally unpinned @code{@@ShortByteString}@@ (platform-dependent encoding) .
|
|
It is recommended to use @code{@@OsPath}@@ when possible, because it is more
|
|
correct. . For each variant there are three main modules: . *
|
|
\"System.@code{FilePath.Posix}\" / \"System.@code{OsPath.Posix}\" manipulates
|
|
POSIX\\/Linux style @code{@@FilePath}@@ values (with @@\\/@@ as the path
|
|
separator). . * \"System.@code{FilePath.Windows}\" /
|
|
\"System.@code{OsPath.Windows}\" manipulates Windows style @code{@@FilePath}@@
|
|
values (with either @@\\\\@@ or @@\\/@@ as the path separator, and deals with
|
|
drives). . * \"System.@code{FilePath}\" / \"System.@code{OsPath}\" for dealing with
|
|
current platform-specific filepaths . For more powerful string manipulation of
|
|
@code{@@OsPath}@@, you can use the
|
|
<https://hackage.haskell.org/package/os-string os-string package>
|
|
(@code{@@OsPath}@@ is a type synonym for @code{@@OsString}@@). . An
|
|
introduction into the new API can be found in this
|
|
<https://hasufell.github.io/posts/2022-06-29-fixing-haskell-filepaths.html blog
|
|
post>. Code examples for the new API can be found
|
|
<https://github.com/hasufell/filepath-examples here>.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-os-string
|
|
(package
|
|
(name "ghc-os-string")
|
|
(version "2.0.7")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "os-string" version))
|
|
(sha256
|
|
(base32 "186b4swiga0nk05np512iw50pz9w88l3bqz47pr241997bykb71k"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "os-string")))
|
|
(native-inputs (list ghc-quickcheck ghc-quickcheck
|
|
ghc-quickcheck-classes-base))
|
|
(home-page "https://github.com/haskell/os-string/blob/master/README.md")
|
|
(synopsis "Library for manipulating Operating system strings.")
|
|
(description
|
|
"This package provides functionality for manipulating @code{@@OsString}@@ values,
|
|
and is shipped with <https://www.haskell.org/ghc/ GHC>.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-cabal-syntax
|
|
(package
|
|
(name "ghc-cabal-syntax")
|
|
(version "3.14.1.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "Cabal-syntax" version))
|
|
(sha256
|
|
(base32 "13d4sfqlbx2m8f075jnqq965sj0ayn1vk2fd2m8rdp9fsqy8hxm0"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "Cabal-syntax")))
|
|
(native-inputs (list
|
|
ghc-alex
|
|
))
|
|
(home-page "http://www.haskell.org/cabal/")
|
|
(synopsis "A library for working with .cabal files")
|
|
(description
|
|
"This library provides tools for reading and manipulating the .cabal file format.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-chs-deps
|
|
(package
|
|
(name "ghc-chs-deps")
|
|
(version "0.1.0.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/chs-deps/chs-deps-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "0mgi44nvsbmfxj2xr7ja7yslsxvbnznd9xbprz967705nhbs2cqb"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(native-inputs (list
|
|
ghc-alex
|
|
ghc-unix
|
|
ghc-cabal
|
|
ghc-cabal-syntax
|
|
))
|
|
(home-page "https://hub.darcs.net/vmchale/chs-deps")
|
|
(synopsis "c2hs dependency analyzer")
|
|
(description
|
|
"This is a package somewhat like cdeps which scans .chs files for dependencies.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-unix
|
|
(package
|
|
(name "ghc-unix")
|
|
(version "2.8.6.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "unix" version))
|
|
(sha256
|
|
(base32 "18pf0nsqzj4ciwrwbynx7r47aapgbb4gn2kiar31vap4nfdmj5w1"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "unix")))
|
|
(native-inputs (list ghc-tasty
|
|
ghc-tasty-hunit
|
|
ghc-tasty-quickcheck
|
|
ghc-tasty-hunit
|
|
ghc-tasty-hunit
|
|
ghc-tasty
|
|
ghc-tasty-hunit
|
|
ghc-os-string
|
|
ghc-filepath))
|
|
(arguments
|
|
`(#:tests? #f
|
|
#:cabal-revision ("1"
|
|
"0ca08c8wsz4hfq7ajzaba45mxp9wak3x6vv37j63r747gbyqlzsv")))
|
|
|
|
(home-page "https://github.com/haskell/unix")
|
|
(synopsis "POSIX functionality")
|
|
(description
|
|
"This package gives you access to the set of operating system services
|
|
standardised by <http://pubs.opengroup.org/onlinepubs/9699919799/ POSIX.1-2008>
|
|
(or the IEEE Portable Operating System Interface for Computing Environments -
|
|
IEEE Std. 1003.1). . The package is not supported under Windows.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-chs-cabal
|
|
(package
|
|
(name "ghc-chs-cabal")
|
|
(version "0.1.1.4")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (string-append
|
|
"https://hackage.haskell.org/package/chs-cabal/chs-cabal-"
|
|
version
|
|
".tar.gz"))
|
|
(sha256
|
|
(base32 "1y9z3ymvsldl4kjjdzagx0p3i7s5lyrsipd29bx2nqv05ldgrkip"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(native-inputs (list
|
|
ghc-chs-deps
|
|
ghc-unix
|
|
ghc-cabal
|
|
))
|
|
(inputs (list ghc-chs-deps ghc-unix))
|
|
(propagated-inputs (list ghc-unix))
|
|
(home-page "https://github.com/vmchale/libarchive")
|
|
(synopsis "Custom Cabal setup that orders chs dependencies correctly.")
|
|
(description
|
|
"Cabal with c2hs dependencies.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-pipes-safe
|
|
(package
|
|
(name "ghc-pipes-safe")
|
|
(version "2.3.5")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "pipes-safe" version))
|
|
(sha256
|
|
(base32 "13npagy597g6zfr2f3vj4a98h2ssg2ps7lmdzrgdsvm8m28x3cph"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "pipes-safe")))
|
|
(inputs (list ghc-transformers-base ghc-monad-control ghc-primitive
|
|
ghc-pipes))
|
|
(arguments
|
|
`(#:cabal-revision ("3"
|
|
"1wic8km3c17g2xrmxd4qj5qmppb76k7srxrgj8jg1vs6g2l7v6cs")))
|
|
(home-page "http://hackage.haskell.org/package/pipes-safe")
|
|
(synopsis "Safety for the pipes ecosystem")
|
|
(description
|
|
"This package adds resource management and exception handling to the @@pipes@@
|
|
ecosystem. . Notable features include: . * /Resource Safety/: Guarantee
|
|
finalization using @@finally@@, @@bracket@@ and more . * /Exception Safety/:
|
|
Even against asynchronous exceptions! . * /Laziness/: Only acquire resources
|
|
when you need them . * /Promptness/: Finalize resources early when you are done
|
|
with them . * /Native Exception Handling/: Catch and resume from exceptions
|
|
inside pipes . * /No Buy-in/: Mix resource-safe pipes with unmanaged pipes using
|
|
@@hoist@@.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-dirstream
|
|
(package
|
|
(name "ghc-dirstream")
|
|
(version "1.1.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "dirstream" version))
|
|
(sha256
|
|
(base32 "1xnxsx1m06jm8yvim1xnvfkwylhyab51wvba1j3fbicy4ysblfz0"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "dirstream")))
|
|
(inputs (list ghc-system-filepath ghc-system-fileio ghc-pipes
|
|
ghc-pipes-safe))
|
|
(arguments
|
|
`(#:cabal-revision ("2"
|
|
"0k4nzimxqc6a47a16yysh39m4vjy9pbyi3j7lygrnaz780c338kc")))
|
|
(home-page "http://hackage.haskell.org/package/dirstream")
|
|
(synopsis "Easily stream directory contents in constant memory")
|
|
(description
|
|
"Use this library to read large directories as streams: . * Use @code{@@ListT}@@
|
|
to assemble recursive directory traversals while still streaming . * Use
|
|
@@pipes@@ to read out the stream of results . * Traversals only open directory
|
|
streams lazily in response to demand . * Avoid directories with insufficient
|
|
permissions . This library works on both Unix and Windows.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-pipes-parse
|
|
(package
|
|
(name "ghc-pipes-parse")
|
|
(version "3.0.9")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "pipes-parse" version))
|
|
(sha256
|
|
(base32 "05cd0j1avkzmryf3869hfpvd9xmzbpz4kc65srswx36n06dkz5x3"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "pipes-parse")))
|
|
(inputs (list ghc-pipes))
|
|
(arguments
|
|
`(#:cabal-revision ("2"
|
|
"0dil8dqjx4l1d065rcixhbri1j40ppip6kfl22kxgyx96hz0vzfh")))
|
|
(home-page "http://hackage.haskell.org/package/pipes-parse")
|
|
(synopsis "Parsing infrastructure for the pipes ecosystem")
|
|
(description
|
|
"@@pipes-parse@@ builds upon the @@pipes@@ library to provide shared parsing
|
|
idioms and utilities: . * /Leftovers/: Save unused input for later consumption .
|
|
* /Leftover propagation/: Leftovers are propagated backwards perfectly . *
|
|
/Connect and Resume/: Use @code{@@StateT}@@ to save unused input for later . *
|
|
/Termination Safety/: Detect and recover from end of input . @@Pipes.Parse@@
|
|
contains the full documentation for this library. . Read
|
|
@@Pipes.Parse.Tutorial@@ for an extensive tutorial.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
|
|
(define-public ghc-pipes-group
|
|
(package
|
|
(name "ghc-pipes-group")
|
|
(version "1.0.12")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "pipes-group" version))
|
|
(sha256
|
|
(base32 "1issfj3syi6lfbcdn3bhlbnlh86s92ldsb04c4ac69xipsgyhwqk"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "pipes-group")))
|
|
(inputs (list ghc-free ghc-pipes ghc-pipes-parse))
|
|
(native-inputs (list ghc-lens-family-core ghc-doctest))
|
|
(arguments
|
|
`(#:cabal-revision ("9"
|
|
"1i0l182q4gxq29g5w8iv3ywq68dq3gcyhjybfrih0q0cnyz8zxlc")))
|
|
(home-page "http://hackage.haskell.org/package/pipes-group")
|
|
(synopsis "Group streams into substreams")
|
|
(description
|
|
"@@pipes-group@@ uses @code{@@FreeT}@@ and lenses to group streams into
|
|
sub-streams. Notable features include: . * /Perfect Streaming/: Group elements
|
|
without collecting them into memory . * /Lens Support/: Use lenses to simplify
|
|
many common operations . @@Pipes.Group@@ contains the full documentation for
|
|
this library. . Read @@Pipes.Group.Tutorial@@ for an extensive tutorial.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-fusion-plugin-types
|
|
(package
|
|
(name "ghc-fusion-plugin-types")
|
|
(version "0.1.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "fusion-plugin-types" version))
|
|
(sha256
|
|
(base32 "14lzymjna6faiwj7bdm1jrz42jfj3w1wi2hv66mldjhadf45613d"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "fusion-plugin-types")))
|
|
(home-page "https://github.com/composewell/fusion-plugin-types")
|
|
(synopsis "Types for the fusion-plugin package.")
|
|
(description
|
|
"GHC package that provides types that when used in a package can be identified by
|
|
the <https://hackage.haskell.org/package/fusion-plugin fusion-plugin> package to
|
|
perform any extra optimizations.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-heaps
|
|
(package
|
|
(name "ghc-heaps")
|
|
(version "0.4.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "heaps" version))
|
|
(sha256
|
|
(base32 "10h3m98fjj114x3nffs0ajllc6z1dbb4g9804j8kq2rd79ka8qw7"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "heaps")))
|
|
(home-page "http://github.com/ekmett/heaps/")
|
|
(synopsis "Asymptotically optimal Brodal/Okasaki heaps.")
|
|
(description
|
|
"Asymptotically optimal Brodal\\/Okasaki bootstrapped skew-binomial heaps from the
|
|
paper <http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.48.973 \"Optimal
|
|
Purely Functional Priority Queues\">, extended with a Foldable interface.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-streamly-core
|
|
(package
|
|
(name "ghc-streamly-core")
|
|
(version "0.2.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "streamly-core" version))
|
|
(sha256
|
|
(base32 "0397vfjbpcwslik68g7imwv1xf0iyj0blj39v920havzrwni4si2"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "streamly-core")))
|
|
(inputs (list ghc-fusion-plugin-types ghc-heaps ghc-monad-control )) ;; needs packaging
|
|
(home-page "https://streamly.composewell.com")
|
|
(synopsis "Streaming, parsers, arrays, serialization and more")
|
|
(description
|
|
"For upgrading to streamly-0.9.0+ please read the
|
|
<https://github.com/composewell/streamly/blob/streamly-0.10.0/docs/User/Project/Upgrading-0.8-to-0.9.md
|
|
Streamly-0.9.0 upgrade guide>. . Streamly is a standard library for Haskell
|
|
that focuses on C-like performance, modular combinators, and streaming data flow
|
|
model. Streamly consists of two packages: \"streamly-core\" and \"streamly\".
|
|
<https://hackage.haskell.org/package/streamly-core streamly-core> provides basic
|
|
features, and depends only on GHC boot libraries (see note below), while
|
|
<https://hackage.haskell.org/package/streamly streamly> provides higher-level
|
|
features like concurrency, time, lifted exceptions, and networking. For
|
|
documentation, visit the <https://streamly.composewell.com Streamly website>. .
|
|
The streamly-core package provides the following functionality: . * Streams as
|
|
composable producers of a sequence of values. * Streams provide all the
|
|
functionality provided by Haskell lists but in an effectful, streaming fashion
|
|
with better performance. * Streams provide @code{ListT} and logic programming
|
|
functionality as well. * Folds as composable stream consumers that reduce the
|
|
streams to a single value or reduce segments of streams to transform the stream.
|
|
* Parsers as more powerful, composable stream consumers supporting standard
|
|
parser combinators with backtracking but in a streaming fashion. * Arrays with
|
|
streaming interfaces providing high performance, modularity, and concise
|
|
interface as all streaming operations can be performed on arrays. * Arrays can
|
|
be immutable or mutable, unboxed or boxed, pinned or unpinned. * Arrays
|
|
generalize the functionality provided by @@bytestring@@ and @@text@@ packages. *
|
|
Interoperability with @@bytestring@@ and @@text@@ is provided via separate
|
|
packages. * Arrays and folds provide natural builder functionality so there are
|
|
no separate builder modules. * High performance binary serialization with
|
|
configurable JSON like features. * Streaming combinators for unicode text
|
|
processing, providing functionality equivalent to the @@text@@ package. * String
|
|
interpolation for convenient construction of strings. * Streaming console IO
|
|
(stdin/stdout) operations. * Streaming file and directory IO operations. . This
|
|
package covers some or all of the functionality covered by @@streaming, pipes,
|
|
conduit, list-t, logic-t, foldl, attoparsec, array, primitive, vector,
|
|
vector-algorithms, binary, cereal, store, bytestring, text, stringsearch,
|
|
interpolate@@. Streamly provides a consistent, concise, modular and performant
|
|
interface for all this functionality. . Note: The dependencies \"heaps\" and
|
|
\"monad-control\" are included in the package solely for backward compatibility,
|
|
and will be removed in future versions.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-abstract-deque-tests
|
|
(package
|
|
(name "ghc-abstract-deque-tests")
|
|
(version "0.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "abstract-deque-tests" version))
|
|
(sha256
|
|
(base32 "19gb5x5z3nvazdra3skm24c2g2byj0i4cjbzfwfghnb5q96gn5sz"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "abstract-deque-tests")))
|
|
(inputs (list ghc-abstract-deque ghc-random ghc-hunit ghc-test-framework
|
|
ghc-test-framework-hunit))
|
|
(home-page "https://github.com/rrnewton/haskell-lockfree/wiki")
|
|
(synopsis
|
|
"A test-suite for any queue or double-ended queue satisfying an interface")
|
|
(description
|
|
"This package provides tests that can be used with any queue implementation that
|
|
satisfies the `abstract-deque` interface.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-lockfree-queue
|
|
(package
|
|
(name "ghc-lockfree-queue")
|
|
(version "0.2.4")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "lockfree-queue" version))
|
|
(sha256
|
|
(base32 "1vlrydp3ywqgfnhmfm7zhdfn3nrkd7q8lj9apa34y35yvh67gxm0"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "lockfree-queue")))
|
|
(inputs (list ghc-abstract-deque ghc-atomic-primops))
|
|
(native-inputs (list ghc-abstract-deque-tests ghc-hunit ghc-test-framework
|
|
ghc-test-framework-hunit))
|
|
(home-page "https://github.com/rrnewton/haskell-lockfree/wiki")
|
|
(synopsis "Michael and Scott lock-free queues.")
|
|
(description
|
|
"Michael and Scott queues are described in their PODC 1996 paper: .
|
|
<http://dl.acm.org/citation.cfm?id=248052.248106> . These are single-ended
|
|
concurrent queues based on a singlly linked list and using atomic CAS
|
|
instructions to swap the tail pointers. As a well-known efficient algorithm
|
|
they became the basis for Java's @code{@@ConcurrentLinkedQueue}@@.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-streamly
|
|
(package
|
|
(name "ghc-streamly")
|
|
(version "0.10.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "streamly" version))
|
|
(sha256
|
|
(base32 "1iyvrhjlvfww5jmwdfx58pr5xi9jzv5h22g0nvnhgnrnxhm86sxn"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "streamly")))
|
|
(inputs (list ghc-streamly-core
|
|
ghc-hashable
|
|
ghc-unordered-containers
|
|
ghc-heaps
|
|
ghc-atomic-primops
|
|
ghc-lockfree-queue
|
|
ghc-unicode-data
|
|
ghc-network
|
|
ghc-transformers-base
|
|
ghc-monad-control))
|
|
(arguments
|
|
`(#:cabal-revision ("6"
|
|
"0jppiaqj930jcvacikaq2kri1ywj7wdmf3jsb2yi303xwp0z1kf0")))
|
|
(home-page "https://streamly.composewell.com")
|
|
(synopsis "Streaming, dataflow programming and declarative concurrency")
|
|
(description
|
|
"For upgrading to streamly-0.9.0+ please read the
|
|
<https://github.com/composewell/streamly/blob/streamly-0.10.0/docs/User/Project/Upgrading-0.8-to-0.9.md
|
|
Streamly-0.9.0 upgrade guide>. . Streamly is a standard library for Haskell
|
|
that focuses on C-like performance, modular combinators, and streaming data flow
|
|
model. Streamly consists of two packages, the
|
|
<https://hackage.haskell.org/package/streamly-core streamly-core> package
|
|
provides functionality that depends only on boot libraries, and the
|
|
<https://hackage.haskell.org/package/streamly streamly> package provides
|
|
additional functionality like concurrency, time, lifted exceptions, and
|
|
networking. For unified documentation visit <https://streamly.composewell.com
|
|
the streamly website>. . Streamly provides unified, modular building blocks to
|
|
build high-performance, concurrent, scalable applications in Haskell
|
|
. Stream
|
|
fusion optimizations in streamly enable exceptional modularity with high
|
|
performance comparable to C. Streamly complements the Haskell
|
|
<https://hackage.haskell.org/package/base base> package, supplying additional
|
|
functionality to quickly build general-purpose applications in Haskell. For
|
|
high-level functionality built over streamly like streaming OS processes, shell
|
|
programming, GNU coreutils, statistics, and compression libraries please see the
|
|
<https://streamly.composewell.com/ecosystem.html streamly ecosystem packages>. .
|
|
Performance with modularity: . * Performance on par with C
|
|
(<https://github.com/composewell/streaming-benchmarks Benchmarks>) * API close
|
|
to standard Haskell lists (<https://github.com/composewell/streamly-examples
|
|
Examples>) * Declarative concurrency with automatic scaling * Filesystem,
|
|
fsnotify, network, and Unicode support included * Fast binary serialization
|
|
(with optional JSON like features) * More functionality is provided via many
|
|
(<https://streamly.composewell.com/ecosystem.html ecosystem packages>) .
|
|
Unified and powerful abstractions: . * Unifies streams, arrays, folds, and
|
|
parsers * Unifies @@Data.List@@, @@list-t@@, and @@logict@@ with streaming *
|
|
Unifies concurrency with standard streaming abstractions * Unifies reactive,
|
|
time-domain programming with streaming * Unifies binary serialization and
|
|
unboxed arrays * Interworks with other streaming libraries.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
|
|
(define-public ghc-time
|
|
(package
|
|
(name "ghc-time")
|
|
(version "1.12")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "time" version))
|
|
(sha256
|
|
(base32 "0xavlg1lsq0fip6mwvphr4xz2iykys4wsn468hr8qdg6xqab0x0b"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "time")))
|
|
(native-inputs (list ghc-random
|
|
ghc-quickcheck
|
|
ghc-tasty
|
|
ghc-tasty-hunit
|
|
ghc-tasty-quickcheck
|
|
ghc-random
|
|
ghc-quickcheck
|
|
ghc-tasty
|
|
ghc-tasty-hunit
|
|
ghc-tasty-quickcheck
|
|
ghc-random
|
|
ghc-quickcheck
|
|
ghc-tasty
|
|
ghc-tasty-hunit
|
|
ghc-tasty-quickcheck))
|
|
(home-page "https://github.com/haskell/time")
|
|
(synopsis "A time library")
|
|
(description "Time, clocks and calendars.")
|
|
(license #f)))
|
|
|
|
|
|
|
|
(define-public ghc-hint
|
|
(package
|
|
(name "ghc-hint")
|
|
(version "0.9.0.8")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "hint" version))
|
|
(sha256
|
|
(base32 "19xvi3g35983vhvq467d8gxx23zq7zbd4d6awh2ijb84vgbff7zf"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "hint")))
|
|
(inputs (list ghc-paths ghc-random ghc-temporary))
|
|
(native-inputs (list ghc-hunit ghc-typed-process))
|
|
(arguments
|
|
`(#:cabal-revision ("2"
|
|
"0d89mkqxknwd0aq6zh64hqjvvdkwax7qn6jiv6a2np1gr6d89w4w")
|
|
#:tests? #f))
|
|
(home-page "https://github.com/haskell-hint/hint")
|
|
(synopsis "A Haskell interpreter built on top of the GHC API")
|
|
(description
|
|
"This library defines an Interpreter monad. It allows to load Haskell modules,
|
|
browse them, type-check and evaluate strings with Haskell expressions and even
|
|
coerce them into values. The library is thread-safe and type-safe (even the
|
|
coercion of expressions to values). It is, essentially, a huge subset of the
|
|
GHC API wrapped in a simpler API.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-quickcheck
|
|
(package
|
|
(name "ghc-quickcheck")
|
|
(version "2.16.0.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "QuickCheck" version))
|
|
(sha256
|
|
(base32 "1h02m26hvhfcs82rrfmfznwh4vj799gn55kysmv3sr8ixak3ymhb"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "QuickCheck")))
|
|
(inputs (list ghc-random ghc-splitmix ghc-data-array-byte))
|
|
(native-inputs (list ghc-split ghc-hint))
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(home-page "https://github.com/nick8325/quickcheck")
|
|
(synopsis "Automatic testing of Haskell programs")
|
|
(description
|
|
"@code{QuickCheck} is a library for random testing of program properties. The
|
|
programmer provides a specification of the program, in the form of properties
|
|
which functions should satisfy, and @code{QuickCheck} then tests that the
|
|
properties hold in a large number of randomly generated cases. Specifications
|
|
are expressed in Haskell, using combinators provided by @code{QuickCheck}.
|
|
@code{QuickCheck} provides combinators to define properties, observe the
|
|
distribution of test data, and define test data generators. . Most of
|
|
@code{QuickCheck's} functionality is exported by the main
|
|
\"Test.@code{QuickCheck}\" module. The main exception is the monadic property
|
|
testing library in \"Test.@code{QuickCheck.Monadic}\". . If you are new to
|
|
@code{QuickCheck}, you can try looking at the following resources: . * The
|
|
<http://www.cse.chalmers.se/~rjmh/@code{QuickCheck/manual.html} official
|
|
@code{QuickCheck} manual>. It's a bit out-of-date in some details and doesn't
|
|
cover newer @code{QuickCheck} features, but is still full of good advice. *
|
|
<https://begriffs.com/posts/2017-01-14-design-use-quickcheck.html>, a detailed
|
|
tutorial written by a user of @code{QuickCheck}. . The
|
|
<https://hackage.haskell.org/package/quickcheck-instances quickcheck-instances>
|
|
companion package provides instances for types in Haskell Platform packages at
|
|
the cost of additional dependencies.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-primitive
|
|
(package
|
|
(name "ghc-primitive")
|
|
(version "0.7.3.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "primitive" version))
|
|
(sha256
|
|
(base32 "1p01fmw8yi578rvwicrlpbfkbfsv7fbnzb88a7vggrhygykgs31w"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "primitive")))
|
|
(inputs (list ghc-data-array-byte))
|
|
(native-inputs (list ghc-base-orphans
|
|
ghc-quickcheck-classes-base
|
|
ghc-quickcheck
|
|
ghc-tasty
|
|
ghc-tasty-quickcheck
|
|
ghc-tagged
|
|
ghc-transformers-compat))
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(home-page "https://github.com/haskell/primitive")
|
|
(synopsis "Primitive memory-related operations")
|
|
(description
|
|
"This package provides various primitive memory-related operations.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
|
|
(define-public ghc-tasty
|
|
(package
|
|
(name "ghc-tasty")
|
|
(version "1.5.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "tasty" version))
|
|
(sha256
|
|
(base32 "10076vlklbcyiz7plakrihava5sy3dvwhskjldqzhfl18jvcg82l"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "tasty")))
|
|
(inputs (list ghc-tagged ghc-optparse-applicative ghc-ansi-terminal))
|
|
(arguments
|
|
`(#:cabal-revision ("2"
|
|
"04llcf1i3gawdik0bjhxdgls2wkiqlx0gi76nfh784nv2qzxlpbb")))
|
|
(home-page "https://github.com/UnkindPartition/tasty")
|
|
(synopsis "Modern and extensible testing framework")
|
|
(description
|
|
"Tasty is a modern testing framework for Haskell. It lets you combine your unit
|
|
tests, golden tests, @code{QuickCheck/SmallCheck} properties, and any other
|
|
types of tests into a single test suite.")
|
|
(license license:expat)))
|
|
|
|
|
|
(define-public ghc-tasty-hunit
|
|
(package
|
|
(name "ghc-tasty-hunit")
|
|
(version "0.10.2")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "tasty-hunit" version))
|
|
(sha256
|
|
(base32 "1xh33ss7dncm7zanzkzh7ywb3a46k7vkcbh6v8jb767gq6kizw2s"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "tasty-hunit")))
|
|
(inputs (list ghc-tasty ghc-call-stack))
|
|
(home-page "https://github.com/UnkindPartition/tasty")
|
|
(synopsis "HUnit support for the Tasty test framework.")
|
|
(description
|
|
"HUnit support for the Tasty test framework. . Note that this package does not
|
|
depend on HUnit but implements the relevant subset of its API. The name is a
|
|
legacy of the early versions of tasty-hunit and of test-framework-hunit, which
|
|
did depend on HUnit.")
|
|
(license license:expat)))
|
|
|
|
|
|
(define-public ghc-tasty-quickcheck
|
|
(package
|
|
(name "ghc-tasty-quickcheck")
|
|
(version "0.11.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "tasty-quickcheck" version))
|
|
(sha256
|
|
(base32 "0si4ccgqlv8h33d6310rrqba7f4pz3g8cinqfj42yd7damsdxm73"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "tasty-quickcheck")))
|
|
(inputs (list ghc-tagged ghc-tasty ghc-random ghc-quickcheck
|
|
ghc-optparse-applicative))
|
|
(native-inputs (list ghc-regex-tdfa ghc-tasty-hunit))
|
|
(arguments
|
|
`(#:cabal-revision ("4"
|
|
"13sn5bwvw04d7l3xv6mkj8mf6wyvhqqhabdqnb4xchzcc48akdxz")))
|
|
(home-page "https://github.com/UnkindPartition/tasty")
|
|
(synopsis "QuickCheck support for the Tasty test framework.")
|
|
(description "@code{QuickCheck} support for the Tasty test framework. .")
|
|
(license license:expat)))
|
|
|
|
|
|
|
|
(define-public ghc-megaparsec
|
|
(package
|
|
(name "ghc-megaparsec")
|
|
(version "9.7.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "megaparsec" version))
|
|
(sha256
|
|
(base32 "15zc66lplq5382wayigcw9kql08nvp9403a8f9xaw85z4lv45vdr"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "megaparsec")))
|
|
(inputs (list ghc-case-insensitive ghc-parser-combinators ghc-scientific ))
|
|
(home-page "https://github.com/mrkkrp/megaparsec")
|
|
(synopsis "Monadic parser combinators")
|
|
(description
|
|
"This is an industrial-strength monadic parser combinator library. Megaparsec is
|
|
a feature-rich package that tries to find a nice balance between speed,
|
|
flexibility, and quality of parse errors.")
|
|
(license #f)))
|
|
|
|
(define-public ghc-hspec-expectations
|
|
(package
|
|
(name "ghc-hspec-expectations")
|
|
(version "0.8.4")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "hspec-expectations" version))
|
|
(sha256
|
|
(base32 "1zr1pqchcwglfr5dvcrgc1l5x924n9w09n2zr68dmkqf4dzdx3bv"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "hspec-expectations")))
|
|
(inputs (list ghc-hunit ghc-call-stack))
|
|
(native-inputs (list ghc-nanospec))
|
|
(arguments
|
|
`(#:cabal-revision ("2"
|
|
"14zzsjqcz1zbnvi50i82lx84nc8b5da7ar5cazzh44lklyag0ds2")))
|
|
(home-page "https://github.com/hspec/hspec-expectations#readme")
|
|
(synopsis "Catchy combinators for HUnit")
|
|
(description "Catchy combinators for HUnit:
|
|
<https://github.com/hspec/hspec-expectations#readme>.")
|
|
(license license:expat)))
|
|
|
|
|
|
|
|
(define-public ghc-hspec-meta
|
|
(package
|
|
(name "ghc-hspec-meta")
|
|
(version "2.11.14")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "hspec-meta" version))
|
|
(sha256
|
|
(base32 "1mi1sfmxqf01dxkw8c56ywiclnl1pk6m5g1cj53w3mq8j7mywqz5"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "hspec-meta")))
|
|
(inputs (list ghc-hunit
|
|
ghc-quickcheck
|
|
ghc-ansi-terminal
|
|
ghc-call-stack
|
|
ghc-haskell-lexer
|
|
ghc-hspec-expectations
|
|
ghc-quickcheck-io
|
|
ghc-random
|
|
ghc-tf-random))
|
|
(arguments
|
|
`(#:cabal-revision ("2"
|
|
"0iylscmcm5052sqa3xaikiqrlfaqs9cn82r777g43l6wgbzzsxi4")))
|
|
(home-page "https://hspec.github.io/")
|
|
(synopsis "A version of Hspec which is used to test Hspec itself")
|
|
(description
|
|
"This package provides a stable version of Hspec which is used to test the
|
|
in-development version of Hspec.")
|
|
(license license:expat)))
|
|
|
|
|
|
|
|
(define-public ghc-hspec-core
|
|
(package
|
|
(name "ghc-hspec-core")
|
|
(version "2.11.14")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "hspec-core" version))
|
|
(sha256
|
|
(base32 "0hnbvcjkylims4xcmajhmwaicnalgi5a93ayk47gvc5z02pgs299"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "hspec-core")))
|
|
(inputs (list ghc-hunit
|
|
ghc-quickcheck
|
|
ghc-ansi-terminal
|
|
ghc-call-stack
|
|
ghc-haskell-lexer
|
|
ghc-hspec-expectations
|
|
ghc-quickcheck-io
|
|
ghc-random
|
|
ghc-tf-random))
|
|
(native-inputs (list ghc-base-orphans ghc-hspec-meta ghc-silently
|
|
ghc-temporary))
|
|
(arguments
|
|
`(#:cabal-revision ("1"
|
|
"0s41xy88mkbxhbf93gdxb23vxr4vaip58519j2c8slz6cmvs0mq5")
|
|
#:tests? #f))
|
|
(home-page "https://hspec.github.io/")
|
|
(synopsis "A Testing Framework for Haskell")
|
|
(description
|
|
"This package exposes internal types and functions that can be used to extend
|
|
Hspec's functionality.")
|
|
(license license:expat)))
|
|
|
|
|
|
(define-public ghc-sha
|
|
(package
|
|
(name "ghc-sha")
|
|
(version "1.6.4.4")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "SHA" version))
|
|
(sha256
|
|
(base32 "0i4b2wjisivdy72synal711ywhx05mfqfba5n65rk8qidggm1nbb"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "SHA")))
|
|
(native-inputs (list ghc-quickcheck ghc-test-framework
|
|
ghc-test-framework-quickcheck2))
|
|
(arguments
|
|
'(#:tests? #f))
|
|
(home-page "http://hackage.haskell.org/package/SHA")
|
|
(synopsis "Implementations of the 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 @code{OpenSSL}.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
(define-public ghc-th-lift
|
|
(package
|
|
(name "ghc-th-lift")
|
|
(version "0.8.6")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "th-lift" version))
|
|
(sha256
|
|
(base32 "07zgl42fq7ijmm29x7q10iv02hk6lqs7snysxdad03pq1vbrlc04"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "th-lift")))
|
|
(inputs (list ghc-th-abstraction))
|
|
(home-page "http://github.com/RyanGlScott/th-lift")
|
|
(synopsis "Derive Template Haskell's Lift class for datatypes.")
|
|
(description
|
|
"Derive Template Haskell's @@Lift@@ class for datatypes using
|
|
@code{@@TemplateHaskell}@@. The functionality in this package has largely been
|
|
subsumed by the @code{@@DeriveLift}@@ language extension, which is available in
|
|
GHC 8.0 and later versions. As such, this package is only useful as a way to
|
|
backport bugfixes to @code{@@DeriveLift}@@ in later GHC versions back to older
|
|
GHCs. . The following libraries are related: . * The
|
|
<https://hackage.haskell.org/package/th-orphans th-orphans> package provides
|
|
instances for @@template-haskell@@ syntax types. . * The
|
|
<http://hackage.haskell.org/package/th-lift-instances th-lift-instances> package
|
|
provides @@Lift@@ instances for types in @@base@@, @@text@@, @@bytestring@@,
|
|
@@vector@@, etc. Some of these instances are only provided for old versions of
|
|
their respective libraries, as the same @@Lift@@ instances are also present
|
|
upstream on newer versions.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
|
|
(define-public ghc-th-reify-many
|
|
(package
|
|
(name "ghc-th-reify-many")
|
|
(version "0.1.10")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "th-reify-many" version))
|
|
(sha256
|
|
(base32 "19g4gc1q3zxbylmvrgk3dqjzychq2k02i7fwvs3vhbrg4ihhw9cx"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "th-reify-many")))
|
|
(inputs (list ghc-safe 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 license:bsd-3)))
|
|
|
|
|
|
|
|
(define-public ghc-th-abstraction
|
|
(package
|
|
(name "ghc-th-abstraction")
|
|
(version "0.7.1.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "th-abstraction" version))
|
|
(sha256
|
|
(base32 "1i843j7lhq6qly9zknrw3nhb17ac3badmxwn1pfn2sscp951idpr"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "th-abstraction")))
|
|
(arguments
|
|
`(#:cabal-revision ("1"
|
|
"1n2gpcajn2sm8zw5ibkjwvhd3k1m0lvvjrixwcq0c1xhhlyl049h")))
|
|
(home-page "https://github.com/glguy/th-abstraction")
|
|
(synopsis "Nicer interface for reified information about data types")
|
|
(description
|
|
"This package normalizes variations in the interface for inspecting datatype
|
|
information via Template Haskell so that packages and support a single, easier
|
|
to use informational datatype while supporting many versions of Template
|
|
Haskell.")
|
|
(license license:isc)))
|
|
|
|
|
|
(define-public ghc-th-orphans
|
|
(package
|
|
(name "ghc-th-orphans")
|
|
(version "0.13.16")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "th-orphans" version))
|
|
(sha256
|
|
(base32 "04x95fwsiczbi4gxadnnz6z39hy72hsj1smfaa52ljhwh8sh3479"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "th-orphans")))
|
|
(inputs (list ghc-th-compat ghc-th-lift ghc-th-reify-many))
|
|
(native-inputs (list ghc-hspec))
|
|
(home-page "http://hackage.haskell.org/package/th-orphans")
|
|
(synopsis "Orphan instances for TH datatypes")
|
|
(description
|
|
"Orphan instances for TH datatypes. In particular, instances for Ord and Lift,
|
|
as well as a few missing Show / Eq. These instances used to live in
|
|
haskell-src-meta, and that's where the version number started.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-th-utilities
|
|
(package
|
|
(name "ghc-th-utilities")
|
|
(version "0.2.5.2")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "th-utilities" version))
|
|
(sha256
|
|
(base32 "1n4fwnfk05jzbl6f6vrms0jmvzc61x0gqqrip9hgsjgzyla72qln"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "th-utilities")))
|
|
(inputs (list ghc-primitive ghc-syb ghc-th-abstraction ghc-th-orphans))
|
|
(native-inputs (list ghc-hspec ghc-th-lift ghc-vector ghc-hspec-discover))
|
|
(home-page "https://github.com/fpco/th-utilities#readme")
|
|
(synopsis "Collection of useful functions for use with Template Haskell")
|
|
(description
|
|
"This package lacks a description. Run \"info '(guix) Synopses and Descriptions'\" for more information.")
|
|
(license license:expat)))
|
|
|
|
|
|
(define-public ghc-store-core
|
|
(package
|
|
(name "ghc-store-core")
|
|
(version "0.4.4.7")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "store-core" version))
|
|
(sha256
|
|
(base32 "1lxwl6zlmmdk62c35dwmx4xpcfvjx61is8ccmnr8i01i9l9i19b4"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "store-core")))
|
|
(inputs (list ghc-primitive))
|
|
(home-page "https://github.com/fpco/store#readme")
|
|
(synopsis "Fast and lightweight binary serialization")
|
|
(description
|
|
"This package lacks a description. Run \"info '(guix) Synopses and Descriptions'\" for more information.")
|
|
(license license:expat)))
|
|
|
|
|
|
(define-public ghc-smallcheck
|
|
(package
|
|
(name "ghc-smallcheck")
|
|
(version "1.1.1")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "smallcheck" version))
|
|
(sha256
|
|
(base32 "1ygrabxh40bym3grnzqyfqn96lirnxspb8cmwkkr213239y605sd"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "smallcheck")))
|
|
(inputs (list ghc-logict
|
|
ghc-hspec-core))
|
|
(native-inputs (list ghc-hspec ghc-quickcheck ghc-base-orphans ghc-hspec ghc-hspec-core))
|
|
(home-page "https://github.com/Bodigrim/smallcheck")
|
|
(synopsis "A property-based testing library")
|
|
(description
|
|
"As of 2023, this library is largely obsolete: arbitrary test generators with
|
|
shrinking such as [falsify](https://hackage.haskell.org/package/falsify) offer
|
|
much better user experience. . @code{SmallCheck} is a testing library that
|
|
allows to verify properties for all test cases up to some depth. The test cases
|
|
are generated automatically by @code{SmallCheck}.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-hspec-smallcheck
|
|
(package
|
|
(name "ghc-hspec-smallcheck")
|
|
(version "0.5.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "hspec-smallcheck" version))
|
|
(sha256
|
|
(base32 "0cjhmhpdll3zg3cy1alqghw86msgafi9b67w5vhd73w7wi5hm0gm"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "hspec-smallcheck")))
|
|
(inputs (list ghc-hunit
|
|
ghc-call-stack
|
|
ghc-hspec-core
|
|
ghc-smallcheck
|
|
ghc-hspec-core))
|
|
(native-inputs (list ghc-hspec ghc-quickcheck ghc-base-orphans ghc-hspec ghc-hspec-core ghc-hspec-discover))
|
|
(arguments
|
|
`(#:tests? #f))
|
|
(home-page "http://hspec.github.io/")
|
|
(synopsis "SmallCheck support for the Hspec testing framework")
|
|
(description "@code{SmallCheck} support for the Hspec testing framework.")
|
|
(license license:expat)))
|
|
|
|
|
|
(define-public ghc-cryptohash-sha1
|
|
(package
|
|
(name "ghc-cryptohash-sha1")
|
|
(version "0.11.101.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "cryptohash-sha1" version))
|
|
(sha256
|
|
(base32 "0h9jl9v38gj0vnscqx7xdklk634p05fa6z2pcvknisq2mnbjq154"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "cryptohash-sha1")))
|
|
(native-inputs (list ghc-base16-bytestring ghc-sha ghc-tasty
|
|
ghc-tasty-quickcheck ghc-tasty-hunit))
|
|
(arguments
|
|
`(#:cabal-revision ("6"
|
|
"1cxdw2y10z4v0mz91wki7f233jziipx85j4qy5msig4nv3djkprb")))
|
|
(home-page "https://github.com/haskell-hvr/cryptohash-sha1")
|
|
(synopsis "Fast, pure and practical SHA-1 implementation")
|
|
(description
|
|
"This package provides a practical incremental and one-pass, pure API to the
|
|
<https://en.wikipedia.org/wiki/SHA-1 SHA-1 hash algorithm> (including
|
|
<https://en.wikipedia.org/wiki/HMAC HMAC> support) with performance close to the
|
|
fastest implementations available in other languages. . The implementation is
|
|
made in C with a haskell FFI wrapper that hides the C implementation. . NOTE:
|
|
This package has been forked off @@cryptohash-0.11.7@@ because the
|
|
@@cryptohash@@ package has been deprecated and so this package continues to
|
|
satisfy the need for a lightweight package providing the SHA1 hash algorithm
|
|
without any dependencies on packages other than @@base@@ and @@bytestring@@. .
|
|
Consequently, this package can be used as a drop-in replacement for
|
|
@@cryptohash@@'s \"Crypto.Hash.SHA1\" module, though with a clearly smaller
|
|
footprint.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
|
|
(define-public ghc-ascii-progress
|
|
(package
|
|
(name "ghc-ascii-progress")
|
|
(version "0.3.3.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "ascii-progress" version))
|
|
(sha256
|
|
(base32 "0glixkmqk7zz4g88sfrqfrdxd4na0krlwr50m2dkra091jwacgvy"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "ascii-progress")))
|
|
(inputs (list ghc-concurrent-output
|
|
ghc-async
|
|
ghc-data-default
|
|
ghc-hspec-discover))
|
|
(native-inputs (list ghc-hspec ghc-quickcheck))
|
|
(home-page "https://github.com/yamadapc/haskell-ascii-progress")
|
|
(synopsis "A simple progress bar for the console.")
|
|
(description
|
|
"This package provides a simple Haskell progress bar for the console. Heavily
|
|
borrows from TJ Holowaychuk's Node.JS project
|
|
<https://github.com/tj/node-progress progress> .
|
|
<https://github.com/yamadapc/haskell-ascii-progress github>.")
|
|
(license license:expat)))
|
|
|
|
|
|
|
|
(define-public ghc-rest-rewrite
|
|
(package
|
|
(name "ghc-rest-rewrite")
|
|
(version "0.4.5") ;; needs to be like this
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "rest-rewrite" version))
|
|
(sha256
|
|
(base32 "0yxg3wfwxcrg036cxqcf601vfc5472vx9zwl21y23kpx031h7ny4"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "rest-rewrite")))
|
|
(inputs (list ghc-hashable
|
|
ghc-time
|
|
ghc-unordered-containers
|
|
ghc-quickcheck
|
|
ghc-monad-loops
|
|
z3))
|
|
(native-inputs (list
|
|
z3
|
|
graphviz))
|
|
(arguments
|
|
`(#:cabal-revision ("1"
|
|
"15n4xgrrcxrm8wkxhi9vw1imdx1y7wifbm8l6p0b5sqp995h86fb")
|
|
#:haddock? #f))
|
|
(home-page "http://hackage.haskell.org/package/rest-rewrite")
|
|
(synopsis "Rewriting library with online termination checking")
|
|
(description
|
|
"REST is a Rewriting library with online termination checking. For more details
|
|
see the paper at https://arxiv.org/abs/2202.05872.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
|
|
(define-public ghc-lens-family
|
|
(package
|
|
(name "ghc-lens-family")
|
|
(version "2.1.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "lens-family" version))
|
|
(sha256
|
|
(base32 "04r5xcypy3vzn3chs9xwmq5gdxk5z5z84qiggkkbz32k6g1b808q"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "lens-family")))
|
|
(inputs (list ghc-lens-family-core))
|
|
(home-page "http://hackage.haskell.org/package/lens-family")
|
|
(synopsis "Lens Families")
|
|
(description
|
|
"This package provides first class functional references in Van Laarhoven style
|
|
supporting the following optics: . * Lenses (view, over) . * Traversals
|
|
(@code{toListOf}, matching, over) . * Setters (over) . * Grates
|
|
(@code{zipWithOf}, under, review) . * Resetters (under) . * Adapters (view,
|
|
review) . * Grids (@code{toListOf}, over / under, review) . * Prisms (matching,
|
|
over / under, review) . * Getters (view) . * Folders (@code{toListOf}) . *
|
|
Reviewers (review).")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
|
|
(define-public ghc-smtlib-backends-tests
|
|
(package
|
|
(name "ghc-smtlib-backends-tests")
|
|
(version "0.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "smtlib-backends-tests" version))
|
|
(sha256
|
|
(base32 "0lj4bpl4nkw6w2hfjzz16zmrbaj5g3myvbmzlsc5rdsz0xwisfb8"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "smtlib-backends-tests")))
|
|
(inputs (list ghc-smtlib-backends ghc-tasty ghc-tasty-hunit))
|
|
(arguments
|
|
`(#:cabal-revision ("5"
|
|
"1frvbpr40dyp2rj2b1hj34f7lfjdb8a3kvbl447gzrqaqapvlya1")))
|
|
(home-page "http://hackage.haskell.org/package/smtlib-backends-tests")
|
|
(synopsis "Testing SMT-LIB backends.")
|
|
(description
|
|
"This library provides common functions and values used for testing SMT-LIB
|
|
backends, as provided by the smtlib-backends library.")
|
|
(license license:expat)))
|
|
|
|
|
|
(define-public ghc-smtlib-backends-process
|
|
(package
|
|
(name "ghc-smtlib-backends-process")
|
|
(version "0.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "smtlib-backends-process" version))
|
|
(sha256
|
|
(base32 "0jc7fmf3x53w8v0a8cj8v8r2f4gpn1jhndl80hyqzsblvrw5hcfg"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "smtlib-backends-process")))
|
|
(inputs (list ghc-smtlib-backends))
|
|
(native-inputs (list ghc-async
|
|
ghc-smtlib-backends-tests
|
|
ghc-tasty
|
|
ghc-tasty-hunit
|
|
z3))
|
|
(arguments
|
|
`(#:cabal-revision ("5"
|
|
"01rz1vbnh3r50lzvlz6qk9vlfxhz013nnbzyr846yy7kxgl2mp8w")))
|
|
(home-page "http://hackage.haskell.org/package/smtlib-backends-process")
|
|
(synopsis "An SMT-LIB backend running solvers as external processes.")
|
|
(description
|
|
"This library implements an SMT-LIB backend (in the sense of the smtlib-backends
|
|
package) which runs solvers as external processes.")
|
|
(license license:expat)))
|
|
|
|
|
|
|
|
(define-public ghc-smtlib-backends
|
|
(package
|
|
(name "ghc-smtlib-backends")
|
|
(version "0.4")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "smtlib-backends" version))
|
|
(sha256
|
|
(base32 "16n2ig71wjqp1ziplwrq3639fqn582ymx5g9ls7f814ddjgc70xg"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "smtlib-backends")))
|
|
(arguments
|
|
`(#:cabal-revision ("2"
|
|
"0w883nmycnfb3y7vhpiak7fz8aasa7hvg6wxy6w3g0whr35zwqm6")))
|
|
(home-page "http://hackage.haskell.org/package/smtlib-backends")
|
|
(synopsis
|
|
"Low-level functions for SMT-LIB-based interaction with SMT solvers.")
|
|
(description
|
|
"This library provides an extensible interface for interacting with SMT solvers
|
|
using SMT-LIB. The smtlib-backends-process package provides a backend that runs
|
|
solvers as external processes, and the smtlib-backends-z3 package provides a
|
|
backend that uses inlined calls to Z3's C API.")
|
|
(license license:expat)))
|
|
|
|
(define-public ghc-intern
|
|
(package
|
|
(name "ghc-intern")
|
|
(version "0.9.6")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "intern" version))
|
|
(sha256
|
|
(base32 "1jinr6z1azzz0fsbp0fs5jjzln33qq8r67c63z30nw5kfh6kxjcf"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "intern")))
|
|
(inputs (list ghc-hashable ghc-unordered-containers))
|
|
(home-page "http://github.com/ekmett/intern/")
|
|
(synopsis "Efficient hash-consing for arbitrary data types")
|
|
(description "Efficient hash-consing for arbitrary data types.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-store
|
|
(package
|
|
(name "ghc-store")
|
|
(version "0.7.20")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "store" version))
|
|
(sha256
|
|
(base32 "1ysp87fhqxw2rlcbhfba1z08j8ml7gq1a1ic6dcl5mdyxxmqywr0"))))
|
|
(build-system haskell-build-system)
|
|
(arguments
|
|
`(#:tests? #f))
|
|
(properties '((upstream-name . "store")))
|
|
(inputs (list ghc-async
|
|
ghc-base-orphans
|
|
ghc-base64-bytestring
|
|
ghc-bifunctors
|
|
ghc-contravariant
|
|
ghc-cryptohash-sha1
|
|
ghc-free
|
|
ghc-hashable
|
|
ghc-hspec
|
|
ghc-hspec-smallcheck
|
|
ghc-lifted-base
|
|
ghc-monad-control
|
|
ghc-mono-traversable
|
|
ghc-nats
|
|
ghc-network
|
|
ghc-primitive
|
|
ghc-resourcet
|
|
ghc-safe
|
|
ghc-smallcheck
|
|
ghc-store-core
|
|
ghc-syb
|
|
ghc-th-lift
|
|
ghc-th-lift-instances
|
|
ghc-th-orphans
|
|
ghc-th-reify-many
|
|
ghc-th-utilities
|
|
ghc-unordered-containers
|
|
ghc-vector
|
|
ghc-void
|
|
hspec-discover))
|
|
(native-inputs (list ghc-clock hspec-discover))
|
|
(home-page "https://github.com/mgsloan/store#readme")
|
|
(synopsis "Fast binary serialization")
|
|
(description
|
|
"This package lacks a description. Run \"info '(guix) Synopses and Descriptions'\" for more information.")
|
|
(license license:expat)))
|
|
|
|
|
|
|
|
(define-public ghc-recursion-schemes
|
|
(package
|
|
(name "ghc-recursion-schemes")
|
|
(version "5.2.3")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "recursion-schemes" version))
|
|
(sha256
|
|
(base32 "020fk7s4dzim3957h8447mi3jp95k25zrac86dcaavldxjy88kiv"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "recursion-schemes")))
|
|
(inputs (list ghc-comonad ghc-data-fix ghc-free ghc-th-abstraction))
|
|
(native-inputs (list ghc-hunit))
|
|
(arguments
|
|
`(#:cabal-revision ("1"
|
|
"0la8md7lv8awhvsyw30mqbyfjvskvndcm9446wnh4bhjhi0813li")))
|
|
(home-page "http://github.com/ekmett/recursion-schemes/")
|
|
(synopsis
|
|
"Representing common recursion patterns as higher-order functions")
|
|
(description
|
|
"Many recursive functions share the same structure, e.g. pattern-match on the
|
|
input and, depending on the data constructor, either recur on a smaller input or
|
|
terminate the recursion with the base case. Another one: start with a seed
|
|
value, use it to produce the first element of an infinite list, and recur on a
|
|
modified seed in order to produce the rest of the list. Such a structure is
|
|
called a recursion scheme. Using higher-order functions to implement those
|
|
recursion schemes makes your code clearer, faster, and safer. See README for
|
|
details.")
|
|
(license license:bsd-2)))
|
|
|
|
|
|
(define-public ghc-liquid-fixpoint
|
|
(package
|
|
(name "ghc-liquid-fixpoint")
|
|
(version "0.9.2.5")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "liquid-fixpoint" version))
|
|
(sha256
|
|
(base32 "0i9487xz1cfmn3nv58wlm685ljvqq1iqfyz1rkx549wa5h4zmdjq"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "liquid-fixpoint")))
|
|
(inputs (list ghc-ansi-terminal
|
|
ghc-async
|
|
ghc-attoparsec
|
|
ghc-store
|
|
ghc-boxes
|
|
ghc-cereal
|
|
ghc-cmdargs
|
|
ghc-fgl
|
|
ghc-hashable
|
|
ghc-intern
|
|
ghc-parallel
|
|
ghc-parser-combinators
|
|
ghc-typed-process
|
|
ghc-megaparsec
|
|
ghc-syb
|
|
ghc-smtlib-backends
|
|
ghc-smtlib-backends-process
|
|
ghc-lens-family
|
|
ghc-intern
|
|
ghc-transformers
|
|
ghc-unordered-containers
|
|
ghc-aeson
|
|
ghc-rest-rewrite
|
|
ghc-ascii-progress))
|
|
(native-inputs (list ghc-tasty
|
|
ghc-tasty-ant-xml
|
|
ghc-tasty-hunit
|
|
ghc-tasty-hunit
|
|
ghc-tasty-rerun
|
|
ghc-tasty
|
|
ghc-tasty-quickcheck
|
|
ghc-typed-process
|
|
ghc-tasty-hunit))
|
|
(arguments
|
|
`(#:tests? #f))
|
|
(home-page "https://github.com/ucsd-progsys/liquid-fixpoint")
|
|
(synopsis
|
|
"Predicate Abstraction-based Horn-Clause/Implication Constraint Solver")
|
|
(description
|
|
"This package implements an SMTLIB based Horn-Clause\\/Logical Implication
|
|
constraint solver used for Liquid Types. . The package includes: . 1. Types
|
|
for Expressions, Predicates, Constraints, Solutions 2. Code for solving
|
|
constraints . Requirements . In addition to the .cabal dependencies you
|
|
require . * A Z3 (<http://z3.codeplex.com>) or CVC4 (<http://cvc4.cs.nyu.edu>)
|
|
binary.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-liquidhaskell-boot
|
|
(package
|
|
(name "ghc-liquidhaskell-boot")
|
|
(version "0.9.2.8.0") ;; updated version
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "liquidhaskell-boot" version))
|
|
(sha256
|
|
(base32 "0q1rknlqi4x9gpkl9yvrzxfkbkcs6m883dhpvlymqpvsp2qs22b1"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "liquidhaskell-boot")))
|
|
(inputs (list ghc-diff
|
|
ghc-aeson
|
|
ghc-cereal
|
|
ghc-cmdargs
|
|
ghc-fingertree
|
|
ghc-gitrev
|
|
ghc-hashable
|
|
ghc-hscolour
|
|
ghc-liquid-fixpoint
|
|
ghc-optparse-applicative
|
|
ghc-githash
|
|
ghc-megaparsec
|
|
ghc-split
|
|
ghc-syb
|
|
ghc-th-compat
|
|
ghc-temporary
|
|
ghc-unordered-containers
|
|
ghc-recursion-schemes
|
|
ghc-vector
|
|
ghc-free
|
|
ghc-extra
|
|
ghc-9.2))
|
|
(native-inputs (list ghc-tasty
|
|
ghc-tasty-ant-xml
|
|
ghc-tasty-hunit
|
|
ghc-recursion-schemes
|
|
ghc-paths
|
|
ghc-9.2))
|
|
(arguments
|
|
`(#:tests? #f))
|
|
(home-page "https://github.com/ucsd-progsys/liquidhaskell")
|
|
(synopsis "Liquid Types for Haskell")
|
|
(description
|
|
"This package provides a plugin to verify Haskell programs. But most likely you
|
|
should be using the [liquidhaskell
|
|
package](https://hackage.haskell.org/package/liquidhaskell) instead, which
|
|
rexports this plugin together with necessary specifications for definitions in
|
|
the boot libraries.")
|
|
(license license:bsd-3)))
|
|
|
|
(define-public ghc-liquidhaskell
|
|
(package
|
|
(name "ghc-liquidhaskell")
|
|
(version "0.9.2.8.0")
|
|
(source
|
|
(origin
|
|
(method url-fetch)
|
|
(uri (hackage-uri "liquidhaskell" version))
|
|
(sha256
|
|
(base32 "1n4dkahiaci6j502w5ksqpb1g7v8rwf3hbhqqprjmcc6cl5ppyzn"))))
|
|
(build-system haskell-build-system)
|
|
(properties '((upstream-name . "liquidhaskell")))
|
|
(inputs (list ghc-liquidhaskell-boot z3))
|
|
(native-inputs (list z3))
|
|
(home-page "https://github.com/ucsd-progsys/liquidhaskell")
|
|
(synopsis "Liquid Types for Haskell")
|
|
(description "Liquid Types for Haskell.")
|
|
(license license:bsd-3)))
|
|
|
|
|
|
ghc-liquidhaskell
|