* bug#35754: guix build silent failure for unterminated string
@ 2019-05-15 16:14 Robert Vollmert
0 siblings, 0 replies; only message in thread
From: Robert Vollmert @ 2019-05-15 16:14 UTC (permalink / raw)
To: 35754
[-- Attachment #1: Type: text/plain, Size: 254 bytes --]
I suspect this had to do with the size of the file, but I’m not really sure what was going on.
$ guix build -f postgrest.scm
$ echo $?
1
The unterminated string is within the definition of `ghc-string-conversions`, line 1169. File attached.
[-- Attachment #2: postgrest.scm --]
[-- Type: application/octet-stream, Size: 97158 bytes --]
(use-modules (gnu)
(guix)
(guix git-download)
(guix build-system haskell)
(guix licenses)
(guix packages))
(use-package-modules haskell haskell-check haskell-crypto haskell-web databases)
(define-public ghc-base-compat
(package
(name "ghc-base-compat")
(version "0.10.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/base-compat/base-compat-"
version
".tar.gz"))
(sha256
(base32
"0hgvlqcr852hfp52jp99snhbj550mvxxpi8qn15d8ml9aqhyl2lr"))))
(build-system haskell-build-system)
(home-page
"http://hackage.haskell.org/package/base-compat")
(synopsis "A compatibility layer for base")
(description
"Provides functions available in later versions of @base@ to a wider range of compilers, without requiring you to use CPP pragmas in your code. See the <https://github.com/haskell-compat/base-compat/blob/master/base-compat/README.markdown README> for what is covered. Also see the <https://github.com/haskell-compat/base-compat/blob/master/base-compat/CHANGES.markdown changelog> for recent changes. . Note that @base-compat@ does not add any orphan instances. There is a separate package, @<http://hackage.haskell.org/package/base-orphans base-orphans>@, for that. . In addition, @base-compat@ does not backport any data types or type classes. See @<https://github.com/haskell-compat/base-compat/blob/master/base-compat/README.markdown#data-types-and-type-classes this section of the README>@ for more info. . @base-compat@ is designed to have zero dependencies. For a version of @base-compat@ that depends on compatibility libraries for a wider support window, see the @<http://hackage.haskell.org/package/base-compat-batteries base-compat-batteries>@ package. Most of the modules in this library have the same names as in @base-compat-batteries@ to make it easier to switch between the two. There also exist versions of each module with the suffix @.Repl@, which are distinct from anything in @base-compat-batteries@, to allow for easier use in GHCi.")
(license expat)))
(define-public ghc-mtl
(package
(name "ghc-mtl")
(version "2.2.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/mtl/mtl-"
version
".tar.gz"))
(sha256
(base32
"1xmy5741h8cyy0d91ahvqdz2hykkk20l8br7lg1rccnkis5g80w8"))))
(build-system haskell-build-system)
(home-page "http://github.com/haskell/mtl")
(synopsis
"Monad classes, using functional dependencies")
(description
"Monad classes using functional dependencies, with instances for various monad transformers, inspired by the paper /Functional Programming with Overloading and Higher-Order Polymorphism/, by Mark P Jones, in /Advanced School of Functional Programming/, 1995 (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).")
(license bsd-3)))
(define-public ghc-mtl-compat
(package
(name "ghc-mtl-compat")
(version "0.2.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/mtl-compat/mtl-compat-"
version
".tar.gz"))
(sha256
(base32
"17iszr5yb4f17g8mq6i74hsamii8z6m2qfsmgzs78mhiwa7kjm8r"))))
(build-system haskell-build-system)
(arguments `(#:haddock? #f))
(inputs `(("ghc-mtl" ,ghc-mtl)))
(home-page
"https://github.com/haskell-compat/mtl-compat")
(synopsis
"Backported Control.Monad.Except module from mtl")
(description
"This package backports the \"Control.Monad.Except\" module from @mtl@ (if using @mtl-2.2.0.1@ or earlier), which reexports the @ExceptT@ monad transformer and the @MonadError@ class. . This package should only be used if there is a need to use the @Control.Monad.Except@ module specifically. If you just want the @mtl@ class instances for @ExceptT@, use @transformers-compat@ instead, since @mtl-compat@ does nothing but reexport the instances from that package. . Note that unlike how @mtl-2.2@ or later works, the \"Control.Monad.Except\" module defined in this package exports all of @ExceptT@'s monad class instances. Therefore, you may have to declare @import Control.Monad.Except ()@ at the top of your file to get all of the @ExceptT@ instances in scope.")
(license bsd-3)))
(define-public ghc-array
(package
(name "ghc-array")
(version "0.5.3.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/array/array-"
version
".tar.gz"))
(sha256
(base32
"07pyr2x09n23rdxldqgbx12hlg9dk92q9p56bpcdw3r87ajc3m9z"))))
(build-system haskell-build-system)
(home-page
"http://hackage.haskell.org/package/array")
(synopsis "Mutable and immutable arrays")
(description
"In addition to providing the \"Data.Array\" module <http://www.haskell.org/onlinereport/haskell2010/haskellch14.html as specified in the Haskell 2010 Language Report>, this package also defines the classes 'IArray' of immutable arrays and 'MArray' of arrays mutable within appropriate monads, as well as some instances of these classes.")
(license bsd-3)))
(define-public ghc-only
(package
(name "ghc-only")
(version "0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/Only/Only-"
version
".tar.gz"))
(sha256
(base32
"0rdj3a629fk2vp121jq8mf2smkblrz5w3cxhlsyx6my2x29s2ymb"))))
(build-system haskell-build-system)
(home-page
"http://hackage.haskell.org/package/Only")
(synopsis
"The 1-tuple type or single-value \"collection\"")
(description
"This package provides a canonical anonymous 1-tuple type missing from Haskell for attaching typeclass instances. . NOTE: There is also the </package/OneTuple OneTuple package> which by using a boxed @data@-type provides a 1-tuple type which has laziness properties which are more faithful to the ones of Haskell's native tuples; whereas the primary purpose of 'Only' is to provide the traditionally so named type-wrapper for attaching typeclass instances.")
(license bsd-3)))
(define-public ghc-quickcheck-2.10.1
(package
(name "ghc-quickcheck")
(version "2.10.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/QuickCheck/QuickCheck-"
version
".tar.gz"))
(sha256
(base32
"1rfmns3lj3hl93k1jws85ajkkw7z9ll8cw292n9m7zald1w5dfqx"))))
(build-system haskell-build-system)
(inputs
`(("ghc-random" ,ghc-random)
("ghc-tf-random" ,ghc-tf-random)))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page
"https://github.com/nick8325/quickcheck")
(synopsis
"Automatic testing of Haskell programs")
(description
"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 QuickCheck then tests that the properties hold in a large number of randomly generated cases. . Specifications are expressed in Haskell, using combinators defined in the QuickCheck library. QuickCheck provides combinators to define properties, observe the distribution of test data, and define test data generators. . The <http://www.cse.chalmers.se/~rjmh/QuickCheck/manual.html official QuickCheck manual> explains how to write generators and properties; it is out-of-date in some details but still full of useful advice. . A user of QuickCheck has written an unofficial, but detailed, tutorial which you can find at <https://begriffs.com/posts/2017-01-14-design-use-quickcheck.html>.")
(license bsd-3)))
(define-public ghc-bytestring
(package
(name "ghc-bytestring")
(version "0.10.8.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/bytestring/bytestring-"
version
".tar.gz"))
(sha256
(base32
"0fjc5ybxx67l0kh27l6vq4saf88hp1wnssj5ka90ii588y76cvys"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f))
(native-inputs
`(("ghc-random" ,ghc-random)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-quickcheck2"
,ghc-test-framework-quickcheck2)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-random" ,ghc-random)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit"
,ghc-test-framework-hunit)
("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-byteorder" ,ghc-byteorder)
("ghc-dlist" ,ghc-dlist)
("ghc-mtl" ,ghc-mtl)
("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit"
,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2"
,ghc-test-framework-quickcheck2)))
(home-page
"https://github.com/haskell/bytestring")
(synopsis
"Fast, compact, strict and lazy byte strings with a list interface")
(description
"An efficient compact, immutable byte string type (both strict and lazy) suitable for binary or 8-bit character data. . The 'ByteString' type represents sequences of bytes or 8-bit characters. It is suitable for high performance use, both in terms of large data quantities, or high speed requirements. The 'ByteString' functions follow the same style as Haskell\\'s ordinary lists, so it is easy to convert code from using 'String' to 'ByteString'. . Two 'ByteString' variants are provided: . * Strict 'ByteString's keep the string as a single large array. This makes them convenient for passing data between C and Haskell. . * Lazy 'ByteString's use a lazy list of strict chunks which makes it suitable for I\\/O streaming tasks. . The @Char8@ modules provide a character-based view of the same underlying 'ByteString' types. This makes it convenient to handle mixed binary and 8-bit character content (which is common in many file formats and network protocols). . The 'Builder' module provides an efficient way to build up 'ByteString's in an ad-hoc way by repeated concatenation. This is ideal for fast serialisation or pretty printing. . There is also a 'ShortByteString' type which has a lower memory overhead and can can be converted to or from a 'ByteString', but supports very few other operations. It is suitable for keeping many short strings in memory. . 'ByteString's are not designed for Unicode. For Unicode strings you should use the 'Text' type from the @text@ package. . These modules are intended to be imported qualified, to avoid name clashes with \"Prelude\" functions, e.g. . > import qualified Data.ByteString as BS")
(license bsd-3)))
(define-public ghc-bytestring-builder
(package
(name "ghc-bytestring-builder")
(version "0.10.8.2.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/bytestring-builder/bytestring-builder-"
version
".tar.gz"))
(sha256
(base32
"0grcrgwwwcvwrs9az7l4d3kf0lsqfa9qpmjzf6iyanvwn9nyzyi7"))))
(build-system haskell-build-system)
(arguments `(#:haddock? #f))
(home-page
"http://hackage.haskell.org/package/bytestring-builder")
(synopsis
"The new bytestring builder, packaged outside of GHC")
(description
"This is the bytestring builder that is debuting in bytestring-0.10.4.0, which should be shipping with GHC 7.8, probably late in 2013. This builder has several nice simplifications and improvements, and more out-of-box functionality than the older blaze-builder. . Note that this package detects which version of bytestring you are compiling against, and if you are compiling against bytestring-0.10.4 or later, will be an empty package. . This package lets the new interface and implementation be used with most older compilers without upgrading bytestring, which can be rather problematic. In conjunction with blaze-builder-0.4 or later, which offers an implementation of blaze-builder in terms of bytestring-builder, this should let most people try the new interface and implementation without causing undue compatibility problems with packages that depend on blaze-builder. . GHC 7.6 did debut an almost identical interface and implementation, but with slightly different module names and organization. Trying to re-export/rename the builder provided with 7.6 did not turn out to be very practical, because this interface includes new functions that rely on Builder internals, which are not exported in 7.6. Furthermore, these module names should be deprecated in 7.10.")
(license bsd-3)))
(define-public ghc-text-short
(package
(name "ghc-text-short")
(version "0.1.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/text-short/text-short-"
version
".tar.gz"))
(sha256
(base32
"0rqiwgjkgyfy8596swl0s0x2jqk6ddh2h02qxa32az2cs5kviwmk"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f))
(inputs
`(("ghc-hashable" ,ghc-hashable)
("ghc-text" ,ghc-text)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-quickcheck-instances"
,ghc-quickcheck-instances)))
(home-page
"http://hackage.haskell.org/package/text-short")
(synopsis
"Memory-efficient representation of Unicode text strings")
(description
"This package provides the 'ShortText' type which is suitable for keeping many short strings in memory. This is similiar to how 'ShortByteString' relates to 'ByteString'. . The main difference between 'Text' and 'ShortText' is that 'ShortText' uses UTF-8 instead of UTF-16 internally and also doesn't support zero-copy slicing (thereby saving 2 words). Consequently, the memory footprint of a (boxed) 'ShortText' value is 4 words (2 words when unboxed) plus the length of the UTF-8 encoded payload.")
(license bsd-3)))
(define-public ghc-cassava
(package
(name "ghc-cassava")
(version "0.5.1.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/cassava/cassava-"
version
".tar.gz"))
(sha256
(base32
"0xs2c5lpy0g5lsmp2cx0dm5lnxij7cgry6xd5gsn3bfdlap8lb3n"))))
(build-system haskell-build-system)
(arguments `(#:configure-flags '("--flags=-bytestring--LT-0_10_4")
#:tests? #f))
(inputs
`(("ghc-array" ,ghc-array)
("ghc-attoparsec" ,ghc-attoparsec)
;("ghc-base" ,ghc-base)
("ghc-bytestring" ,ghc-bytestring)
;("ghc-containers" ,ghc-containers)
;("ghc-deepseq" ,ghc-deepseq)
("ghc-hashable" ,ghc-hashable)
("ghc-scientific" ,ghc-scientific)
("ghc-text" ,ghc-text)
("ghc-text-short" ,ghc-text-short)
("ghc-unordered-containers" ,ghc-unordered-containers)
("ghc-vector" ,ghc-vector)
("ghc-only" ,ghc-only)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck@2.10.1" ,ghc-quickcheck-2.10.1)
("ghc-quickcheck-instances" ,ghc-quickcheck-instances)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit" ,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2" ,ghc-test-framework-quickcheck2)))
(home-page "https:github.com/hvr/cassava")
(synopsis "A CSV parsing and encoding library")
(description
"cassava is a library for parsing and encoding RFC4180 compliant comma-separated values (CSV) data, which is a textual line-oriented format commonly used for exchanging tabular data.")
(license expat)))
(define-public ghc-configurator-ng
(package
(name "ghc-configurator-ng")
(version "0.0.0.2")
(source
(origin
(method git-fetch)
(uri
(git-reference
(url "https://github.com/robx/configurator-ng.git")
(commit "v0.0.0.2")))
(sha256
(base32
"0igg86agw9i8f88gn3v0xli8k73xmi9s6spi5zlkmzi2ra458q9k"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f))
(inputs
`(("ghc-attoparsec" ,ghc-attoparsec)
("ghc-critbit" ,ghc-critbit)
("ghc-dlist" ,ghc-dlist)
("ghc-data-ordlist" ,ghc-data-ordlist)
("ghc-fail" ,ghc-fail)
("ghc-hashable" ,ghc-hashable)
("ghc-scientific" ,ghc-scientific)
("ghc-text" ,ghc-text)
("ghc-unix-compat" ,ghc-unix-compat)
("ghc-unordered-containers"
,ghc-unordered-containers)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit"
,ghc-test-framework-hunit)))
(home-page
"http://github.com/lpsmith/configurator-ng")
(synopsis
"The next generation of configuration management")
(description
"A configuration management library for programs and daemons. . Features include: . * A simple, but flexible, configuration language, supporting several of the most commonly needed types of data, along with interpolation of strings from the configuration or the system environment (e.g. @$(HOME)@). . * An @import@ directive allows the configuration of a complex application to be split across several smaller files, or common configuration data to be shared across several applications. . * An expressive applicative/monadic high-level parsing interface to gracefully scale to more complicated configuration needs, with powerful diagnostic messaging mechanism. . For details of the configuration file format, see <http://hackage.haskell.org/packages/archive/configurator/latest/doc/html/Data-Configurator.html>.")
(license bsd-3)))
(define-public ghc-hasql
(package
(name "ghc-hasql")
(version "1.3.0.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/hasql/hasql-"
version
".tar.gz"))
(sha256
(base32
"0qs2x4gbaffrxndivb4237vxc6qrzn2rs5kbf04n4d6py9cdhbjv"))))
(build-system haskell-build-system)
(inputs
`(("ghc-attoparsec" ,ghc-attoparsec)
("ghc-postgresql-binary" ,ghc-postgresql-binary)
("ghc-postgresql-libpq" ,ghc-postgresql-libpq)
("ghc-bytestring-strict-builder"
,ghc-bytestring-strict-builder)
("ghc-dlist" ,ghc-dlist)
("ghc-vector" ,ghc-vector)
("ghc-hashtables" ,ghc-hashtables)
("ghc-text" ,ghc-text)
("ghc-text-builder" ,ghc-text-builder)
("ghc-hashable" ,ghc-hashable)
("ghc-data-default-class"
,ghc-data-default-class)
("ghc-profunctors" ,ghc-profunctors)
("ghc-contravariant-extras"
,ghc-contravariant-extras)
("ghc-contravariant" ,ghc-contravariant)
("ghc-mtl" ,ghc-mtl)
("ghc-loch-th" ,ghc-loch-th)
("ghc-placeholders" ,ghc-placeholders)
("ghc-base-prelude" ,ghc-base-prelude)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-quickcheck-instances"
,ghc-quickcheck-instances)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-rerebase" ,ghc-rerebase)
("ghc-rebase" ,ghc-rebase)
("ghc-bug" ,ghc-bug)
("ghc-rerebase" ,ghc-rerebase)))
(home-page
"https://github.com/nikita-volkov/hasql")
(synopsis
"An efficient PostgreSQL driver and a flexible mapping API")
(description
"This package is the root of the \\\"hasql\\\" ecosystem. . The API comes free from all kinds of exceptions. All error-reporting is explicit and is presented using the 'Either' type.")
(license expat)))
(define-public ghc-hasql-pool
(package
(name "ghc-hasql-pool")
(version "0.5.0.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/hasql-pool/hasql-pool-"
version
".tar.gz"))
(sha256
(base32
"12289a6xn7gn58s8009bwcjffvr5ipycyb2ixzkxbigaxjbprar4"))))
(build-system haskell-build-system)
(inputs
`(("ghc-resource-pool" ,ghc-resource-pool)
("ghc-hasql" ,ghc-hasql)
("ghc-base-prelude" ,ghc-base-prelude)))
(native-inputs `(("ghc-hspec" ,ghc-hspec)))
(home-page
"https://github.com/nikita-volkov/hasql-pool")
(synopsis "A pool of connections for Hasql")
(description "")
(license expat)))
(define-public ghc-hasql-transaction
(package
(name "ghc-hasql-transaction")
(version "0.7.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/hasql-transaction/hasql-transaction-"
version
".tar.gz"))
(sha256
(base32
"02isgjzx3dhp5a7zgz2pbvm6fwmgbnwbqz7k01argf4pawckb8s9"))))
(build-system haskell-build-system)
(inputs
`(("ghc-bytestring-tree-builder"
,ghc-bytestring-tree-builder)
("ghc-contravariant" ,ghc-contravariant)
("ghc-contravariant-extras"
,ghc-contravariant-extras)
("ghc-hasql" ,ghc-hasql)
("ghc-mtl" ,ghc-mtl)))
(native-inputs
`(("ghc-async" ,ghc-async)
("ghc-rebase" ,ghc-rebase)))
(home-page
"https://github.com/nikita-volkov/hasql-transaction")
(synopsis
"A composable abstraction over the retryable transactions for Hasql")
(description "")
(license expat)))
(define-public ghc-heredoc
(package
(name "ghc-heredoc")
(version "0.2.0.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/heredoc/heredoc-"
version
".tar.gz"))
(sha256
(base32
"0h0g2f7yscwl1ba1yn3jnz2drvd6ns9m910hwlmq3kdq3k39y3f9"))))
(build-system haskell-build-system)
(home-page
"http://hackage.haskell.org/package/heredoc")
(synopsis
"multi-line string / here document using QuasiQuotes")
(description
"multi-line string / here document using QuasiQuotes")
(license #f)))
(define-public ghc-insert-ordered-containers
(package
(name "ghc-insert-ordered-containers")
(version "0.2.1.0-git")
(source
(origin
(method git-fetch)
(uri
(git-reference
(url "https://github.com/phadej/insert-ordered-containers.git")
(commit "2637782a07dfdd681cfbe1c1b172c53f8485c7eb")))
(sha256
(base32
"0igg86agw9i8f88gn3v0xli8k73xmi9s6spi5zlkmzi2ra458q9k"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f))
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-base-compat" ,ghc-base-compat)
("ghc-hashable" ,ghc-hashable)
("ghc-lens" ,ghc-lens)
("ghc-semigroupoids" ,ghc-semigroupoids)
("ghc-semigroups" ,ghc-semigroups)
("ghc-text" ,ghc-text)
("ghc-unordered-containers"
,ghc-unordered-containers)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page
"https://github.com/phadej/insert-ordered-containers#readme")
(synopsis
"Associative containers retaining insertion order for traversals.")
(description
"Associative containers retaining insertion order for traversals. . The implementation is based on `unordered-containers`.")
(license bsd-3)))
(define-public ghc-interpolatedstring-perl6
(package
(name "ghc-interpolatedstring-perl6")
(version "1.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/interpolatedstring-perl6/interpolatedstring-perl6-"
version
".tar.gz"))
(sha256
(base32
"0n3j6qvzp6as5ji93rn0sy873w5hdsplik51lkrah42cl95vmbay"))))
(build-system haskell-build-system)
(inputs
`(("ghc-haskell-src-meta" ,ghc-haskell-src-meta)
("ghc-text" ,ghc-text)))
(home-page
"http://hackage.haskell.org/package/interpolatedstring-perl6")
(synopsis
"QuasiQuoter for Perl6-style multi-line interpolated strings")
(description
"QuasiQuoter for Perl6-style multi-line interpolated strings with \\\"q\\\", \\\"qq\\\" and \\\"qc\\\" support.")
(license #f)))
(define-public ghc-jose
(package
(name "ghc-jose")
(version "0.8.0.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/jose/jose-"
version
".tar.gz"))
(sha256
(base32
"027698xq5l8in420x3sc5zqwp16i1jzjcy8rlh546j8acxcvrqc4"))))
(build-system haskell-build-system)
(inputs
`(("ghc-attoparsec" ,ghc-attoparsec)
("ghc-base64-bytestring" ,ghc-base64-bytestring)
("ghc-concise" ,ghc-concise)
("ghc-cryptonite" ,ghc-cryptonite)
("ghc-lens" ,ghc-lens)
("ghc-memory" ,ghc-memory)
("ghc-monad-time" ,ghc-monad-time)
("ghc-mtl" ,ghc-mtl)
("ghc-semigroups" ,ghc-semigroups)
("ghc-safe" ,ghc-safe)
("ghc-aeson" ,ghc-aeson)
("ghc-unordered-containers"
,ghc-unordered-containers)
("ghc-text" ,ghc-text)
("ghc-network-uri" ,ghc-network-uri)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-quickcheck-instances"
,ghc-quickcheck-instances)
("ghc-x509" ,ghc-x509)
("ghc-vector" ,ghc-vector)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hspec" ,ghc-tasty-hspec)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-hspec" ,ghc-hspec)))
(home-page
"https://github.com/frasertweedale/hs-jose")
(synopsis
"Javascript Object Signing and Encryption and JSON Web Token library")
(description
". An implementation of the Javascript Object Signing and Encryption (JOSE) and JSON Web Token (JWT; RFC 7519) formats. . The JSON Web Signature (JWS; RFC 7515) implementation is complete. . EdDSA signatures (RFC 8037) are supported (Ed25519 only). . JWK Thumbprint (RFC 7638) is supported (requires /aeson/ >= 0.10). . JSON Web Encryption (JWE; RFC 7516) is not yet implemented. . The __ECDSA implementation is vulnerable to timing attacks__ and should only be used for verification.")
(license asl2.0)))
(define-public ghc-lens-aeson
(package
(name "ghc-lens-aeson")
(version "1.0.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/lens-aeson/lens-aeson-"
version
".tar.gz"))
(sha256
(base32
"1k028ycmhz7mnjlrap88fqix4nmmpyy6b88m16kv77d3r8sz04a3"))))
(build-system haskell-build-system)
(arguments
`(#:tests? #f
#:cabal-revision
("6" "1pg5v8fnlqw1krgi3d2a03a0zkjjdv5yp5f5z6q4mlb5jldz99a8")))
(inputs
`(("ghc-lens" ,ghc-lens)
("ghc-text" ,ghc-text)
("ghc-vector" ,ghc-vector)
("ghc-unordered-containers"
,ghc-unordered-containers)
("ghc-attoparsec" ,ghc-attoparsec)
("ghc-aeson" ,ghc-aeson)
("ghc-scientific" ,ghc-scientific)))
;(native-inputs
; `(("ghc-doctest" ,ghc-doctest)
; ("ghc-generic-deriving" ,ghc-generic-deriving)
; ("ghc-semigroups" ,ghc-semigroups)
; ("ghc-simple-reflect" ,ghc-simple-reflect)
; ("ghc-cabal-doctest" ,ghc-cabal-doctest)))
(home-page "http://github.com/lens/lens-aeson/")
(synopsis "Law-abiding lenses for aeson")
(description "Law-abiding lenses for aeson")
(license expat)))
(define-public ghc-postgrest
(package
(name "ghc-postgrest")
(version "5.2.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/postgrest/postgrest-"
version
".tar.gz"))
(sha256
(base32
"0h4167jr0k398paf2sgnxkm4iziqf3a9i61cbh7d0ix86z2v8a53"))))
(build-system haskell-build-system)
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-ansi-wl-pprint" ,ghc-ansi-wl-pprint)
("ghc-base64-bytestring" ,ghc-base64-bytestring)
("ghc-case-insensitive" ,ghc-case-insensitive)
("ghc-cassava" ,ghc-cassava)
("ghc-configurator-ng" ,ghc-configurator-ng)
("ghc-contravariant" ,ghc-contravariant)
("ghc-contravariant-extras"
,ghc-contravariant-extras)
("ghc-either" ,ghc-either)
("ghc-gitrev" ,ghc-gitrev)
("ghc-hasql" ,ghc-hasql)
("ghc-hasql-pool" ,ghc-hasql-pool)
("ghc-hasql-transaction" ,ghc-hasql-transaction)
("ghc-heredoc" ,ghc-heredoc)
("ghc-http" ,ghc-http)
("ghc-http-types" ,ghc-http-types)
("ghc-insert-ordered-containers"
,ghc-insert-ordered-containers)
("ghc-interpolatedstring-perl6"
,ghc-interpolatedstring-perl6)
("ghc-jose" ,ghc-jose)
("ghc-lens" ,ghc-lens)
("ghc-lens-aeson" ,ghc-lens-aeson)
("ghc-network-uri" ,ghc-network-uri)
("ghc-optparse-applicative"
,ghc-optparse-applicative)
("ghc-parsec" ,ghc-parsec)
("ghc-protolude" ,ghc-protolude)
("ghc-ranged-sets" ,ghc-ranged-sets)
("ghc-regex-tdfa" ,ghc-regex-tdfa)
("ghc-scientific" ,ghc-scientific)
("ghc-swagger2" ,ghc-swagger2)
("ghc-text" ,ghc-text)
("ghc-unordered-containers"
,ghc-unordered-containers)
("ghc-vector" ,ghc-vector)
("ghc-wai" ,ghc-wai)
("ghc-wai-cors" ,ghc-wai-cors)
("ghc-wai-extra" ,ghc-wai-extra)
("ghc-wai-middleware-static"
,ghc-wai-middleware-static)
("ghc-cookie" ,ghc-cookie)
("ghc-auto-update" ,ghc-auto-update)
("ghc-warp" ,ghc-warp)
("ghc-retry" ,ghc-retry)))
(native-inputs
`(("ghc-aeson-qq" ,ghc-aeson-qq)
("ghc-async" ,ghc-async)
("ghc-hjsonschema" ,ghc-hjsonschema)
("ghc-hspec" ,ghc-hspec)
("ghc-hspec-wai" ,ghc-hspec-wai)
("ghc-hspec-wai-json" ,ghc-hspec-wai-json)
("ghc-monad-control" ,ghc-monad-control)
("ghc-transformers-base" ,ghc-transformers-base)))
(home-page "https://postgrest.org")
(synopsis "REST API for any Postgres database")
(description
"Reads the schema of a PostgreSQL database and creates RESTful routes for the tables and views, supporting all HTTP verbs that security permits.")
(license expat)))
(define-public ghc-protolude
(package
(name "ghc-protolude")
(version "0.2.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/protolude/protolude-"
version
".tar.gz"))
(sha256
(base32
"0zzkyxz0vmcbncpid7gp72fpjj0fla3gqhlfkij5c5lg12skjgfj"))))
(build-system haskell-build-system)
(inputs
`(("ghc-async" ,ghc-async)
("ghc-hashable" ,ghc-hashable)
("ghc-text" ,ghc-text)
("ghc-stm" ,ghc-stm)
("ghc-mtl" ,ghc-mtl)
("ghc-mtl-compat" ,ghc-mtl-compat)
("ghc-transformers-compat"
,ghc-transformers-compat)))
(home-page "https://github.com/sdiehl/protolude")
(synopsis "A small prelude.")
(description
"A sensible set of defaults for writing custom Preludes.")
(license expat)))
(define-public ghc-ranged-sets
(package
(name "ghc-ranged-sets")
(version "0.4.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/Ranged-sets/Ranged-sets-"
version
".tar.gz"))
(sha256
(base32
"1skd2a6yw7dd5vq8x81kwh28gi8sgyzg9qqqyadxmgpvy11sh9ab"))))
(build-system haskell-build-system)
(inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page
"https://github.com/PaulJohnson/Ranged-sets")
(synopsis "Ranged sets for Haskell")
(description
"A ranged set is an ordered list of ranges. This allows sets such as all reals x such that: . > (0.25 < x <= 0.75 or 1.4 <= x < 2.3 or 4.5 < x) . Alternatively you can have all strings s such that: . > (\"F\" <= s < \"G\")")
(license bsd-3)))
(define-public ghc-swagger2
(package
(name "ghc-swagger2")
(version "2.3.1.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/swagger2/swagger2-"
version
".tar.gz"))
(sha256
(base32
"19fslhjqcnk0da1c8sdflnnxjzbbzqb0nbknpgyd45q0psxr6xs7"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f))
(inputs
`(("ghc-mtl" ,ghc-mtl)
("ghc-text" ,ghc-text)
("ghc-base-compat-batteries"
,ghc-base-compat-batteries)
("ghc-aeson" ,ghc-aeson)
("ghc-cookie" ,ghc-cookie)
("ghc-generics-sop" ,ghc-generics-sop)
("ghc-hashable" ,ghc-hashable)
("ghc-http-media" ,ghc-http-media)
("ghc-insert-ordered-containers"
,ghc-insert-ordered-containers)
("ghc-lens" ,ghc-lens)
("ghc-network" ,ghc-network)
("ghc-scientific" ,ghc-scientific)
("ghc-transformers-compat"
,ghc-transformers-compat)
("ghc-unordered-containers"
,ghc-unordered-containers)
("ghc-uuid-types" ,ghc-uuid-types)
("ghc-vector" ,ghc-vector)
("ghc-quickcheck" ,ghc-quickcheck)))
;(native-inputs
; `(("ghc-hspec" ,ghc-hspec)
; ("ghc-hunit" ,ghc-hunit)
; ("ghc-quickcheck-instances"
; ,ghc-quickcheck-instances)
; ("ghc-utf8-string" ,ghc-utf8-string)
; ("ghc-doctest" ,ghc-doctest)
; ("ghc-glob" ,ghc-glob)
; ("ghc-cabal-doctest" ,ghc-cabal-doctest)))
(home-page
"https://github.com/GetShopTV/swagger2")
(synopsis "Swagger 2.0 data model")
(description
"This library is intended to be used for decoding and encoding Swagger 2.0 API specifications as well as manipulating them. . The original Swagger 2.0 specification is available at http://swagger.io/specification/.")
(license bsd-3)))
(define-public ghc-wai-cors
(package
(name "ghc-wai-cors")
(version "0.2.6")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/wai-cors/wai-cors-"
version
".tar.gz"))
(sha256
(base32
"11m9d8hn9pb9brprz0kglldmcqj83kjkjdwdpxdbl12430ii1ina"))))
(build-system haskell-build-system)
(inputs
`(("ghc-attoparsec" ,ghc-attoparsec)
("ghc-base-unicode-symbols"
,ghc-base-unicode-symbols)
("ghc-case-insensitive" ,ghc-case-insensitive)
("ghc-http-types" ,ghc-http-types)
("ghc-wai" ,ghc-wai)
("ghc-mtl" ,ghc-mtl)))
(native-inputs
`(("ghc-network" ,ghc-network)
("ghc-text" ,ghc-text)
("ghc-wai-websockets" ,ghc-wai-websockets)
("ghc-warp" ,ghc-warp)
("ghc-websockets" ,ghc-websockets)
("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-wai-extra" ,ghc-wai-extra)
("ghc-wai-websockets" ,ghc-wai-websockets)
("ghc-warp" ,ghc-warp)
("ghc-websockets" ,ghc-websockets)))
(home-page
"https://github.com/larskuhtz/wai-cors")
(synopsis "CORS for WAI")
(description
"This package provides an implemenation of Cross-Origin resource sharing (CORS) for <http://hackage.haskell.org/package/wai Wai> that aims to be compliant with <http://www.w3.org/TR/cors>.")
(license expat)))
(define-public ghc-wai-middleware-static
(package
(name "ghc-wai-middleware-static")
(version "0.8.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/wai-middleware-static/wai-middleware-static-"
version
".tar.gz"))
(sha256
(base32
"1z5yapcf8j9w71f2na30snmalsajlyi8an2f9qrjdmajabyykr0b"))))
(build-system haskell-build-system)
(inputs
`(("ghc-cryptonite" ,ghc-cryptonite)
("ghc-memory" ,ghc-memory)
("ghc-expiring-cache-map"
,ghc-expiring-cache-map)
("ghc-http-types" ,ghc-http-types)
("ghc-mime-types" ,ghc-mime-types)
("ghc-mtl" ,ghc-mtl)
("ghc-old-locale" ,ghc-old-locale)
("ghc-semigroups" ,ghc-semigroups)
("ghc-text" ,ghc-text)
("ghc-wai" ,ghc-wai)))
(home-page
"https://github.com/scotty-web/wai-middleware-static")
(synopsis
"WAI middleware that serves requests to static files.")
(description
"WAI middleware that intercepts requests to static files and serves them if they exist. . [WAI] <http://hackage.haskell.org/package/wai>")
(license bsd-3)))
(define-public ghc-retry
(package
(name "ghc-retry")
(version "0.8.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/retry/retry-"
version
".tar.gz"))
(sha256
(base32
"0x63grjv0r96gv8ksh6r6aja6fvnwr06bypigvkskzhjjbk3fhcx"))))
(build-system haskell-build-system)
(inputs
`(("ghc-exceptions" ,ghc-exceptions)
("ghc-random" ,ghc-random)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-tasty-hedgehog" ,ghc-tasty-hedgehog)
("ghc-hedgehog" ,ghc-hedgehog)
("ghc-stm" ,ghc-stm)
("ghc-mtl" ,ghc-mtl)))
(home-page "http://github.com/Soostone/retry")
(synopsis
"Retry combinators for monadic actions that may fail")
(description
"This package exposes combinators that can wrap arbitrary monadic actions. They run the action and potentially retry running it with some configurable delay for a configurable number of times. The purpose is to make it easier to work with IO and especially network IO actions that often experience temporary failure and warrant retrying of the original action. For example, a database query may time out for a while, in which case we should hang back for a bit and retry the query instead of simply raising an exception.")
(license bsd-3)))
(define-public ghc-hjsonschema
(package
(name "ghc-hjsonschema")
(version "1.9.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/hjsonschema/hjsonschema-"
version
".tar.gz"))
(sha256
(base32
"051i5y557g82hd5zcn63f65jyxk07d9wnvfmwdps391zxza8ifki"))))
(build-system haskell-build-system)
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-file-embed" ,ghc-file-embed)
("ghc-hashable" ,ghc-hashable)
("ghc-hjsonpointer" ,ghc-hjsonpointer)
("ghc-http-client" ,ghc-http-client)
("ghc-http-client-tls" ,ghc-http-client-tls)
("ghc-http-types" ,ghc-http-types)
("ghc-pcre-heavy" ,ghc-pcre-heavy)
("ghc-profunctors" ,ghc-profunctors)
("ghc-protolude" ,ghc-protolude)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-safe-exceptions" ,ghc-safe-exceptions)
("ghc-scientific" ,ghc-scientific)
("ghc-unordered-containers"
,ghc-unordered-containers)
("ghc-text" ,ghc-text)
("ghc-vector" ,ghc-vector)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-async" ,ghc-async)
("ghc-hspec" ,ghc-hspec)
("ghc-wai-app-static" ,ghc-wai-app-static)
("ghc-warp" ,ghc-warp)))
(home-page
"https://github.com/seagreen/hjsonschema")
(synopsis "JSON Schema library")
(description "")
(license expat)))
(define-public ghc-hspec-wai
(package
(name "ghc-hspec-wai")
(version "0.9.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/hspec-wai/hspec-wai-"
version
".tar.gz"))
(sha256
(base32
"0gr8j8x8vvzygxyqc0likam63f3427x4p73g95a387aksr5l2ph5"))))
(build-system haskell-build-system)
(inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-base-compat" ,ghc-base-compat)
("ghc-case-insensitive" ,ghc-case-insensitive)
("ghc-hspec-core" ,ghc-hspec-core)
("ghc-hspec-expectations"
,ghc-hspec-expectations)
("ghc-http-types" ,ghc-http-types)
("ghc-text" ,ghc-text)
("ghc-wai" ,ghc-wai)
("ghc-wai-extra" ,ghc-wai-extra)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)))
(home-page
"https://github.com/hspec/hspec-wai#readme")
(synopsis
"Experimental Hspec support for testing WAI applications")
(description
"Experimental Hspec support for testing WAI applications")
(license expat)))
(define-public ghc-hspec-wai-json
(package
(name "ghc-hspec-wai-json")
(version "0.9.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/hspec-wai-json/hspec-wai-json-"
version
".tar.gz"))
(sha256
(base32
"1p6adknahl357cjkfg32aha6v79mwwr55isgl4hj2rh45r429qw2"))))
(build-system haskell-build-system)
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-aeson-qq" ,ghc-aeson-qq)
("ghc-case-insensitive" ,ghc-case-insensitive)
("ghc-hspec-wai" ,ghc-hspec-wai)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)))
(home-page
"https://github.com/hspec/hspec-wai#readme")
(synopsis "Testing JSON APIs with hspec-wai")
(description "Testing JSON APIs with hspec-wai")
(license expat)))
(define-public ghc-hjsonpointer
(package
(name "ghc-hjsonpointer")
(version "1.5.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/hjsonpointer/hjsonpointer-"
version
".tar.gz"))
(sha256
(base32
"1bdr5jpc2vcx6bk724jmfz7nh3jgqwrmj4hab64h9pjdrl4vz00y"))))
(build-system haskell-build-system)
(inputs
`(("ghc-aeson" ,ghc-aeson)
("ghc-hashable" ,ghc-hashable)
("ghc-unordered-containers"
,ghc-unordered-containers)
("ghc-text" ,ghc-text)
("ghc-vector" ,ghc-vector)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-http-types" ,ghc-http-types)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page
"https://github.com/seagreen/hjsonpointer")
(synopsis "JSON Pointer library")
(description "")
(license expat)))
(define-public ghc-pcre-heavy
(package
(name "ghc-pcre-heavy")
(version "1.0.0.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/pcre-heavy/pcre-heavy-"
version
".tar.gz"))
(sha256
(base32
"1lfbjgvl55jh226n307c2w8mrb3l1myzbkjh4j0jfcb8nybzcp4a"))))
(build-system haskell-build-system)
(inputs
`(("ghc-base-compat" ,ghc-base-compat)
("ghc-pcre-light" ,ghc-pcre-light)
("ghc-string-conversions"
,ghc-string-conversions)
("ghc-semigroups" ,ghc-semigroups)))
(native-inputs
`(("ghc-glob" ,ghc-glob)
("ghc-doctest" ,ghc-doctest)))
(home-page
"https://github.com/myfreeweb/pcre-heavy")
(synopsis
"A regexp (regex) library on top of pcre-light you can actually use.")
(description
"A regular expressions library that does not suck. Based on <https://hackage.haskell.org/package/pcre-light pcre-light>. Takes and returns <https://hackage.haskell.org/package/stringable Stringables> everywhere. Includes a QuasiQuoter for regexps that does compile time checking. SEARCHES FOR MULTIPLE MATCHES! DOES REPLACEMENT!")
(license #f)))
(define-public ghc-wai-app-static
(package
(name "ghc-wai-app-static")
(version "3.1.6.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/wai-app-static/wai-app-static-"
version
".tar.gz"))
(sha256
(base32
"0s6bpz5gmjy797bnnw1y5mwy9761h46bjp1srnrh7cxlnvm93c4c"))))
(build-system haskell-build-system)
(inputs
`(("ghc-wai" ,ghc-wai)
("ghc-http-types" ,ghc-http-types)
("ghc-unix-compat" ,ghc-unix-compat)
("ghc-old-locale" ,ghc-old-locale)
("ghc-file-embed" ,ghc-file-embed)
("ghc-text" ,ghc-text)
("ghc-cryptonite" ,ghc-cryptonite)
("ghc-memory" ,ghc-memory)
("ghc-http-date" ,ghc-http-date)
("ghc-blaze-html" ,ghc-blaze-html)
("ghc-blaze-markup" ,ghc-blaze-markup)
("ghc-mime-types" ,ghc-mime-types)
("ghc-unordered-containers"
,ghc-unordered-containers)
("ghc-zlib" ,ghc-zlib)
("ghc-wai-extra" ,ghc-wai-extra)
("ghc-optparse-applicative"
,ghc-optparse-applicative)
("ghc-warp" ,ghc-warp)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-network" ,ghc-network)
("ghc-temporary" ,ghc-temporary)
("ghc-mockery" ,ghc-mockery)))
(home-page
"http://www.yesodweb.com/book/web-application-interface")
(synopsis "WAI application for static serving")
(description
"API docs and the README are available at <http://www.stackage.org/package/wai-app-static>.")
(license expat)))
(define-public ghc-string-conversions
(package
(name "ghc-string-conversions")
(version "0.4.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/string-conversions/string-conversions-"
version
".tar.gz"))
(sha256
(base32
"150rdank90h7v08x0wq4dffjbxv2daf5v9sqfs5mab76kinwxg26"))))
(build-system haskell-build-system)
(inputs
`(("ghc-text" ,ghc-text)
("ghc-utf8-string" ,ghc-utf8-string)))
(native-inputs
`(("hspec-discover ,hspec-discover)
("ghc-hspec" ,ghc-hspec)
("ghc-quickcheck-instances"
,ghc-quickcheck-instances)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page
"https://github.com/soenkehahn/string-conversions#readme")
(synopsis
"Simplifies dealing with different types for strings")
(description
"Provides a simple type class for converting values of different string types into values of other string types.")
(license bsd-3)))
(define-public ghc-critbit
(package
(name "ghc-critbit")
(version "0.2.1.0")
(source
(origin
(method git-fetch)
(uri
(git-reference
(url "https://github.com/robx/critbit.git")
(commit "v0.2.1.0")))
(sha256
(base32
"0igg86agw9i8f88gn3v0xli8k73xmi9s6spi5zlkmzi2ra458q9k"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f)) ; out of memory
(inputs
`(("ghc-text" ,ghc-text)
("ghc-vector" ,ghc-vector)))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-quickcheck2"
,ghc-test-framework-quickcheck2)))
(home-page "https://github.com/bos/critbit")
(synopsis "Crit-bit maps and sets")
(description
"This package implements crit-bit trees, a key-value container type for storing keys that can be treated as bitstrings (e.g. 'ByteString' and 'Text'). . Compared to the data structures from the containers and unordered-containers packages, you will find that sometimes the functions implemented in this package are faster, sometimes slower. . In many cases, a 'CritBit' tree provides performance close to that of a 'HashMap', while providing ordered storage and traversal like a 'Map'.")
(license bsd-3)))
(define-public ghc-data-checked
(package
(name "ghc-data-checked")
(version "0.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/data-checked/data-checked-"
version
".tar.gz"))
(sha256
(base32
"0xjn7iqlsgi51h8gz4x40kc2qb5lwf6nw5kjwgkck1w5gjfd11yw"))))
(build-system haskell-build-system)
(home-page "https://github.com/mvv/data-checked")
(synopsis
"Type-indexed runtime-checked properties")
(description
"This package provides a (phantom) type-indexed newtype evidence-wrapper for values that are checked to satisfy the property associated with the type.")
(license bsd-3)))
(define-public ghc-text-latin1
(package
(name "ghc-text-latin1")
(version "0.3.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/text-latin1/text-latin1-"
version
".tar.gz"))
(sha256
(base32
"1wxbv6m567n3330baw2k0xxd50nhn2k6w3lgmpk6zq7x1jp84x3c"))))
(build-system haskell-build-system)
(inputs
`(("ghc-data-checked" ,ghc-data-checked)
("ghc-text" ,ghc-text)
("ghc-semigroups" ,ghc-semigroups)
("ghc-case-insensitive" ,ghc-case-insensitive)
("ghc-hashable" ,ghc-hashable)))
(home-page "https://github.com/mvv/text-latin1")
(synopsis
"Latin-1 (including ASCII) utility functions")
(description
"This package provides various functions over the ASCII ang Latin-1 portions of the 'Char' and 'Word8' data types.")
(license bsd-3)))
(define-public ghc-data-serializer
(package
(name "ghc-data-serializer")
(version "0.3.4")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/data-serializer/data-serializer-"
version
".tar.gz"))
(sha256
(base32
"1ijy8l5lxmm8wpzx4h2vh9q21zz66xgh979s32aa4b16l9m1b4z7"))))
(build-system haskell-build-system)
(inputs
`(("ghc-semigroups" ,ghc-semigroups)
("ghc-cereal" ,ghc-cereal)
("ghc-data-endian" ,ghc-data-endian)
("ghc-parsers" ,ghc-parsers)
("ghc-split" ,ghc-split)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
(home-page
"https://github.com/mvv/data-serializer")
(synopsis
"Common API for serialization libraries")
(description
"This package provides a common API for serialization libraries like <http://hackage.haskell.org/package/binary binary> and <http://hackage.haskell.org/package/cereal cereal>.")
(license bsd-3)))
(define-public ghc-data-bword
(package
(name "ghc-data-bword")
(version "0.1.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/data-bword/data-bword-"
version
".tar.gz"))
(sha256
(base32
"0zfvk7b7qi6inra0kc03rhsic2rj0818n4i03lfwzvb5g22izw3h"))))
(build-system haskell-build-system)
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
(home-page "https://github.com/mvv/data-bword")
(synopsis
"Extra operations on binary words of fixed length")
(description
"This package provides extra (vs. 'Data.Bits') operations on binary words of fixed length.")
(license bsd-3)))
(define-public ghc-text-printer
(package
(name "ghc-text-printer")
(version "0.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/text-printer/text-printer-"
version
".tar.gz"))
(sha256
(base32
"02sadjd19dbxzawr1q8z3j7w6vhp5mvz1dbssk118hsvl6k0234g"))))
(build-system haskell-build-system)
(inputs
`(("ghc-text" ,ghc-text)
("ghc-text-latin1" ,ghc-text-latin1)
("ghc-semigroups" ,ghc-semigroups)))
(native-inputs
`(("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-quickcheck2"
,ghc-test-framework-quickcheck2)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page "https://github.com/mvv/text-printer")
(synopsis
"Abstract interface for text builders/printers.")
(description
"This package provides an interface for injecting text into monoids such as builders and printers.")
(license bsd-3)))
(define-public ghc-type-hint
(package
(name "ghc-type-hint")
(version "0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/type-hint/type-hint-"
version
".tar.gz"))
(sha256
(base32
"1fcrma7m6y7i1y42rzhv7qch8xkk93lkh1767saw4hsb9fzwsq8i"))))
(build-system haskell-build-system)
(home-page "https://github.com/mvv/type-hint")
(synopsis
"Guide type inference with proxy values")
(description
"This package provides 'Proxy' values for various types from the @base@ library and functions to use these values as hints for type inference.")
(license bsd-3)))
(define-public ghc-data-dword
(package
(name "ghc-data-dword")
(version "0.3.1.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/data-dword/data-dword-"
version
".tar.gz"))
(sha256
(base32
"084invjg8zj7ndxnz9clqmq06ch47k1d9lhxwap6xs0x4807crvb"))))
(build-system haskell-build-system)
(inputs
`(("ghc-hashable" ,ghc-hashable)
("ghc-data-bword" ,ghc-data-bword)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
(home-page "https://github.com/mvv/data-dword")
(synopsis
"Stick two binary words together to get a bigger one")
(description
"This package provides Template Haskell utilities for declaring fixed-length binary word data types. Signed and unsigned 96, 128, 160, 192, 224, and 256-bit types are predefined.")
(license bsd-3)))
(define-public ghc-data-endian
(package
(name "ghc-data-endian")
(version "0.1.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/data-endian/data-endian-"
version
".tar.gz"))
(sha256
(base32
"1h1abz87nha7cpw50yvf8fwvcca350wnnz2d3z9k30sg6wq4y7cc"))))
(build-system haskell-build-system)
(home-page "https://github.com/mvv/data-endian")
(synopsis "Endian-sensitive data")
(description
"This package provides helpers for converting endian-sensitive data.")
(license bsd-3)))
(define-public ghc-loch-th
(package
(name "ghc-loch-th")
(version "0.2.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/loch-th/loch-th-"
version
".tar.gz"))
(sha256
(base32
"1hvdkcyrlnv65q8x8h0441x30wr9bbfbg3961xd3fy9an5r961fc"))))
(build-system haskell-build-system)
(home-page "https://github.com/liskin/loch-th")
(synopsis
"Support for precise error locations in source files (Template Haskell version)")
(description
"This module provides a Template Haskell based mechanism to tag failures with the location of the failure call. The location message includes the file name, line and column numbers.")
(license bsd-3)))
(define-public ghc-placeholders
(package
(name "ghc-placeholders")
(version "0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/placeholders/placeholders-"
version
".tar.gz"))
(sha256
(base32
"0ih35n2pw5gr9ggj2xz5zfcs4bdk200fdw6q9hdy3xna7maphak5"))))
(build-system haskell-build-system)
(home-page
"http://github.com/ahammar/placeholders")
(synopsis
"Placeholders for use while developing Haskell code")
(description
"While working on some Haskell code, it is often useful to work incrementally by inserting @undefined@ as a placeholder for missing code. . This library provides placeholders that produce better messages when evaluated at run-time and also generate compile-time warnings so that they do not get forgotten so easily. For details, see <http://github.com/ahammar/placeholders>")
(license bsd-3)))
(define-public ghc-postgresql-libpq
(package
(name "ghc-postgresql-libpq")
(version "0.9.4.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/postgresql-libpq/postgresql-libpq-"
version
".tar.gz"))
(sha256
(base32
"1y86kysakfcf3zq252yl2llrx3765vxvkdwda4q5ql7ikv3m786f"))))
(build-system haskell-build-system)
(inputs `(("postgresql", postgresql)))
(home-page
"https://github.com/phadej/postgresql-libpq")
(synopsis "low-level binding to libpq")
(description
"This is a binding to libpq: the C application programmer's interface to PostgreSQL. libpq is a set of library functions that allow client programs to pass queries to the PostgreSQL backend server and to receive the results of these queries.")
(license bsd-3)))
(define-public ghc-json-ast
(package
(name "ghc-json-ast")
(version "0.3.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/json-ast/json-ast-"
version
".tar.gz"))
(sha256
(base32
"1fn41v8k1lac6mavxjxxd9dwcbkkhvwjhqikhkv94jmd75qpdz8j"))))
(build-system haskell-build-system)
(inputs
`(("ghc-vector" ,ghc-vector)
("ghc-text" ,ghc-text)
("ghc-scientific" ,ghc-scientific)
("ghc-unordered-containers"
,ghc-unordered-containers)))
(home-page
"https://github.com/nikita-volkov/json-ast")
(synopsis "Universal JSON AST datastructure")
(description "")
(license expat)))
(define-public ghc-conversion
(package
(name "ghc-conversion")
(version "1.2.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/conversion/conversion-"
version
".tar.gz"))
(sha256
(base32
"0211p3jb8cynpmvxhz3ay1294hmvccx2acrh39pqhagjjbd72xy9"))))
(build-system haskell-build-system)
(inputs
`(("ghc-base-prelude" ,ghc-base-prelude)))
(home-page
"https://github.com/nikita-volkov/conversion")
(synopsis
"Universal converter between values of different types")
(description
"This library provides a typeclass with instances for types defined in \\\"base\\\". Instances for other types are expected to be defined in other libraries. Such libraries should be listed under <http://hackage.haskell.org/packages/#cat:Conversion the Conversion category>. So far the following are known: . * <http://hackage.haskell.org/package/conversion-bytestring \"conversion-bytestring\"> . * <http://hackage.haskell.org/package/conversion-text \"conversion-text\"> . * <http://hackage.haskell.org/package/conversion-case-insensitive \"conversion-case-insensitive\">")
(license expat)))
(define-public ghc-data-textual
(package
(name "ghc-data-textual")
(version "0.3.0.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/data-textual/data-textual-"
version
".tar.gz"))
(sha256
(base32
"0c4qs923dj4jnvvkjvbij0c1yg922iw66140cq6wb1m4h6q31ia4"))))
(build-system haskell-build-system)
(inputs
`(("ghc-text" ,ghc-text)
("ghc-text-latin1" ,ghc-text-latin1)
("ghc-text-printer" ,ghc-text-printer)
("ghc-parsers" ,ghc-parsers)))
(native-inputs
`(("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-quickcheck2"
,ghc-test-framework-quickcheck2)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-type-hint" ,ghc-type-hint)))
(home-page "https://github.com/mvv/data-textual")
(synopsis
"Human-friendly textual representations.")
(description
"This package provides an interface for converting between data and its (human-friendly) textual representation.")
(license bsd-3)))
(define-public ghc-conversion-bytestring
(package
(name "ghc-conversion-bytestring")
(version "1.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/conversion-bytestring/conversion-bytestring-"
version
".tar.gz"))
(sha256
(base32
"0ybh702mrwjvm48i03bb5hfiiz5qypyxyz5n14wai0kjn4ks1qwh"))))
(build-system haskell-build-system)
(inputs
`(("ghc-conversion" ,ghc-conversion)
("ghc-base-prelude" ,ghc-base-prelude)))
(home-page
"https://github.com/nikita-volkov/conversion-bytestring")
(synopsis
"\"Conversion\" instances for the \"bytestring\" library")
(description "")
(license expat)))
(define-public ghc-network-ip
(package
(name "ghc-network-ip")
(version "0.3.0.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/network-ip/network-ip-"
version
".tar.gz"))
(sha256
(base32
"1zjy232pamkd3977cyaq5w5r6ksbpqpgzzlds15zrahjccirs9gf"))))
(build-system haskell-build-system)
(inputs
`(("ghc-data-default-class"
,ghc-data-default-class)
("ghc-data-endian" ,ghc-data-endian)
("ghc-data-dword" ,ghc-data-dword)
("ghc-type-hint" ,ghc-type-hint)
("ghc-hashable" ,ghc-hashable)
("ghc-data-serializer" ,ghc-data-serializer)
("ghc-text-printer" ,ghc-text-printer)
("ghc-data-textual" ,ghc-data-textual)
("ghc-parsers" ,ghc-parsers)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
(home-page "https://github.com/mvv/network-ip")
(synopsis "Internet Protocol data structures")
(description
"This package provides Internet Protocol data structures")
(license bsd-3)))
(define-public ghc-bytestring-strict-builder
(package
(name "ghc-bytestring-strict-builder")
(version "0.4.5.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/bytestring-strict-builder/bytestring-strict-builder-"
version
".tar.gz"))
(sha256
(base32
"14l5q4wgx3fpysindlapf2binhy6svsc904c8x052v095p6gn9c2"))))
(build-system haskell-build-system)
(inputs
`(("ghc-semigroups" ,ghc-semigroups)
("ghc-base-prelude" ,ghc-base-prelude)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-quickcheck-instances"
,ghc-quickcheck-instances)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-rerebase" ,ghc-rerebase)))
(home-page
"https://github.com/nikita-volkov/bytestring-strict-builder")
(synopsis
"An efficient strict bytestring builder")
(description
"According to <https://github.com/nikita-volkov/bytestring-builders-benchmark the competition benchmarks>, this library provides on average the fastest builder of strict bytestrings. . Practical benchmarks have proven it to be highly performant as well. The encoders from the \\\"postgresql-binary\\\" library have shown a stable performance improvement by factors of up to 10 after the migration from the standard builder to \\\"bytestring-strict-builder\\\".")
(license expat)))
(define-public ghc-mtl
(package
(name "ghc-mtl")
(version "2.2.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/mtl/mtl-"
version
".tar.gz"))
(sha256
(base32
"1xmy5741h8cyy0d91ahvqdz2hykkk20l8br7lg1rccnkis5g80w8"))))
(build-system haskell-build-system)
(home-page "http://github.com/haskell/mtl")
(synopsis
"Monad classes, using functional dependencies")
(description
"Monad classes using functional dependencies, with instances for various monad transformers, inspired by the paper /Functional Programming with Overloading and Higher-Order Polymorphism/, by Mark P Jones, in /Advanced School of Functional Programming/, 1995 (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).")
(license bsd-3)))
(define-public ghc-conversion-text
(package
(name "ghc-conversion-text")
(version "1.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/conversion-text/conversion-text-"
version
".tar.gz"))
(sha256
(base32
"0ncvdgify4vhnzanl607h7nj6hqvzyq1csmaq5713gdp6h56fs9h"))))
(build-system haskell-build-system)
(inputs
`(("ghc-text" ,ghc-text)
("ghc-conversion" ,ghc-conversion)
("ghc-conversion-bytestring"
,ghc-conversion-bytestring)
("ghc-base-prelude" ,ghc-base-prelude)))
(home-page
"https://github.com/nikita-volkov/conversion-text")
(synopsis
"\"Conversion\" instances for the \"text\" library")
(description "")
(license expat)))
(define-public ghc-binary-parser
(package
(name "ghc-binary-parser")
(version "0.5.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/binary-parser/binary-parser-"
version
".tar.gz"))
(sha256
(base32
"1cs3zrhgnng2h84xnnvqcy6yrdm0xay1494dsa612y590s773aqx"))))
(build-system haskell-build-system)
(arguments `(#:tests? #f))
(inputs
`(("ghc-text" ,ghc-text)
("ghc-mtl" ,ghc-mtl)
("ghc-base-prelude" ,ghc-base-prelude)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-quickcheck-instances"
,ghc-quickcheck-instances)
("ghc-rerebase" ,ghc-rerebase)))
(home-page
"https://github.com/nikita-volkov/binary-parser")
(synopsis
"A highly-efficient but limited parser API specialised for bytestrings")
(description "")
(license expat)))
(define-public ghc-postgresql-binary
(package
(name "ghc-postgresql-binary")
(version "0.12.1.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/postgresql-binary/postgresql-binary-"
version
".tar.gz"))
(sha256
(base32
"10h5299fxqmfz0kxyvivfy396q35gzg60spnjagyha33kx5m3bc3"))))
(build-system haskell-build-system)
(inputs
`(("ghc-binary-parser" ,ghc-binary-parser)
("ghc-bytestring-strict-builder"
,ghc-bytestring-strict-builder)
("ghc-aeson" ,ghc-aeson)
("ghc-uuid" ,ghc-uuid)
("ghc-scientific" ,ghc-scientific)
("ghc-text" ,ghc-text)
("ghc-vector" ,ghc-vector)
("ghc-network-ip" ,ghc-network-ip)
("ghc-unordered-containers"
,ghc-unordered-containers)
("ghc-loch-th" ,ghc-loch-th)
("ghc-placeholders" ,ghc-placeholders)
("ghc-base-prelude" ,ghc-base-prelude)))
(native-inputs
`(("ghc-postgresql-libpq" ,ghc-postgresql-libpq)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-quickcheck-instances"
,ghc-quickcheck-instances)
("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-json-ast" ,ghc-json-ast)
("ghc-conversion" ,ghc-conversion)
("ghc-conversion-bytestring"
,ghc-conversion-bytestring)
("ghc-conversion-text" ,ghc-conversion-text)
("ghc-rerebase" ,ghc-rerebase)))
(home-page
"https://github.com/nikita-volkov/postgresql-binary")
(synopsis
"Encoders and decoders for the PostgreSQL's binary format")
(description
"An API for dealing with PostgreSQL's binary data format. . It can be used to implement performant bindings to Postgres. E.g., <http://hackage.haskell.org/package/hasql \"hasql\"> is based on this library. . It supports all Postgres versions starting from 8.3 and is tested against 8.3, 9.3 and 9.5 with the @integer_datetimes@ setting off and on.")
(license expat)))
(define-public ghc-deferred-folds
(package
(name "ghc-deferred-folds")
(version "0.9.10")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/deferred-folds/deferred-folds-"
version
".tar.gz"))
(sha256
(base32
"0rvb7cv45xs087jrm4dmv9ajyx5kfs8n01cclc7msfg90fcs60fx"))))
(build-system haskell-build-system)
(inputs
`(("ghc-foldl" ,ghc-foldl)
("ghc-hashable" ,ghc-hashable)
("ghc-primitive" ,ghc-primitive)
("ghc-unordered-containers"
,ghc-unordered-containers)
("ghc-vector" ,ghc-vector)))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-quickcheck-instances"
,ghc-quickcheck-instances)
("ghc-rerebase" ,ghc-rerebase)
("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
(home-page
"https://github.com/metrix-ai/deferred-folds")
(synopsis "Abstractions over deferred folds")
(description
"This library is in an experimental state. Users should be prepared for frequent updates.")
(license expat)))
(define-public ghc-text-builder
(package
(name "ghc-text-builder")
(version "0.6.5.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/text-builder/text-builder-"
version
".tar.gz"))
(sha256
(base32
"0g40s5md7kfmhqsxxrfliwb3p4whg3m2wp31bai051nx1ddkkvay"))))
(build-system haskell-build-system)
(inputs
`(("ghc-base-prelude" ,ghc-base-prelude)
("ghc-deferred-folds" ,ghc-deferred-folds)
("ghc-semigroups" ,ghc-semigroups)
("ghc-text" ,ghc-text)))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-quickcheck-instances"
,ghc-quickcheck-instances)
("ghc-rerebase" ,ghc-rerebase)
("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
(home-page
"https://github.com/nikita-volkov/text-builder")
(synopsis "An efficient strict text builder")
(description "")
(license expat)))
(define-public ghc-bug
(package
(name "ghc-bug")
(version "1.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/bug/bug-"
version
".tar.gz"))
(sha256
(base32
"1xfynvp5fyn46gg3p5qq9cmb1dnw2dyf3bz6w5wdvikfvs19dwhq"))))
(build-system haskell-build-system)
(home-page
"https://github.com/nikita-volkov/bug")
(synopsis
"Better alternatives to the \"error\" function")
(description "")
(license expat)))
(define-public ghc-bytestring-tree-builder
(package
(name "ghc-bytestring-tree-builder")
(version "0.2.7.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/bytestring-tree-builder/bytestring-tree-builder-"
version
".tar.gz"))
(sha256
(base32
"0v78jwzmpipw4iyr0i9klxhcfxf98vljxz3had1xklslhzsabk16"))))
(build-system haskell-build-system)
(inputs
`(("ghc-semigroups" ,ghc-semigroups)
("ghc-text" ,ghc-text)
("ghc-base-prelude" ,ghc-base-prelude)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-tasty-hunit" ,ghc-tasty-hunit)
("ghc-quickcheck-instances"
,ghc-quickcheck-instances)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page
"https://github.com/nikita-volkov/bytestring-tree-builder")
(synopsis
"A very efficient ByteString builder implementation based on the binary tree")
(description
"According to <https://github.com/nikita-volkov/bytestring-builders-benchmark the benchmarks> this builder implementation beats all the alternatives. It is especially well-suited for generating strict bytestrings, beating the standard builder by at least the factor of 4.")
(license expat)))
(define-public ghc-concise
(package
(name "ghc-concise")
(version "0.1.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/concise/concise-"
version
".tar.gz"))
(sha256
(base32
"09crgc6gjfidlad6263253xx1di6wfhc9awhira21s0z7rddy9sw"))))
(build-system haskell-build-system)
(inputs
`(("ghc-lens" ,ghc-lens) ("ghc-text" ,ghc-text)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-quickcheck-instances"
,ghc-quickcheck-instances)))
(home-page
"https://github.com/frasertweedale/hs-concise")
(synopsis "Utilities for Control.Lens.Cons")
(description
"concise provides a handful of functions to extend what you can do with Control.Lens.Cons.")
(license bsd-3)))
(define-public ghc-monad-time
(package
(name "ghc-monad-time")
(version "0.3.1.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/monad-time/monad-time-"
version
".tar.gz"))
(sha256
(base32
"0z30c0k5bqlz86vwajnm6kj26i09zx6dzqwd00z6ba8hqyzm1x0a"))))
(build-system haskell-build-system)
(inputs `(("ghc-mtl" ,ghc-mtl)))
(home-page
"https://github.com/scrive/monad-time")
(synopsis
"Type class for monads which carry the notion of the current time.")
(description
"'MonadTime' type class for monads which carry the notion of the current time.")
(license bsd-3)))
(define-public ghc-tasty-hspec
(package
(name "ghc-tasty-hspec")
(version "1.1.5.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/tasty-hspec/tasty-hspec-"
version
".tar.gz"))
(sha256
(base32
"0i9kdzjpk750sa078jj3iyhp72k0177zk7vxl131r6dkyz09x27y"))))
(build-system haskell-build-system)
(inputs
`(("ghc-hspec" ,ghc-hspec)
("ghc-hspec-core" ,ghc-hspec-core)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-tasty" ,ghc-tasty)
("ghc-tasty-smallcheck" ,ghc-tasty-smallcheck)
("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
(home-page
"https://github.com/mitchellwrosen/tasty-hspec")
(synopsis
"Hspec support for the Tasty test framework.")
(description
"This package provides a Tasty provider for Hspec test suites.")
(license bsd-3)))
(define-public ghc-cabal-doctest
(package
(name "ghc-cabal-doctest")
(version "1.0.6")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/cabal-doctest/cabal-doctest-"
version
".tar.gz"))
(sha256
(base32
"0bgd4jdmzxq5y465r4sf4jv2ix73yvblnr4c9wyazazafddamjny"))))
(build-system haskell-build-system)
(home-page
"https://github.com/phadej/cabal-doctest")
(synopsis
"A Setup.hs helper for doctests running")
(description
"Currently (beginning of 2017), there isn't @cabal doctest@ command. Yet, to properly work doctest needs plenty of configuration. This library provides the common bits for writing custom Setup.hs See <https://github.com/haskell/cabal/issues/2327 Cabal/2327> for the progress of @cabal doctest@, i.e. whether this library is obsolete.")
(license bsd-3)))
(define-public ghc-base-compat-batteries
(package
(name "ghc-base-compat-batteries")
(version "0.10.5")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/base-compat-batteries/base-compat-batteries-"
version
".tar.gz"))
(sha256
(base32
"1vkhc639vqiv5p39jn1v312z32i7yk5q2lf0ap4jxl1v8p8wyp8p"))))
(build-system haskell-build-system)
(inputs
`(("ghc-base-compat" ,ghc-base-compat)
("ghc-contravariant" ,ghc-contravariant)))
(native-inputs
`(("ghc-hspec" ,ghc-hspec)
("hspec-discover" ,hspec-discover)
("ghc-quickcheck" ,ghc-quickcheck)))
(home-page
"http://hackage.haskell.org/package/base-compat-batteries")
(synopsis "base-compat with extra batteries")
(description
"Provides functions available in later versions of @base@ to a wider range of compilers, without requiring you to use CPP pragmas in your code. . This package provides the same API as the @<http://hackage.haskell.org/package/base-compat base-compat>@ library, but depends on compatibility packages (such as @semigroups@) to offer a wider support window than @base-compat@, which has no dependencies. Most of the modules in this library have the same names as in @base-compat@ to make it easier to switch between the two. There also exist versions of each module with the suffix @.Repl.Batteries@, which are distinct from anything in @base-compat@, to allow for easier use in GHCi. . See @<https://github.com/haskell-compat/base-compat/blob/master/base-compat/README.markdown#dependencies here>@ for a more comprehensive list of differences between @base-compat@ and @base-compat-batteries@.")
(license expat)))
(define-public ghc-http-media
(package
(name "ghc-http-media")
(version "0.8.0.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/http-media/http-media-"
version
".tar.gz"))
(sha256
(base32
"0lww5cxrc9jlvzsysjv99lca33i4rb7cll66p3c0rdpmvz8pk0ir"))))
(build-system haskell-build-system)
(inputs
`(("ghc-case-insensitive" ,ghc-case-insensitive)
("ghc-utf8-string" ,ghc-utf8-string)))
(native-inputs
`(("ghc-quickcheck" ,ghc-quickcheck)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-quickcheck2"
,ghc-test-framework-quickcheck2)))
(home-page "https://github.com/zmthy/http-media")
(synopsis
"Processing HTTP Content-Type and Accept headers")
(description
"This library is intended to be a comprehensive solution to parsing and selecting quality-indexed values in HTTP headers. It is capable of parsing both media types and language parameters from the Accept and Content header families, and can be extended to match against other accept headers as well. Selecting the appropriate header value is achieved by comparing a list of server options against the quality-indexed values supplied by the client. . In the following example, the Accept header is parsed and then matched against a list of server options to serve the appropriate media using 'mapAcceptMedia': . > getHeader >>= maybe send406Error sendResourceWith . mapAcceptMedia > [ (\"text/html\", asHtml) > , (\"application/json\", asJson) > ] . Similarly, the Content-Type header can be used to produce a parser for request bodies based on the given content type with 'mapContentMedia': . > getContentType >>= maybe send415Error readRequestBodyWith . mapContentMedia > [ (\"application/json\", parseJson) > , (\"text/plain\", parseText) > ] . The API is agnostic to your choice of server.")
(license expat)))
(define-public ghc-websockets
(package
(name "ghc-websockets")
(version "0.12.5.3")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/websockets/websockets-"
version
".tar.gz"))
(sha256
(base32
"0mkxl7iwl5pl2w0svji9248v4c0hi45k725jj5ybaknb73650ns4"))))
(build-system haskell-build-system)
(inputs
`(("ghc-attoparsec" ,ghc-attoparsec)
("ghc-base64-bytestring" ,ghc-base64-bytestring)
("ghc-bytestring-builder"
,ghc-bytestring-builder)
("ghc-case-insensitive" ,ghc-case-insensitive)
("ghc-network" ,ghc-network)
("ghc-random" ,ghc-random)
("ghc-sha" ,ghc-sha)
("ghc-streaming-commons" ,ghc-streaming-commons)
("ghc-text" ,ghc-text)
("ghc-entropy" ,ghc-entropy)))
(native-inputs
`(("ghc-hunit" ,ghc-hunit)
("ghc-quickcheck" ,ghc-quickcheck)
("ghc-test-framework" ,ghc-test-framework)
("ghc-test-framework-hunit"
,ghc-test-framework-hunit)
("ghc-test-framework-quickcheck2"
,ghc-test-framework-quickcheck2)))
(home-page "http://jaspervdj.be/websockets")
(synopsis
"A sensible and clean way to write WebSocket-capable servers in Haskell.")
(description
"This library allows you to write WebSocket-capable servers. . An example server: <https://github.com/jaspervdj/websockets/blob/master/example/server.lhs> . An example client: <https://github.com/jaspervdj/websockets/blob/master/example/client.hs> . See also: . * The specification of the WebSocket protocol: <http://www.whatwg.org/specs/web-socket-protocol/> . * The JavaScript API for dealing with WebSockets: <http://www.w3.org/TR/websockets/>")
(license bsd-3)))
(define-public ghc-wai-websockets
(package
(name "ghc-wai-websockets")
(version "3.0.1.2")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/wai-websockets/wai-websockets-"
version
".tar.gz"))
(sha256
(base32
"0b2xmdsrsqpssyib53wbr6r8hf75789ndyyanv37sv99iyqcwz4i"))))
(build-system haskell-build-system)
(inputs
`(("ghc-wai" ,ghc-wai)
("ghc-case-insensitive" ,ghc-case-insensitive)
("ghc-network" ,ghc-network)
("ghc-websockets" ,ghc-websockets)
("ghc-http-types" ,ghc-http-types)
("ghc-warp" ,ghc-warp)
("ghc-wai-app-static" ,ghc-wai-app-static)
("ghc-text" ,ghc-text)
("ghc-file-embed" ,ghc-file-embed)))
(home-page "http://github.com/yesodweb/wai")
(synopsis
"Provide a bridge between WAI and the websockets package.")
(description
"API docs and the README are available at <http://www.stackage.org/package/wai-websockets>.")
(license expat)))
(define-public ghc-expiring-cache-map
(package
(name "ghc-expiring-cache-map")
(version "0.0.6.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/expiring-cache-map/expiring-cache-map-"
version
".tar.gz"))
(sha256
(base32
"1fb47hsn06ybn2yzw7r6pjkmvvfpbdx7wjhbpxcywilbjyac4fqf"))))
(build-system haskell-build-system)
(inputs
`(("ghc-hashable" ,ghc-hashable)
("ghc-unordered-containers"
,ghc-unordered-containers)))
(home-page
"https://github.com/elblake/expiring-cache-map")
(synopsis "General purpose simple caching.")
(description
"A simple general purpose shared state cache map with automatic expiration of values, for caching the results of accessing a resource such as reading a file. With variations for Ord and Hashable keys using \"Data.Map.Strict\" and \"Data.HashMap.Strict\", respectively.")
(license bsd-3)))
(define-public ghc-wl-pprint-annotated
(package
(name "ghc-wl-pprint-annotated")
(version "0.1.0.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/wl-pprint-annotated/wl-pprint-annotated-"
version
".tar.gz"))
(sha256
(base32
"1br7qyf27iza213inwhf9bm2k6in0zbmfw6w4clqlc9f9cj2nrkb"))))
(build-system haskell-build-system)
(inputs `(("ghc-text" ,ghc-text)))
(native-inputs
`(("ghc-tasty" ,ghc-tasty)
("ghc-tasty-hunit" ,ghc-tasty-hunit)))
(home-page
"https://github.com/minad/wl-pprint-annotated#readme")
(synopsis
"Pretty printer with annotation support")
(description
"Wadler/Leijen pretty printer with support for annotations and modernized API. Annotations are useful for coloring. See wl-pprint-console.")
(license bsd-3)))
(define-public ghc-concurrent-output
(package
(name "ghc-concurrent-output")
(version "1.10.10")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/concurrent-output/concurrent-output-"
version
".tar.gz"))
(sha256
(base32
"1wnjxnwbc3l853kiiijagzjyb6fmhz3lmkwls24plbximl1qrr22"))))
(build-system haskell-build-system)
(inputs
`(("ghc-text" ,ghc-text)
("ghc-async" ,ghc-async)
("ghc-stm" ,ghc-stm)
("ghc-exceptions" ,ghc-exceptions)
("ghc-ansi-terminal" ,ghc-ansi-terminal)
("ghc-terminal-size" ,ghc-terminal-size)))
(home-page
"http://hackage.haskell.org/package/concurrent-output")
(synopsis
"Ungarble output from several threads or commands")
(description
"Lets multiple threads and external processes concurrently output to the console, without it getting all garbled up. . Built on top of that is a way of defining multiple output regions, which are automatically laid out on the screen and can be individually updated by concurrent threads. Can be used for progress displays etc. . <<https://joeyh.name/code/concurrent-output/demo2.gif>>")
(license bsd-2)))
(define-public ghc-hedgehog
(package
(name "ghc-hedgehog")
(version "1.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/hedgehog/hedgehog-"
version
".tar.gz"))
(sha256
(base32
"1np9xg58x20kalfci9dxbd4wsg0sl3ka56ragzy3i9p0nx29pmns"))))
(build-system haskell-build-system)
(inputs
`(("ghc-ansi-terminal" ,ghc-ansi-terminal)
("ghc-async" ,ghc-async)
("ghc-concurrent-output" ,ghc-concurrent-output)
("ghc-exceptions" ,ghc-exceptions)
("ghc-fail" ,ghc-fail)
("ghc-lifted-async" ,ghc-lifted-async)
("ghc-mmorph" ,ghc-mmorph)
("ghc-monad-control" ,ghc-monad-control)
("ghc-mtl" ,ghc-mtl)
("ghc-pretty-show" ,ghc-pretty-show)
("ghc-primitive" ,ghc-primitive)
("ghc-random" ,ghc-random)
("ghc-resourcet" ,ghc-resourcet)
("ghc-semigroups" ,ghc-semigroups)
("ghc-stm" ,ghc-stm)
("ghc-text" ,ghc-text)
("ghc-transformers-base" ,ghc-transformers-base)
("ghc-wl-pprint-annotated"
,ghc-wl-pprint-annotated)))
(home-page "https://hedgehog.qa")
(synopsis "Release with confidence.")
(description
"<http://hedgehog.qa/ Hedgehog> automatically generates a comprehensive array of test cases, exercising your software in ways human testers would never imagine. . Generate hundreds of test cases automatically, exposing even the most insidious of corner cases. Failures are automatically simplified, giving developers coherent, intelligible error messages. . To get started quickly, see the <https://github.com/hedgehogqa/haskell-hedgehog/tree/master/hedgehog-example examples>.")
(license bsd-3)))
(define-public ghc-tasty-hedgehog
(package
(name "ghc-tasty-hedgehog")
(version "0.2.0.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/tasty-hedgehog/tasty-hedgehog-"
version
".tar.gz"))
(sha256
(base32
"10m1akbiblnjq9ljk469725k30b254d36d267rk51z2f171py42s"))))
(build-system haskell-build-system)
(inputs
`(("ghc-tagged" ,ghc-tagged)
("ghc-tasty" ,ghc-tasty)
("ghc-hedgehog" ,ghc-hedgehog)))
(native-inputs
`(("ghc-tasty-expected-failure"
,ghc-tasty-expected-failure)))
(home-page
"https://github.com/qfpl/tasty-hedgehog")
(synopsis "Integration for tasty and hedgehog.")
(description
"Integrates the hedgehog testing library with the tasty testing framework.")
(license bsd-3)))
(define-public ghc-contravariant
(package
(name "ghc-contravariant")
(version "1.5.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/contravariant/contravariant-"
version
".tar.gz"))
(sha256
(base32
"1jcfbv3mmx2hb49h4djn72bb13j609wvsy9z4wcbj461cvhcr2q8"))))
(build-system haskell-build-system)
(inputs `(("ghc-statevar" ,ghc-statevar)))
(home-page
"http://github.com/ekmett/contravariant/")
(synopsis "Contravariant functors")
(description "Contravariant functors.")
(license bsd-3)))
(define-public ghc-ansi-terminal
(package
(name "ghc-ansi-terminal")
(version "0.9.1")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/ansi-terminal/ansi-terminal-"
version
".tar.gz"))
(sha256
(base32
"1yr0ld0kqns3w3j9gl62bdwshvyazidx4dv1qkvq19ivnf08w23l"))))
(build-system haskell-build-system)
(inputs `(("ghc-colour" ,ghc-colour)))
(home-page
"https://github.com/feuerbach/ansi-terminal")
(synopsis
"Simple ANSI terminal support, with Windows compatibility")
(description
"ANSI terminal support for Haskell: allows cursor movement, screen clearing, color output, showing or hiding the cursor, and changing the title. Works on UNIX and Windows.")
(license bsd-3)))
(define-public ghc-primitive
(package
(name "ghc-primitive")
(version "0.6.4.0")
(source
(origin
(method url-fetch)
(uri (string-append
"https://hackage.haskell.org/package/primitive/primitive-"
version
".tar.gz"))
(sha256
(base32
"0r0cda7acvplgwaxy69kviv4jp7kkfi038by68gj4yfx4iwszgjc"))))
(build-system haskell-build-system)
(home-page
"https://github.com/haskell/primitive")
(synopsis "Primitive memory-related operations")
(description
"This package provides various primitive memory-related operations.")
(license bsd-3)))
ghc-postgrest
[-- Attachment #3: Type: text/plain, Size: 1 bytes --]
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2019-05-15 16:15 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-05-15 16:14 bug#35754: guix build silent failure for unterminated string Robert Vollmert
Code repositories for project(s) associated with this public inbox
https://git.savannah.gnu.org/cgit/guix.git
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).