···
({ mkDerivation, async, base, containers, enummapset-th, filepath
+
, LambdaHack, optparse-applicative, random, template-haskell, text
+
sha256 = "1i4lj4ixs9p6c9l3y57cws6hirwkabc6hwn8cjbzc7xqcmz8xrxg";
enableSeparateDataOutput = true;
executableHaskellDepends = [
+
async base containers enummapset-th filepath LambdaHack
+
optparse-applicative random template-haskell text zlib
+
base containers enummapset-th filepath LambdaHack
+
optparse-applicative random template-haskell text zlib
homepage = "http://allureofthestars.com";
description = "Near-future Sci-Fi roguelike and tactical squad game";
···
license = stdenv.lib.licenses.bsd3;
+
"Frames_0_3_0_2" = callPackage
({ mkDerivation, base, criterion, directory, ghc-prim, hspec, htoml
+
, HUnit, pipes, pipes-bytestring, pipes-group, pipes-parse
+
, pipes-safe, pipes-text, pretty, primitive, readable
+
, regex-applicative, template-haskell, temporary, text
+
, transformers, unordered-containers, vector, vinyl
+
sha256 = "1a0dq3dfiqj5nmqk5ivn07ds7k51rf24k5kcbk19m8nwy4hvi896";
libraryHaskellDepends = [
+
base ghc-prim pipes pipes-bytestring pipes-group pipes-parse
+
pipes-safe pipes-text primitive readable template-haskell text
transformers vector vinyl
···
+
sha256 = "045wdcxm8ink7q86f6c4p47i1vmjyndk8xahabb0zic4yf3mdr76";
libraryHaskellDepends = [
array base bytestring containers directory filepath hpp JuicyPixels
linear OpenGL OpenGLRaw transformers vector
···
sha256 = "1g31zgsg7gq5ac9r5aizghvrg7jwn1a0qs4qwnfillqn4wkw6y5b";
+
editedCabalFile = "04llw8m0s7bqz1d1vymhnzr51y9y6r9vwn4acwch1a10kq02kkpg";
libraryHaskellDepends = [
base binary bytestring containers deepseq mtl primitive
···
license = stdenv.lib.licenses.bsd3;
+
"LambdaDesigner" = callPackage
+
({ mkDerivation, aeson, base, bytestring, bytestring-trie
+
, containers, hosc, lens, lens-aeson, matrix, text, transformers
+
pname = "LambdaDesigner";
+
sha256 = "1lgplxb546f7bdrwnmivb8zwix4rqhkrhv83ni90hzf4nx5fpjcy";
+
libraryHaskellDepends = [
+
aeson base bytestring bytestring-trie containers hosc lens
+
lens-aeson matrix text transformers vector
+
homepage = "https://github.com/ulyssesp/LambdaDesigner#readme";
+
description = "A type-safe EDSL for TouchDesigner written in Haskell";
+
license = stdenv.lib.licenses.bsd3;
"LambdaHack" = callPackage
({ mkDerivation, assert-failure, async, base, base-compat, binary
, bytestring, containers, deepseq, directory, enummapset-th
+
, filepath, ghc-prim, hashable, hsini, keys, miniutter
+
, optparse-applicative, pretty-show, random, sdl2, sdl2-ttf, stm
+
, template-haskell, text, time, transformers, unordered-containers
+
, vector, vector-binary-instances, zlib
+
sha256 = "1f20d0533lxx6ag54752xvvbigp4mkw7b7iklm7cxxpijvbfjcqv";
enableSeparateDataOutput = true;
libraryHaskellDepends = [
assert-failure async base base-compat binary bytestring containers
deepseq directory enummapset-th filepath ghc-prim hashable hsini
+
keys miniutter optparse-applicative pretty-show random sdl2
+
sdl2-ttf stm text time transformers unordered-containers vector
+
vector-binary-instances zlib
executableHaskellDepends = [
assert-failure async base base-compat binary bytestring containers
deepseq directory enummapset-th filepath ghc-prim hashable hsini
+
keys miniutter optparse-applicative pretty-show random stm
+
template-haskell text time transformers unordered-containers vector
+
vector-binary-instances zlib
assert-failure async base base-compat binary bytestring containers
deepseq directory enummapset-th filepath ghc-prim hashable hsini
+
keys miniutter optparse-applicative pretty-show random stm
+
template-haskell text time transformers unordered-containers vector
+
vector-binary-instances zlib
homepage = "https://lambdahack.github.io";
description = "A game engine library for roguelike dungeon crawlers";
···
homepage = "http://github.com/JohnLato/listlike";
description = "Generic support for list-like structures";
+
license = stdenv.lib.licenses.bsd3;
+
({ mkDerivation, base, transformers }:
+
sha256 = "0x2xzasxgrvybyz4ksr41ary5k9l0qccbk2wh71kpwk9nhp4ybx0";
+
libraryHaskellDepends = [ base transformers ];
+
description = "List transformer";
license = stdenv.lib.licenses.bsd3;
···
license = stdenv.lib.licenses.bsd3;
}) {inherit (pkgs) SDL;};
+
"SDL_0_6_6_0" = callPackage
+
({ mkDerivation, base, SDL }:
+
sha256 = "0wpddhq5vwm2m1q8ja1p6draz4f40p1snmdshxwqnyyj3nchqz0z";
+
enableSeparateDataOutput = true;
+
libraryHaskellDepends = [ base ];
+
librarySystemDepends = [ SDL ];
+
description = "Binding to libSDL";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
+
}) {inherit (pkgs) SDL;};
({ mkDerivation, base, SDL, SDL_gfx }:
···
+
sha256 = "0z0dlx4s0j5v627cvns5qdq1r6kcka5nif8g62hdria29lk5aj8q";
libraryHaskellDepends = [
···
"aern2-real" = callPackage
({ mkDerivation, aern2-mp, aeson, base, bytestring, containers
+
, convertible, hspec, lens, mixed-types-num, QuickCheck, random
+
sha256 = "1sq2s20vwhm0avdzqg2vb5ck6rj7aw16kcfkdyhda0dl6s2l5q15";
libraryHaskellDepends = [
···
mixed-types-num QuickCheck stm transformers
executableHaskellDepends = [
+
aern2-mp base mixed-types-num QuickCheck random
testHaskellDepends = [ base hspec QuickCheck ];
homepage = "https://github.com/michalkonecny/aern2";
···
license = stdenv.lib.licenses.mit;
+
"airship_0_9_2" = callPackage
({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
, bytestring, bytestring-trie, case-insensitive, containers
, cryptohash, directory, either, filepath, http-date, http-media
···
+
sha256 = "02r607yqvr5w6i6hba0ifbc02fshxijd4g46ygird9lsarcr2svp";
libraryHaskellDepends = [
attoparsec base base64-bytestring blaze-builder bytestring
bytestring-trie case-insensitive containers cryptohash directory
···
+
sha256 = "1szf6xaq7lk3l473rm8pls5s23nk08dwdzf875hx96i0m7kxmp6p";
libraryHaskellDepends = [
aivika aivika-transformers base containers hashable mtl
···
homepage = "https://github.com/jxv/animate#readme";
description = "Animation for sprites";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"anki-tools" = callPackage
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"ansi-escape-codes" = callPackage
+
({ mkDerivation, base }:
+
pname = "ansi-escape-codes";
+
sha256 = "0cd8nllv5p3jxm8cshfimkqwxhcnws7qyrgd8mc0hm4a55k5vhpd";
+
libraryHaskellDepends = [ base ];
+
homepage = "https://github.com/joegesualdo/ansi-escape-codes";
+
description = "Haskell package to generate ANSI escape codes for styling strings in the terminal";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"ansi-pretty" = callPackage
({ mkDerivation, aeson, ansi-wl-pprint, array, base, bytestring
, containers, generics-sop, nats, scientific, semigroups, tagged
···
+
sha256 = "0hqx0q52688zd7hdy6bcmbhycscy1laxggy8fvswglbfdm9m9n8s";
libraryHaskellDepends = [
async base containers mtl template-haskell vector
···
sha256 = "14kcv5n9rm48f9vac333cbazy4hlpb0wqgb4fbv97ivxnjs7g22m";
+
editedCabalFile = "1n2aqkcz2glzcmpiv6wi29pgvgkhqp5gwv134slhz9v3jj4ji1j3";
configureFlags = [ "-f-llvm" ];
libraryHaskellDepends = [
array base containers exact-pi ghc-prim integer-gmp
···
license = stdenv.lib.licenses.bsd3;
+
"atomic-primops_0_8_1_1" = callPackage
+
({ mkDerivation, base, ghc-prim, primitive }:
+
pname = "atomic-primops";
+
sha256 = "0wi18i3k5mjmyd13n1kly7021084rjm4wfpcf70zzzss1z37kxch";
+
libraryHaskellDepends = [ base ghc-prim primitive ];
+
homepage = "https://github.com/rrnewton/haskell-lockfree/wiki";
+
description = "A safe approach to CAS and other atomic ops in Haskell";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"atomic-primops-foreign" = callPackage
({ mkDerivation, base, bits-atomic, HUnit, test-framework
, test-framework-hunit, time
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"base_4_10_1_0" = callPackage
({ mkDerivation, ghc-prim, invalid-cabal-flag-settings, rts }:
+
sha256 = "0hnzhqdf2bxz9slia67sym6s0hi5szh8596kcckighchs9jzl9wx";
libraryHaskellDepends = [
ghc-prim invalid-cabal-flag-settings rts
···
license = stdenv.lib.licenses.mit;
+
"basic-prelude_0_7_0" = callPackage
+
({ mkDerivation, base, bytestring, containers, filepath, hashable
+
, text, transformers, unordered-containers, vector
+
pname = "basic-prelude";
+
sha256 = "0yckmnvm6i4vw0mykj4fzl4ldsf67v8d2h0vp1bakyj84n4myx8h";
+
libraryHaskellDepends = [
+
base bytestring containers filepath hashable text transformers
+
unordered-containers vector
+
homepage = "https://github.com/snoyberg/basic-prelude#readme";
+
description = "An enhanced core prelude; a common foundation for alternate preludes";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"basic-sop" = callPackage
({ mkDerivation, base, deepseq, generics-sop, QuickCheck, text }:
···
+
({ mkDerivation, base, hspec, parsec }:
+
sha256 = "03fnm2xffpf1ldry6wc7haqy40zqfsjswhdwynmnnhbjn7mr5py7";
+
libraryHaskellDepends = [ base parsec ];
+
testHaskellDepends = [ base hspec parsec ];
+
homepage = "https://github.com/henrylaxen/bbdb";
+
description = "Ability to read, write, and modify BBDB files";
license = stdenv.lib.licenses.gpl3;
···
"bearriver" = callPackage
+
({ mkDerivation, base, dunai, MonadRandom, mtl, transformers }:
+
sha256 = "1y8ha8kllp0s6v89q8kyzhmlchrldf9rahdk3sx9qygwbq36fg09";
+
libraryHaskellDepends = [
+
base dunai MonadRandom mtl transformers
homepage = "keera.co.uk";
description = "A replacement of Yampa based on Monadic Stream Functions";
license = stdenv.lib.licenses.bsd3;
···
license = stdenv.lib.licenses.bsd3;
+
"bifunctors_5_5" = callPackage
+
({ mkDerivation, base, base-orphans, comonad, containers, hspec
+
, QuickCheck, semigroups, tagged, template-haskell, th-abstraction
+
, transformers, transformers-compat
+
sha256 = "0a5y85p1dhcvkagpdci6ah5kczc2jpwsj7ywkd9cg0nqcyzq3icj";
+
libraryHaskellDepends = [
+
base base-orphans comonad containers semigroups tagged
+
template-haskell th-abstraction transformers transformers-compat
+
base hspec QuickCheck template-haskell transformers
+
homepage = "http://github.com/ekmett/bifunctors/";
+
description = "Bifunctors";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"bighugethesaurus" = callPackage
({ mkDerivation, base, HTTP, split }:
···
homepage = "https://github.com/jwiegley/bindings-dsl/wiki";
description = "FFI domain specific language, on top of hsc2hs";
license = stdenv.lib.licenses.bsd3;
+
"bindings-DSL_1_0_24" = callPackage
+
({ mkDerivation, base }:
+
pname = "bindings-DSL";
+
sha256 = "03n8z5qxrrq4l6h2f3xyav45f5v2gr112g4l4r4jw8yfvr8qyk93";
+
libraryHaskellDepends = [ base ];
+
homepage = "https://github.com/jwiegley/bindings-dsl/wiki";
+
description = "FFI domain specific language, on top of hsc2hs";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"bindings-EsounD" = callPackage
···
+
sha256 = "000dydglclgk65ryb2n2zdrwp1rnzv7phmh2vi8s1gpp67b5l5ad";
executableHaskellDepends = [
···
+
sha256 = "0vpmz66qg4kqkg6rqwpnp21d36yzywxvlcxxfbqrpv2kdy8pm3pb";
enableSeparateDataOutput = true;
···
sha256 = "0xmvkwambzmji1czxipl9cms5l3v98765b9spmb3wn5n6dpj0ji9";
+
editedCabalFile = "1ls2p35png3wjbldvgknkpsg1xsgxzgkb1mmvzjpbbgxhfhk8x68";
setupHaskellDepends = [ base Cabal cabal-doctest ];
libraryHaskellDepends = [
base bifunctors binary bytes cereal comonad deepseq hashable mmorph
···
license = stdenv.lib.licenses.bsd3;
+
"brick_0_29_1" = callPackage
({ mkDerivation, base, config-ini, containers, contravariant
, data-clist, deepseq, dlist, microlens, microlens-mtl
, microlens-th, stm, template-haskell, text, text-zipper
···
+
sha256 = "1jslqfsqgrg379x4zi44f5xxn2jh0syqd4zbnfg07y3zgy5i399z";
libraryHaskellDepends = [
···
({ mkDerivation, aeson, base, butcher, bytestring, cmdargs
+
, containers, czipwith, data-tree-print, deepseq, directory, extra
+
, filepath, ghc, ghc-boot-th, ghc-exactprint, ghc-paths, hspec
+
, monad-memo, mtl, multistate, neat-interpolation, parsec, pretty
+
, safe, semigroups, strict, syb, text, transformers, uniplate
+
sha256 = "0fi87p8ybibwhsmbh35xhipfkdg3kdwqb6n3y5ynql7603kssgc1";
libraryHaskellDepends = [
aeson base butcher bytestring cmdargs containers czipwith
+
data-tree-print deepseq directory extra ghc ghc-boot-th
ghc-exactprint ghc-paths monad-memo mtl multistate
neat-interpolation pretty safe semigroups strict syb text
transformers uniplate unsafe yaml
executableHaskellDepends = [
aeson base butcher bytestring cmdargs containers czipwith
+
data-tree-print deepseq directory extra filepath ghc ghc-boot-th
+
ghc-exactprint ghc-paths hspec monad-memo mtl multistate
+
neat-interpolation pretty safe semigroups strict syb text
+
transformers uniplate unsafe yaml
aeson base butcher bytestring cmdargs containers czipwith
+
data-tree-print deepseq directory extra filepath ghc ghc-boot-th
ghc-exactprint ghc-paths hspec monad-memo mtl multistate
neat-interpolation parsec pretty safe semigroups strict syb text
transformers uniplate unsafe yaml
···
homepage = "http://github.com/silkapp/bumper";
description = "Automatically bump package versions, also transitively";
license = stdenv.lib.licenses.bsd3;
+
({ mkDerivation, base, cmdargs, doctest, hspec, text, unix }:
+
sha256 = "1n19bsa1sgjjd3c45wvyr9bpdrmj0qjr8nm50h1q4a9lf0fy66wv";
+
libraryHaskellDepends = [ base text ];
+
executableHaskellDepends = [ base cmdargs unix ];
+
testHaskellDepends = [ base doctest hspec ];
+
homepage = "https://github.com/sendyhalim/bunz";
+
description = "CLI tool to beautify JSON string";
+
license = stdenv.lib.licenses.mit;
"burnt-explorer" = callPackage
···
+
({ mkDerivation, base, cmdargs, containers, data-default, directory
+
, filepath, here, hspec, HStringTemplate, language-c, logging
+
, monad-logger, mtl, pretty, split, temporary, text, transformers
+
sha256 = "02z6bfnhsngl5l4shnyw81alhsw9vhl1lbvy04azlg54fgm9sg9x";
+
libraryHaskellDepends = [
+
base containers data-default directory filepath HStringTemplate
+
language-c logging mtl pretty split temporary text transformers
executableHaskellDepends = [
+
base cmdargs containers data-default directory filepath
+
HStringTemplate language-c logging pretty split temporary text
+
testHaskellDepends = [ base here hspec logging monad-logger text ];
homepage = "https://github.com/jwiegley/c2hsc";
description = "Convert C API header files to .hsc and .hsc.helper.c files";
license = stdenv.lib.licenses.bsd3;
···
license = stdenv.lib.licenses.bsd3;
+
"cabal-doctest_1_0_4" = callPackage
+
({ mkDerivation, base, Cabal, directory, filepath }:
+
pname = "cabal-doctest";
+
sha256 = "03sawamkp95jycq9sah72iw525pdndb3x4h489zf4s3ir9avds3d";
+
libraryHaskellDepends = [ base Cabal directory filepath ];
+
homepage = "https://github.com/phadej/cabal-doctest";
+
description = "A Setup.hs helper for doctests running";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"cabal-file-th" = callPackage
({ mkDerivation, base, Cabal, directory, pretty, template-haskell
···
sha256 = "16ax1lx89jdgf9pqka423h2bf8dblkra48n4y3icg8fs79py74gr";
+
editedCabalFile = "148rq7hcbl8rq7pkywn1hk3l7lv442flf6b0wamfixxzxk74fwlj";
setupHaskellDepends = [ base Cabal filepath process ];
···
({ mkDerivation, alg, base }:
+
sha256 = "0f3ik57gc9x7ppxgbc487jazpj8wd14aaiwpnkqxkf9142kqv8nj";
libraryHaskellDepends = [ alg base ];
description = "Categorical types and classes";
license = stdenv.lib.licenses.bsd3;
···
({ mkDerivation, aeson, aeson-casing, base, bytestring, connection
, data-default-class, hspec, http-api-data, http-client
+
, http-client-tls, http-types, req, retry, servant-server, text
+
sha256 = "1qgb5b8y99rh243x1mz0n12lv59l73vnhczxzq8s2h5lzcay3bps";
libraryHaskellDepends = [
aeson aeson-casing base bytestring connection data-default-class
+
http-api-data http-client http-client-tls http-types req retry text
executableHaskellDepends = [
aeson aeson-casing base bytestring connection data-default-class
+
http-api-data http-client http-client-tls http-types req retry text
aeson aeson-casing base bytestring connection data-default-class
hspec http-api-data http-client http-client-tls http-types req
+
retry servant-server text warp
homepage = "https://github.com/matsubara0507/chatwork#readme";
description = "The ChatWork API in Haskell";
···
license = stdenv.lib.licenses.mit;
+
"classy-prelude_1_3_1" = callPackage
({ mkDerivation, async, base, basic-prelude, bifunctors, bytestring
, chunked-data, containers, deepseq, dlist, exceptions, ghc-prim
, hashable, hspec, lifted-async, lifted-base, monad-unlift
···
pname = "classy-prelude";
+
sha256 = "0rk1h0kipmpk94ny2i389l6kjv7j4a55vabpm938rxv5clja2wyd";
libraryHaskellDepends = [
async base basic-prelude bifunctors bytestring chunked-data
containers deepseq dlist exceptions ghc-prim hashable lifted-async
···
base containers hspec QuickCheck transformers unordered-containers
+
homepage = "https://github.com/snoyberg/mono-traversable#readme";
description = "A typeclass-based Prelude";
license = stdenv.lib.licenses.mit;
hydraPlatforms = stdenv.lib.platforms.none;
···
license = stdenv.lib.licenses.mit;
+
"classy-prelude-conduit_1_3_1" = callPackage
({ mkDerivation, base, bytestring, classy-prelude, conduit
, conduit-combinators, hspec, monad-control, QuickCheck, resourcet
pname = "classy-prelude-conduit";
+
sha256 = "0n76c6bg45zcvy1jid3lrn6cr4iz3la7dd1ym7nffvqvgrfp0r2j";
libraryHaskellDepends = [
base bytestring classy-prelude conduit conduit-combinators
monad-control resourcet transformers void
···
base bytestring conduit hspec QuickCheck transformers
+
homepage = "https://github.com/snoyberg/mono-traversable#readme";
description = "classy-prelude together with conduit functions";
license = stdenv.lib.licenses.mit;
hydraPlatforms = stdenv.lib.platforms.none;
···
license = stdenv.lib.licenses.mit;
+
"classy-prelude-yesod_1_3_1" = callPackage
({ mkDerivation, aeson, base, classy-prelude
, classy-prelude-conduit, data-default, http-conduit, http-types
, persistent, yesod, yesod-newsfeed, yesod-static
pname = "classy-prelude-yesod";
+
sha256 = "1yzkwp4gbl1jqv8r95kvbiqgf2sr9wy5ddkqdz3413y0rvwccr9x";
libraryHaskellDepends = [
aeson base classy-prelude classy-prelude-conduit data-default
http-conduit http-types persistent yesod yesod-newsfeed
+
homepage = "https://github.com/snoyberg/mono-traversable#readme";
description = "Provide a classy prelude including common Yesod functionality";
license = stdenv.lib.licenses.mit;
hydraPlatforms = stdenv.lib.platforms.none;
···
benchmarkHaskellDepends = [ base criterion parallel uniplate ];
description = "Fuseable type-class based generics";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
···
description = "Clone all github repositories from a given user";
license = stdenv.lib.licenses.mit;
hydraPlatforms = stdenv.lib.platforms.none;
+
({ mkDerivation, aeson, base, cassava, deepseq, hashable, hspec
+
, markdown-unlit, QuickCheck, vector
+
sha256 = "0x87s852xfsyxnwj88kw38wmpzrj52hd7r87xx73r4ffv0lp6kh4";
+
libraryHaskellDepends = [
+
aeson base cassava deepseq hashable QuickCheck
+
aeson base cassava deepseq hashable hspec markdown-unlit QuickCheck
+
homepage = "https://github.com/frontrowed/closed#readme";
+
description = "Integers bounded by a closed interval";
+
license = stdenv.lib.licenses.mit;
···
"computational-algebra" = callPackage
({ mkDerivation, algebra, algebraic-prelude, arithmoi, base
+
, constraint, constraints, containers, control-monad-loop
+
, convertible, criterion, deepseq, dlist, entropy
+
, equational-reasoning, ghc-typelits-knownnat
+
, ghc-typelits-natnormalise, ghc-typelits-presburger, hashable
+
, heaps, hmatrix, hspec, HUnit, hybrid-vectors, integer-logarithms
+
, lazysmallcheck, lens, ListLike, matrix, monad-loops, MonadRandom
+
, mono-traversable, monomorphic, mtl, parallel, primes, process
+
, QuickCheck, quickcheck-instances, random, reflection, semigroups
+
, singletons, sized, smallcheck, tagged, template-haskell
+
, test-framework, test-framework-hunit, text, transformers
+
, type-natural, unamb, unordered-containers, vector
pname = "computational-algebra";
+
sha256 = "1ivhfw60gv1gxv6fl8z2n3a468dkvrwff8kg1brypaixzwp589gx";
libraryHaskellDepends = [
algebra algebraic-prelude arithmoi base constraints containers
control-monad-loop convertible deepseq dlist entropy
+
equational-reasoning ghc-typelits-knownnat
+
ghc-typelits-natnormalise ghc-typelits-presburger hashable heaps
+
hmatrix hybrid-vectors integer-logarithms lens ListLike matrix
+
monad-loops MonadRandom mono-traversable monomorphic mtl parallel
+
primes reflection semigroups singletons sized tagged
+
template-haskell text type-natural unamb unordered-containers
+
vector vector-algorithms
executableHaskellDepends = [
algebra algebraic-prelude base constraints convertible criterion
···
test-framework-hunit text transformers type-natural vector
benchmarkHaskellDepends = [
+
algebra base constraint constraints containers criterion deepseq
equational-reasoning hspec HUnit lens matrix MonadRandom
monomorphic parallel process QuickCheck quickcheck-instances random
reflection singletons sized smallcheck tagged test-framework
test-framework-hunit transformers type-natural vector
+
homepage = "https://konn.github.com/computational-algebra";
description = "Well-kinded computational algebra library, currently supporting Groebner basis";
license = stdenv.lib.licenses.bsd3;
hydraPlatforms = stdenv.lib.platforms.none;
···
"concrete-haskell" = callPackage
+
({ mkDerivation, base, binary, bytestring, bzlib, bzlib-conduit
+
, concrete-haskell-autogen, conduit, conduit-combinators
+
, conduit-extra, containers, cryptohash-conduit, deepseq, directory
+
, filepath, hashable, lens, megaparsec, monad-extras, mtl, network
, optparse-generic, path, path-io, process, QuickCheck, scientific
+
, stm, tar, tar-conduit, text, thrift, time, unordered-containers
+
, uuid, vector, zip, zip-conduit, zlib
pname = "concrete-haskell";
+
sha256 = "1bjdbvsi7saqrlxybrzi35x47a08b01nlghvz9r6l04dkikjy2xc";
libraryHaskellDepends = [
+
base binary bytestring bzlib bzlib-conduit concrete-haskell-autogen
+
conduit conduit-combinators conduit-extra containers
+
cryptohash-conduit deepseq directory filepath hashable lens
+
megaparsec monad-extras mtl network optparse-generic path path-io
+
process QuickCheck scientific stm tar tar-conduit text thrift time
+
unordered-containers uuid vector zip zip-conduit zlib
executableHaskellDepends = [
+
base binary bytestring bzlib bzlib-conduit concrete-haskell-autogen
+
conduit conduit-combinators conduit-extra containers
+
cryptohash-conduit deepseq directory filepath hashable lens
+
megaparsec monad-extras mtl network optparse-generic path path-io
+
process QuickCheck scientific stm tar tar-conduit text thrift time
+
unordered-containers uuid vector zip zip-conduit zlib
+
base binary bytestring bzlib bzlib-conduit concrete-haskell-autogen
+
conduit conduit-combinators conduit-extra containers
+
cryptohash-conduit deepseq directory filepath hashable lens
+
megaparsec monad-extras mtl network optparse-generic path path-io
+
process QuickCheck scientific stm tar tar-conduit text thrift time
+
unordered-containers uuid vector zip zip-conduit zlib
homepage = "https://github.com/hltcoe";
description = "Library for the Concrete data format";
···
license = stdenv.lib.licenses.mit;
+
"conduit-combinators_1_1_2" = callPackage
+
({ mkDerivation, base, base16-bytestring, base64-bytestring
+
, bytestring, chunked-data, conduit, conduit-extra, containers
+
, directory, filepath, hspec, monad-control, mono-traversable, mtl
+
, mwc-random, primitive, QuickCheck, resourcet, safe, silently
+
, text, transformers, transformers-base, unix, unix-compat, vector
+
pname = "conduit-combinators";
+
sha256 = "0f31iphdi31m7cfd2szq06x3xdag1kkv2vbxh6bm2ax37k9sw2w4";
+
libraryHaskellDepends = [
+
base base16-bytestring base64-bytestring bytestring chunked-data
+
conduit conduit-extra filepath monad-control mono-traversable
+
mwc-random primitive resourcet text transformers transformers-base
+
unix unix-compat vector void
+
base base16-bytestring base64-bytestring bytestring chunked-data
+
conduit containers directory filepath hspec mono-traversable mtl
+
mwc-random QuickCheck safe silently text transformers vector
+
homepage = "https://github.com/snoyberg/mono-traversable#readme";
+
description = "Commonly used conduit functions, for both chunked and unchunked data";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"conduit-connection" = callPackage
({ mkDerivation, base, bytestring, conduit, connection, HUnit
, network, resourcet, test-framework, test-framework-hunit
···
license = stdenv.lib.licenses.mit;
+
"conduit-extra_1_2_1" = callPackage
({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
, bytestring-builder, conduit, criterion, directory, exceptions
, filepath, hspec, monad-control, network, primitive, process
, QuickCheck, resourcet, stm, streaming-commons, text, transformers
+
, transformers-base, typed-process, unliftio-core
+
sha256 = "10sdnnjwk9wmj7fsjdnz4isbqibdhws54igy420c2q5m4alkzsgk";
libraryHaskellDepends = [
async attoparsec base blaze-builder bytestring conduit directory
exceptions filepath monad-control network primitive process
resourcet stm streaming-commons text transformers transformers-base
+
typed-process unliftio-core
async attoparsec base blaze-builder bytestring bytestring-builder
···
libraryHaskellDepends = [ base category ];
description = "Reified constraints";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"constraint-classes" = callPackage
···
homepage = "https://github.com/cblp/crdt#readme";
description = "Conflict-free replicated data types";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
···
license = stdenv.lib.licenses.bsd3;
+
"criterion_1_2_6_0" = callPackage
({ mkDerivation, aeson, ansi-wl-pprint, base, base-compat, binary
, bytestring, cassava, code-page, containers, deepseq, directory
, exceptions, filepath, Glob, HUnit, js-flot, js-jquery
···
+
sha256 = "0a9pjmy74cd3yirihyabavsfa6b9rrrgav86qdagw5nwjw7as1bc";
enableSeparateDataOutput = true;
···
sha256 = "0lrm0sal5pl453mkqn8b9fc9l7lwinc140iqihya9g17bk408nrm";
+
editedCabalFile = "0if3ww0xhi8k5c8a9yb687gjjdp2k4q2896qn7vgwwzg360slx8n";
configureFlags = [ "-fforce-char8-encoding" "-flibrary" ];
···
license = stdenv.lib.licenses.bsd3;
+
"data-serializer_0_3_2" = callPackage
+
({ mkDerivation, base, binary, bytestring, cereal, data-endian
+
, parsers, semigroups, split, tasty, tasty-quickcheck
+
pname = "data-serializer";
+
sha256 = "055a4kqwg6cqx9a58i7m59jp70s4mmm2q73wa78jzp87lnh2646l";
+
libraryHaskellDepends = [
+
base binary bytestring cereal data-endian parsers semigroups split
+
base binary bytestring cereal tasty tasty-quickcheck
+
homepage = "https://github.com/mvv/data-serializer";
+
description = "Common API for serialization libraries";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"data-size" = callPackage
({ mkDerivation, base, bytestring, containers, deepseq, text }:
···
hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
+
"dejafu_0_9_1_1" = callPackage
({ mkDerivation, base, concurrency, containers, deepseq, exceptions
, leancheck, random, ref-fd, transformers, transformers-base
+
sha256 = "0ipi2i80xkprrmvapm9z4pfs7r05zk408fg7npcxq4i8k77rvz8z";
libraryHaskellDepends = [
base concurrency containers deepseq exceptions leancheck random
ref-fd transformers transformers-base
···
license = stdenv.lib.licenses.bsd3;
+
"deriving-compat_0_4" = callPackage
+
({ mkDerivation, base, base-compat, base-orphans, containers
+
, ghc-boot-th, ghc-prim, hspec, QuickCheck, tagged
+
, template-haskell, th-abstraction, transformers
+
pname = "deriving-compat";
+
sha256 = "1jza92p1x3dbm4gx891miaihq3ly30mlz20ddwdsz0xyk7c1wk15";
+
libraryHaskellDepends = [
+
base containers ghc-boot-th ghc-prim template-haskell
+
th-abstraction transformers transformers-compat
+
base base-compat base-orphans hspec QuickCheck tagged
+
template-haskell transformers transformers-compat
+
homepage = "https://github.com/haskell-compat/deriving-compat";
+
description = "Backports of GHC deriving extensions";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
({ mkDerivation, base, containers }:
···
pname = "diagrams-rubiks-cube";
+
sha256 = "10j9zag6b5mlhhmd3j0p2vxpm26rhm74ihs8xjcwh77xkywbfi7z";
libraryHaskellDepends = [
adjunctions base data-default-class diagrams-lib distributive lens
···
homepage = "https://github.com/andrewthad/disjoint-containers#readme";
description = "Disjoint containers";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"disjoint-set" = callPackage
···
sha256 = "0y566r97sfyvhsmd4yxiz4ns2mqgwf5bdbp56wgxl6wlkidq0wwi";
+
editedCabalFile = "02j27xvlj0jw3b2jpfg6wbysj0blllin792wj6qnrgnrvd4haj7v";
setupHaskellDepends = [ base Cabal cabal-doctest ];
libraryHaskellDepends = [
base base-orphans tagged transformers transformers-compat
···
description = "Builds a services with docker and caches all of its intermediate stages";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"dockercook" = callPackage
···
+
({ mkDerivation, base, MonadRandom, transformers, transformers-base
+
sha256 = "05xqhbz0x7wzfka4wl2wvfhzr242nx4ci4r3zvm89mcyxn9q7x6n";
+
libraryHaskellDepends = [
+
base MonadRandom transformers transformers-base
homepage = "https://github.com/ivanperez-keera/dunai";
description = "Generalised reactive framework supporting classic, arrowized and monadic FRP";
license = stdenv.lib.licenses.bsd3;
···
"easyrender" = callPackage
+
({ mkDerivation, base, bytestring, Cabal, containers, mtl, superdoc
+
sha256 = "105s3d5yz7qz9cv5jq005kzd7jfdn2fccnc4s1xgkszk46y83qbx";
+
setupHaskellDepends = [ base Cabal superdoc ];
+
libraryHaskellDepends = [ base bytestring containers mtl zlib ];
homepage = "http://www.mathstat.dal.ca/~selinger/easyrender/";
description = "User-friendly creation of EPS, PostScript, and PDF files";
license = stdenv.lib.licenses.gpl3;
···
homepage = "https://github.com/adinapoli/ekg-prometheus-adapter#readme";
description = "Easily expose your EKG metrics to Prometheus";
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
···
"errors-ext" = callPackage
+
({ mkDerivation, base, errors, exceptions, HUnit, monad-control
+
sha256 = "1xly8pgkbqkm4mb1zg9bga08gx5fj4nrmidzj5p8anqdksq7ib5h";
+
libraryHaskellDepends = [
+
base errors exceptions monad-control mtl transformers
+
base errors exceptions HUnit monad-control mtl transformers
homepage = "https://github.com/A1-Triard/errors-ext#readme";
+
description = "`bracket`-like functions for `ExceptT` over `IO` monad";
license = stdenv.lib.licenses.asl20;
···
license = stdenv.lib.licenses.bsd3;
+
"extra_1_6_2" = callPackage
({ mkDerivation, base, clock, directory, filepath, process
+
sha256 = "1l8l8724g3kd3f01pq429y7czr1bnhbrq2y0lii1hi767sjxgnz4";
libraryHaskellDepends = [
base clock directory filepath process time unix
+
testHaskellDepends = [ base directory filepath QuickCheck unix ];
homepage = "https://github.com/ndmitchell/extra#readme";
description = "Extra functions I use";
license = stdenv.lib.licenses.bsd3;
···
license = stdenv.lib.licenses.gpl3;
+
"fedora-haskell-tools_0_4" = callPackage
+
({ mkDerivation, base, directory, filepath, process, time, unix }:
+
pname = "fedora-haskell-tools";
+
sha256 = "0105i1klks1f0gcq9fyv1pbfrm3mfiwp14pdac0xb8hm1fbhbs70";
+
executableHaskellDepends = [
+
base directory filepath process time unix
+
homepage = "https://github.com/fedora-haskell/fedora-haskell-tools";
+
description = "Building and managing tools for Fedora Haskell";
+
license = stdenv.lib.licenses.gpl3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"fedora-packages" = callPackage
({ mkDerivation, aeson, base, bytestring, containers, hlint
, HsOpenSSL, hspec, http-streams, io-streams, lens, text
···
homepage = "https://github.com/ChrisPenner/Firefly#readme";
description = "A simple example using Firefly";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"first-and-last" = callPackage
···
+
({ mkDerivation, base, constraints, ghc-prim, tasty
+
sha256 = "1sdwcjjsgq0ba84474pdnvppg66vmqsqn6frb97ricdnyy78lg11";
+
libraryHaskellDepends = [ base constraints ghc-prim ];
testHaskellDepends = [ base tasty tasty-quickcheck ];
homepage = "https://github.com/k0001/flay";
+
description = "Work generically on your datatype without knowing its shape nor its contents";
license = stdenv.lib.licenses.bsd3;
···
description = "A simple web application as a online practice website for XDU SE 2017 fall SPM";
license = stdenv.lib.licenses.gpl3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"fluffy-parser" = callPackage
···
description = "The parser for fluffy to parsec the question bank in .docx type";
license = stdenv.lib.licenses.gpl3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"fluid-idl" = callPackage
···
license = stdenv.lib.licenses.bsd3;
+
"freer-simple" = callPackage
+
({ mkDerivation, base, criterion, extensible-effects, free, mtl
+
, natural-transformation, QuickCheck, tasty, tasty-hunit
+
, tasty-quickcheck, transformers-base
+
pname = "freer-simple";
+
sha256 = "11nh0majlmn6aw5qzv5jfs6jx9vxk7jn72568frmryvymn2aqax8";
+
libraryHaskellDepends = [
+
base natural-transformation transformers-base
+
executableHaskellDepends = [ base ];
+
base QuickCheck tasty tasty-hunit tasty-quickcheck
+
benchmarkHaskellDepends = [
+
base criterion extensible-effects free mtl
+
homepage = "https://github.com/lexi-lambda/freer-simple#readme";
+
description = "Implementation of a friendly effect system for Haskell";
+
license = stdenv.lib.licenses.bsd3;
({ mkDerivation, array, base, cpphs, directory, mtl, parallel
···
license = stdenv.lib.licenses.bsd3;
+
"generic-deriving_1_12" = callPackage
+
({ mkDerivation, base, containers, ghc-prim, hspec
+
pname = "generic-deriving";
+
sha256 = "09nl2c2b54ngqv4rgv3avvallyvfnv5jfld0wk2v90srl3x6p5vk";
+
libraryHaskellDepends = [
+
base containers ghc-prim template-haskell
+
testHaskellDepends = [ base hspec template-haskell ];
+
homepage = "https://github.com/dreixel/generic-deriving";
+
description = "Generic programming library for generalised deriving";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"generic-enum" = callPackage
({ mkDerivation, array, base, bytestring, hspec }:
···
"generic-lens" = callPackage
+
({ mkDerivation, base, criterion, deepseq, doctest
+
, inspection-testing, lens, profunctors, QuickCheck, tagged
+
sha256 = "0jp6qy45j7cg251pxq5x4ygg6m7gc6v57nd8ky26r18g9wn9f7w3";
+
libraryHaskellDepends = [ base profunctors tagged ];
+
testHaskellDepends = [ base doctest inspection-testing ];
benchmarkHaskellDepends = [
base criterion deepseq lens QuickCheck
···
pname = "generic-xmlpickler";
sha256 = "1brnlgnbys811qy64aps2j03ks2p0rkihaqzaszfwl80cpsn05ym";
+
editedCabalFile = "0zcrn8n12fk36iacg0c429ras6pbr96c1zxjbnf5jiq7ajwnd8ri";
libraryHaskellDepends = [ base generic-deriving hxt text ];
base hxt hxt-pickle-utils tasty tasty-hunit tasty-th
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"ghc-boot_8_2_2" = callPackage
({ mkDerivation, base, binary, bytestring, directory, filepath
+
sha256 = "0fwpfsdx584mcvavj1m961rnaryif9a0yibhlw0b2i59g3ca8f6g";
libraryHaskellDepends = [
base binary bytestring directory filepath ghc-boot-th
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"ghc-boot-th_8_2_2" = callPackage
+
sha256 = "0pdgimqqn1w04qw504bgcji74wj5wmxpwgj5w3wdrid47sr2d3kc";
libraryHaskellDepends = [ base ];
description = "Shared functionality between GHC and the @template-haskell@ library";
license = stdenv.lib.licenses.bsd3;
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"ghci_8_2_2" = callPackage
({ mkDerivation, array, base, binary, bytestring, containers
, deepseq, filepath, ghc-boot, ghc-boot-th, template-haskell
+
sha256 = "0j6aq2scjv0fpr5b60ac46r1n2hrcgbkrhv31yfnallwlwyqz5zn";
libraryHaskellDepends = [
array base binary bytestring containers deepseq filepath ghc-boot
ghc-boot-th template-haskell transformers unix
···
hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
}) {gtk3 = pkgs.gnome3.gtk;};
+
"gi-gtk_3_0_18" = callPackage
+
({ mkDerivation, base, bytestring, Cabal, containers, gi-atk
+
, gi-cairo, gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject
+
, gi-pango, gtk3, haskell-gi, haskell-gi-base
+
, haskell-gi-overloading, text, transformers
+
sha256 = "1fp84dba8hg6pvkdy0mip2pz9npx0kwp492gx8p1bgf119rqqfl1";
+
setupHaskellDepends = [ base Cabal haskell-gi ];
+
libraryHaskellDepends = [
+
base bytestring containers gi-atk gi-cairo gi-gdk gi-gdkpixbuf
+
gi-gio gi-glib gi-gobject gi-pango haskell-gi haskell-gi-base
+
haskell-gi-overloading text transformers
+
libraryPkgconfigDepends = [ gtk3 ];
+
homepage = "https://github.com/haskell-gi/haskell-gi";
+
description = "Gtk bindings";
+
license = stdenv.lib.licenses.lgpl21;
+
hydraPlatforms = stdenv.lib.platforms.none;
+
}) {gtk3 = pkgs.gnome3.gtk;};
"gi-gtk-hs" = callPackage
({ mkDerivation, base, base-compat, containers, gi-gdk
, gi-gdkpixbuf, gi-glib, gi-gobject, gi-gtk, haskell-gi-base, mtl
···
sha256 = "0i4cs6d95ik5c8zs2508nmhjh2v30a0qjyxfqyxhjsz48p9h5p1i";
+
editedCabalFile = "1krz0plxhm1q1k7bb0wzl969zd5fqkgqcgfr6rmqw60njpwrdsrp";
libraryHaskellDepends = [
aeson aeson-compat base base-compat base16-bytestring binary
binary-orphans byteable bytestring containers cryptohash deepseq
···
homepage = "https://github.com/tfausak/github-release#readme";
description = "Upload files to GitHub releases";
license = stdenv.lib.licenses.mit;
+
"github-release_1_1_0" = callPackage
+
({ mkDerivation, aeson, base, bytestring, http-client
+
, http-client-tls, http-types, mime-types, optparse-generic, text
+
, unordered-containers, uri-templater
+
pname = "github-release";
+
sha256 = "1a3a7pil5k0danybcfk19b4rql5s4alrlbprgq9053npb2369js2";
+
libraryHaskellDepends = [
+
aeson base bytestring http-client http-client-tls http-types
+
mime-types optparse-generic text unordered-containers uri-templater
+
executableHaskellDepends = [ base ];
+
homepage = "https://github.com/tfausak/github-release#readme";
+
description = "Upload files to GitHub releases";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"github-tools" = callPackage
···
pname = "gnss-converters";
+
sha256 = "1ps3jjlf9igqmllyapqznzxjkf7291i7zv8w86p2fnm6wxsd73q9";
libraryHaskellDepends = [
···
license = stdenv.lib.licenses.bsd3;
+
"groundhog-th_0_8_0_2" = callPackage
+
({ mkDerivation, aeson, base, bytestring, containers, groundhog
+
, template-haskell, text, time, unordered-containers, yaml
+
pname = "groundhog-th";
+
sha256 = "13rxdmnbmsivp608xclkvjnab0dzhzyqc8zjrpm7ml9d5yc8v596";
+
libraryHaskellDepends = [
+
aeson base bytestring containers groundhog template-haskell text
+
time unordered-containers yaml
+
description = "Type-safe datatype-database mapping library";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"group-by-date" = callPackage
({ mkDerivation, base, explicit-exception, filemanip, hsshellscript
, pathtype, time, transformers, unix-compat, utility-ht
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"gym-http-api" = callPackage
+
({ mkDerivation, aeson, base, exceptions, http-client, servant
+
, servant-client, servant-lucid, text, unordered-containers
+
pname = "gym-http-api";
+
sha256 = "0id8npw9ziqibm0j5fqkjw7r75la2cd4zlyzsk90rpx2xf5xy20p";
+
libraryHaskellDepends = [
+
aeson base servant servant-client servant-lucid text
+
executableHaskellDepends = [
+
base exceptions http-client servant-client
+
homepage = "https://github.com/stites/gym-http-api#readme";
+
description = "REST client to the gym-http-api project";
+
license = stdenv.lib.licenses.mit;
({ mkDerivation, base, bytestring, containers, directory, filepath
, http-conduit, hxt, mtl, stm, template-haskell, transformers
···
license = stdenv.lib.licenses.mit;
+
"hapistrano_0_3_5_0" = callPackage
+
({ mkDerivation, aeson, async, base, directory, filepath, hspec
+
, mtl, optparse-applicative, path, path-io, process, stm, temporary
+
, time, transformers, yaml
+
sha256 = "15cjssws55awwq8j0xz8f4dd0y826f99zdv6mpxfxq97fah7zlcc";
+
enableSeparateDataOutput = true;
+
libraryHaskellDepends = [
+
base filepath mtl path process time transformers
+
executableHaskellDepends = [
+
aeson async base optparse-applicative path path-io stm yaml
+
base directory filepath hspec mtl path path-io process temporary
+
homepage = "https://github.com/stackbuilders/hapistrano";
+
description = "A deployment library for Haskell applications";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"happindicator" = callPackage
({ mkDerivation, array, base, bytestring, containers, glib, gtk
, gtk2hs-buildtools, libappindicator-gtk2, mtl
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"haskeline_0_7_4_2" = callPackage
({ mkDerivation, base, bytestring, containers, directory, filepath
, process, stm, terminfo, transformers, unix
+
sha256 = "1sxhdhy9asinxn0gvd4zandbk6xkb04vy1y7lmh66f9jv66fqhsm";
configureFlags = [ "-fterminfo" ];
libraryHaskellDepends = [
base bytestring containers directory filepath process stm terminfo
···
license = stdenv.lib.licenses.publicDomain;
+
"haskell-holes-th" = callPackage
+
({ mkDerivation, base, template-haskell }:
+
pname = "haskell-holes-th";
+
sha256 = "13xyxck9f15mwi641zs9zw77cnrgh30p2771f66haby96k8wx9jf";
+
libraryHaskellDepends = [ base template-haskell ];
+
homepage = "https://github.com/8084/haskell-holes-th";
+
description = "Infer haskell code by given type";
+
license = stdenv.lib.licenses.mit;
"haskell-igraph" = callPackage
({ mkDerivation, base, binary, bytestring, bytestring-lexing, c2hs
, colour, data-default-class, data-ordlist, hashable, hxt, igraph
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"haskell-src-exts_1_20_0" = callPackage
+
({ mkDerivation, array, base, containers, cpphs, directory
+
, filepath, ghc-prim, happy, mtl, pretty, pretty-show, smallcheck
+
, tasty, tasty-golden, tasty-smallcheck
+
pname = "haskell-src-exts";
+
sha256 = "0fsbcrjf4m8zd759hsqjm29mnarmkf44aln903g7ipj7rkxyl8lx";
+
libraryHaskellDepends = [ array base cpphs ghc-prim pretty ];
+
libraryToolDepends = [ happy ];
+
base containers directory filepath mtl pretty-show smallcheck tasty
+
tasty-golden tasty-smallcheck
+
homepage = "https://github.com/haskell-suite/haskell-src-exts";
+
description = "Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"haskell-src-exts-observe" = callPackage
({ mkDerivation, base, haskell-src-exts, Hoed }:
···
license = stdenv.lib.licenses.bsd3;
+
"haskell-tools-ast_1_0_0_1" = callPackage
({ mkDerivation, base, ghc, mtl, references, template-haskell
pname = "haskell-tools-ast";
+
sha256 = "0i84hv1hvsf7z9jl11m0ic0ja6m46dw58zjrdmllmmravnfw5j5g";
libraryHaskellDepends = [
base ghc mtl references template-haskell uniplate
···
license = stdenv.lib.licenses.bsd3;
+
"haskell-tools-backend-ghc_1_0_0_1" = callPackage
({ mkDerivation, base, bytestring, containers, ghc, ghc-boot-th
, haskell-tools-ast, mtl, references, safe, split, template-haskell
pname = "haskell-tools-backend-ghc";
+
sha256 = "1cfwy1qcvk72pspvgf9yq3i8z0n2payhir9f2spvqyxxd6pgyvsa";
libraryHaskellDepends = [
base bytestring containers ghc ghc-boot-th haskell-tools-ast mtl
references safe split template-haskell transformers uniplate
···
pname = "haskell-tools-builtin-refactorings";
+
sha256 = "0c3gnf8chg6c7cprx148x2h10miysq0d4m0q1snhhhnqpd9vxws0";
libraryHaskellDepends = [
base Cabal containers directory filepath ghc ghc-paths
haskell-tools-ast haskell-tools-backend-ghc
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"haskell-tools-cli_1_0_0_1" = callPackage
({ mkDerivation, aeson, base, bytestring, containers, criterion
, directory, filepath, ghc, ghc-paths, Glob
, haskell-tools-builtin-refactorings, haskell-tools-daemon
···
pname = "haskell-tools-cli";
+
sha256 = "0qh0fsrqxlc6bqsz2c11isywd451l0nxndk5p4s6hkq88m6yrkic";
libraryHaskellDepends = [
···
license = stdenv.lib.licenses.bsd3;
+
"haskell-tools-daemon_1_0_0_1" = callPackage
({ mkDerivation, aeson, base, bytestring, Cabal, containers
, deepseq, Diff, directory, filepath, fswatch, ghc, ghc-paths, Glob
, haskell-tools-builtin-refactorings, haskell-tools-prettyprint
···
pname = "haskell-tools-daemon";
+
sha256 = "0hjafm57619xsfzzcqsyj2ksbhg70m011vv9q2w5rpbzk5jzrlk8";
libraryHaskellDepends = [
···
license = stdenv.lib.licenses.bsd3;
+
"haskell-tools-debug_1_0_0_1" = callPackage
({ mkDerivation, base, filepath, ghc, ghc-paths, haskell-tools-ast
, haskell-tools-backend-ghc, haskell-tools-builtin-refactorings
, haskell-tools-prettyprint, haskell-tools-refactor, references
···
pname = "haskell-tools-debug";
+
sha256 = "1j0v0hdkmd01cg4pk1as27ws8krgvpswmqfcj06dzkx81f0a4fn3";
libraryHaskellDepends = [
···
license = stdenv.lib.licenses.bsd3;
+
"haskell-tools-demo_1_0_0_1" = callPackage
({ mkDerivation, aeson, base, bytestring, containers, directory
, filepath, ghc, ghc-paths, haskell-tools-ast
, haskell-tools-backend-ghc, haskell-tools-builtin-refactorings
···
pname = "haskell-tools-demo";
+
sha256 = "121dggqzhv8w80xh8cjl8hqds511sgp8ai86fjfrqcvs3zwy16da";
libraryHaskellDepends = [
···
pname = "haskell-tools-experimental-refactorings";
+
sha256 = "1rpyzl22jiwvjp2k3w7pg51i5n6idr9d29xqll25h17h56lzqa2j";
libraryHaskellDepends = [
base Cabal containers directory filepath ghc ghc-paths
haskell-tools-ast haskell-tools-backend-ghc
···
license = stdenv.lib.licenses.bsd3;
+
"haskell-tools-prettyprint_1_0_0_1" = callPackage
({ mkDerivation, base, containers, ghc, haskell-tools-ast, mtl
, references, split, text, uniplate
pname = "haskell-tools-prettyprint";
+
sha256 = "1jdrzwr8gc878s3nkqhqhcwpp4kadi1mi7wk704qn4lls61q59ia";
libraryHaskellDepends = [
base containers ghc haskell-tools-ast mtl references split text
···
license = stdenv.lib.licenses.bsd3;
+
"haskell-tools-refactor_1_0_0_1" = callPackage
({ mkDerivation, base, Cabal, containers, directory, filepath, ghc
, ghc-paths, haskell-tools-ast, haskell-tools-backend-ghc
, haskell-tools-prettyprint, haskell-tools-rewrite, mtl, references
···
pname = "haskell-tools-refactor";
+
sha256 = "1d9w811n8dhnsgpvvh3v7wm0fywiv7qmd1652kjn4cazc4sfzyn5";
libraryHaskellDepends = [
base Cabal containers directory filepath ghc ghc-paths
haskell-tools-ast haskell-tools-backend-ghc
···
license = stdenv.lib.licenses.bsd3;
+
"haskell-tools-rewrite_1_0_0_1" = callPackage
({ mkDerivation, base, containers, directory, filepath, ghc
, haskell-tools-ast, haskell-tools-prettyprint, mtl, references
pname = "haskell-tools-rewrite";
+
sha256 = "1sv6z3qm6vyjpm7mh1clyikcvzgq3x9l1clgqi4vrs0lcr3npand";
libraryHaskellDepends = [
base containers ghc haskell-tools-ast haskell-tools-prettyprint mtl
···
pname = "hasql-optparse-applicative";
+
sha256 = "05i9hij1z67l1sc53swwcmd88544dypc3qkzkh8f4n6nlmv82190";
libraryHaskellDepends = [
base-prelude hasql hasql-pool optparse-applicative
···
license = stdenv.lib.licenses.bsd3;
+
"hedgehog_0_5_1" = callPackage
+
({ mkDerivation, ansi-terminal, async, base, bytestring
+
, concurrent-output, containers, directory, exceptions
+
, lifted-async, mmorph, monad-control, mtl, pretty-show, primitive
+
, random, resourcet, stm, template-haskell, text, th-lift, time
+
, transformers, transformers-base, unix, wl-pprint-annotated
+
sha256 = "0fx3dq45azxrhihhq6hlb89zkj3y8fmnfdrsz1wbvih9a3dhiwx7";
+
libraryHaskellDepends = [
+
ansi-terminal async base bytestring concurrent-output containers
+
directory exceptions lifted-async mmorph monad-control mtl
+
pretty-show primitive random resourcet stm template-haskell text
+
th-lift time transformers transformers-base unix
+
base containers pretty-show text transformers
+
homepage = "https://hedgehog.qa";
+
description = "Hedgehog will eat all your bugs";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"hedgehog-quickcheck" = callPackage
({ mkDerivation, base, hedgehog, QuickCheck, transformers }:
···
({ mkDerivation, base, containers }:
+
sha256 = "1bx49z3ycc24bsn0x0617x0gmgapan6qnwnwq6v0w06gjrahr4r4";
libraryHaskellDepends = [ base containers ];
homepage = "https://github.com/mniip/hexchat-haskell";
description = "Haskell scripting interface for HexChat";
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
···
+
sha256 = "08lry3bxppnxr1mqpsbplq041nf2c5aaaim4iqhrapvqwwca7n5v";
executableHaskellDepends = [
···
({ mkDerivation, base, containers, template-haskell, text }:
+
sha256 = "0lmjgwgfp1s2ag2fbi6n8yryafb5qz87yb0p122lxzm3487sf98h";
libraryHaskellDepends = [ base containers template-haskell text ];
homepage = "http://github.com/errge/hflags";
description = "Command line flag parser, very similar to Google's gflags";
···
sha256 = "0rm6091nlpijhi6k74dg35g38a7ly22mqfnb0mvjp8pyxb4phq33";
+
editedCabalFile = "0diprhzbql32yvbby4fz9lx4i8khd553s18vsfk537zkjrcsalbc";
enableSeparateDataOutput = true;
···
+
sha256 = "11p207fmkfkc6jimnq9y30xj3l1msc5r090qvg1klmyvmhjkh702";
libraryHaskellDepends = [
···
homepage = "https://github.com/awakesecurity/hocker#readme";
description = "Interact with the docker registry and generate nix build instructions";
license = stdenv.lib.licenses.asl20;
+
hydraPlatforms = stdenv.lib.platforms.none;
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"hpack_0_21_0" = callPackage
+
({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal
+
, containers, cryptonite, deepseq, directory, filepath, Glob, hspec
+
, HUnit, interpolate, mockery, pretty, QuickCheck, temporary, text
+
, transformers, unordered-containers, yaml
+
sha256 = "004n0p3ljvaindaxjnadija16fwkjfv6s80acpps2ky2frnfbplp";
+
libraryHaskellDepends = [
+
aeson base bifunctors bytestring Cabal containers cryptonite
+
deepseq directory filepath Glob pretty text transformers
+
unordered-containers yaml
+
executableHaskellDepends = [
+
aeson base bifunctors bytestring Cabal containers cryptonite
+
deepseq directory filepath Glob pretty text transformers
+
unordered-containers yaml
+
aeson base bifunctors bytestring Cabal containers cryptonite
+
deepseq directory filepath Glob hspec HUnit interpolate mockery
+
pretty QuickCheck temporary text transformers unordered-containers
+
homepage = "https://github.com/sol/hpack#readme";
+
description = "An alternative format for Haskell packages";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"hpack-convert" = callPackage
({ mkDerivation, aeson, aeson-qq, base, base-compat, bytestring
, Cabal, containers, deepseq, directory, filepath, Glob, hspec
···
license = stdenv.lib.licenses.bsd3;
+
"hpp_0_5_1" = callPackage
+
({ mkDerivation, base, bytestring, bytestring-trie, directory
+
, filepath, ghc-prim, time, transformers
+
sha256 = "0bdx85k9c9cb5wkp91fi1sb0dahg6f4fknyddfh92wcywa485q9b";
+
libraryHaskellDepends = [
+
base bytestring bytestring-trie directory filepath ghc-prim time
+
executableHaskellDepends = [ base directory filepath time ];
+
testHaskellDepends = [ base bytestring transformers ];
+
homepage = "https://github.com/acowley/hpp";
+
description = "A Haskell pre-processor";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
({ mkDerivation, aeson, base, bytestring, containers
, data-default-class, exceptions, HUnit, lifted-base, monad-control
···
pname = "hpqtypes-extras";
+
sha256 = "1hp9nn49a8kg58y8cywsiwcy64zq65c1hnsn2xi5ajk71hag8b8c";
libraryHaskellDepends = [
base base16-bytestring bytestring containers cryptohash exceptions
fields-json hpqtypes lifted-base log-base monad-control mtl safe
···
homepage = "http://rd.slavepianos.org/t/hsc3-auditor";
description = "Haskell SuperCollider Auditor";
+
hydraPlatforms = stdenv.lib.platforms.none;
"hsc3-cairo" = callPackage
···
"hsemail-ns" = callPackage
+
({ mkDerivation, base, doctest, hspec, mtl, old-time, parsec }:
+
sha256 = "01vnlcv5gj7zj33b6m8mc4n6n8d15casywgicn1lr699hkh287hg";
libraryHaskellDepends = [ base mtl old-time parsec ];
+
testHaskellDepends = [ base doctest hspec old-time parsec ];
+
homepage = "https://github.com/phlummox/hsemail-ns/tree/hsemail-ns";
description = "Internet Message Parsers";
license = stdenv.lib.licenses.bsd3;
hydraPlatforms = stdenv.lib.platforms.none;
···
license = stdenv.lib.licenses.mit;
}) {inherit (pkgs) lua5_1;};
+
"hslua_0_9_3" = callPackage
({ mkDerivation, base, bytestring, containers, exceptions, fail
, lua5_1, mtl, QuickCheck, quickcheck-instances, tasty
, tasty-expected-failure, tasty-hunit, tasty-quickcheck, text
+
sha256 = "1ml64f8faz17qfp0wm9fqgribcf8fvyhazjk9a1385fsjy96ks8m";
configureFlags = [ "-fsystem-lua" ];
libraryHaskellDepends = [
base bytestring containers exceptions fail mtl text
···
license = stdenv.lib.licenses.bsd3;
+
"hspec-golden-aeson_0_4_0_0" = callPackage
({ mkDerivation, aeson, aeson-pretty, base, bytestring, directory
, filepath, hspec, hspec-core, QuickCheck, quickcheck-arbitrary-adt
, random, silently, transformers
pname = "hspec-golden-aeson";
+
sha256 = "03gsw9jamkjwj5vhlhg9xz7214d71py94qx0daym7gjiq4zpw1gk";
libraryHaskellDepends = [
aeson aeson-pretty base bytestring directory filepath hspec
QuickCheck quickcheck-arbitrary-adt random transformers
···
homepage = "https://github.com/yamadapc/haskell-hspec-setup";
description = "Add an hspec test-suite in one command";
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"hspec-shouldbe" = callPackage
···
hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
+
"hsshellscript_3_4_5" = callPackage
({ mkDerivation, base, c2hs, directory, parsec, random, unix }:
+
sha256 = "0d66gsm7s2j4f60cjca6fsddg4i1m3l6rcyq29ywskifhfaxbgvx";
libraryHaskellDepends = [ base directory parsec random unix ];
libraryToolDepends = [ c2hs ];
homepage = "http://www.volker-wysk.de/hsshellscript/";
···
+
sha256 = "09kr9mcjd41xl5an8ddfrcyx8dc1fgfq70mkw6m96dvcmhryf0gv";
libraryHaskellDepends = [
base bytestring hsyslog hsyslog-udp network text time
···
+
sha256 = "0z4jpgdp5brfpzw5xawwxx7i239xjxgr1rjvrv2fyd6d6ixg3gwl";
libraryHaskellDepends = [
base bytestring hsyslog network text time unix
···
license = stdenv.lib.licenses.bsd3;
+
"http-conduit_2_2_4" = callPackage
+
({ mkDerivation, aeson, base, blaze-builder, bytestring
+
, case-insensitive, conduit, conduit-extra, connection, cookie
+
, data-default-class, exceptions, hspec, http-client
+
, http-client-tls, http-types, HUnit, lifted-base, monad-control
+
, mtl, network, resourcet, streaming-commons, temporary, text, time
+
, transformers, utf8-string, wai, wai-conduit, warp, warp-tls
+
pname = "http-conduit";
+
sha256 = "1wcl3lpg4v1ylq9j77j9fmf6l9qbmp8dmj3a9829q19q6bbgza7l";
+
libraryHaskellDepends = [
+
aeson base bytestring conduit conduit-extra exceptions http-client
+
http-client-tls http-types lifted-base monad-control mtl resourcet
+
aeson base blaze-builder bytestring case-insensitive conduit
+
conduit-extra connection cookie data-default-class hspec
+
http-client http-types HUnit lifted-base network resourcet
+
streaming-commons temporary text time transformers utf8-string wai
+
wai-conduit warp warp-tls
+
homepage = "http://www.yesodweb.com/book/http-conduit";
+
description = "HTTP client package with conduit interface and HTTPS support";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"http-conduit-browser" = callPackage
({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
, case-insensitive, conduit, containers, cookie, data-default
···
license = stdenv.lib.licenses.bsd3;
+
"http-streams_0_8_5_5" = callPackage
+
({ mkDerivation, aeson, aeson-pretty, attoparsec, base
+
, base64-bytestring, blaze-builder, bytestring, Cabal
+
, case-insensitive, directory, ghc-prim, HsOpenSSL, hspec
+
, hspec-expectations, http-common, HUnit, io-streams, lifted-base
+
, mtl, network, network-uri, openssl-streams, snap-core
+
, snap-server, system-fileio, system-filepath, text, transformers
+
pname = "http-streams";
+
sha256 = "1g2ygxyfq2x923df5q83wkrwhy2631r33zvffgj3fn0zwr024hhf";
+
setupHaskellDepends = [ base Cabal ];
+
libraryHaskellDepends = [
+
aeson attoparsec base base64-bytestring blaze-builder bytestring
+
case-insensitive directory HsOpenSSL http-common io-streams mtl
+
network network-uri openssl-streams text transformers
+
aeson aeson-pretty attoparsec base base64-bytestring blaze-builder
+
bytestring case-insensitive directory ghc-prim HsOpenSSL hspec
+
hspec-expectations http-common HUnit io-streams lifted-base mtl
+
network network-uri openssl-streams snap-core snap-server
+
system-fileio system-filepath text transformers
+
homepage = "http://github.com/afcowie/http-streams/";
+
description = "An HTTP client using io-streams";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"http-test" = callPackage
({ mkDerivation, aeson, base, bytestring, http-client, lens
, lens-aeson, mtl, tasty, tasty-hunit, text, time, wreq
···
pname = "hw-kafka-client";
+
sha256 = "1wc6vngnjgpmkhiq4zfn1plqf0q636nsr5nkvmq20rzlg35w8az9";
libraryHaskellDepends = [
···
homepage = "http://www.idris-lang.org/";
description = "Functional Programming Language with Dependent Types";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
}) {inherit (pkgs) gmp;};
···
license = stdenv.lib.licenses.bsd3;
+
"inline-java_0_7_1" = callPackage
({ mkDerivation, base, bytestring, Cabal, directory, filepath, ghc
, hspec, jni, jvm, language-java, mtl, process, template-haskell
+
sha256 = "000qzhjg2qah379dlhshgxqzm4mslcv6d5cwqycvx8q3hxginv08";
libraryHaskellDepends = [
base bytestring Cabal directory filepath ghc jni jvm language-java
mtl process template-haskell temporary text
···
license = stdenv.lib.licenses.bsd3;
+
"integer-gmp_1_0_1_0" = callPackage
({ mkDerivation, ghc-prim }:
+
sha256 = "1xrdqksharn0jg8m1d7zm8nhbsq3abw2k25kzw0z7m0zm14n1nlw";
+
editedCabalFile = "02xp5ldq3xxx1qdxg7gbs2zcqpf1dxbdrvrzizxnjwhpiqxcigy3";
libraryHaskellDepends = [ ghc-prim ];
description = "Integer library based on GMP";
license = stdenv.lib.licenses.bsd3;
···
pname = "intrinsic-superclasses";
+
sha256 = "0bx8igqwpyhs1q8rhyxhc5389nx49ynfq08bis30x9gdq209dqih";
libraryHaskellDepends = [
base containers haskell-src-meta mtl template-haskell
···
license = stdenv.lib.licenses.bsd2;
+
"invariant_0_5" = callPackage
+
({ mkDerivation, array, base, bifunctors, comonad, containers
+
, contravariant, ghc-prim, hspec, profunctors, QuickCheck
+
, semigroups, StateVar, stm, tagged, template-haskell
+
, th-abstraction, transformers, transformers-compat
+
sha256 = "1zz9a5irmpma5qchvvp7qin1s7cfnhvpg3b452xxysgbxvmcmfw0";
+
libraryHaskellDepends = [
+
array base bifunctors comonad containers contravariant ghc-prim
+
profunctors semigroups StateVar stm tagged template-haskell
+
th-abstraction transformers transformers-compat
+
testHaskellDepends = [ base hspec QuickCheck template-haskell ];
+
homepage = "https://github.com/nfrisby/invariant-functors";
+
description = "Haskell98 invariant functors";
+
license = stdenv.lib.licenses.bsd2;
+
hydraPlatforms = stdenv.lib.platforms.none;
"invertible" = callPackage
({ mkDerivation, base, haskell-src-meta, invariant, lens
, partial-isomorphisms, QuickCheck, semigroupoids, template-haskell
···
sha256 = "07mq4w4gvak8gahxdx3rwykwqqisxma8faxi4k0xfk6jcpai0snl";
+
editedCabalFile = "1qphrj2fb11kv79j92818lcdzvcldm18gfd85fmlrqmfjmig34wq";
libraryHaskellDepends = [
aeson attoparsec base bytestring cereal containers cryptonite
either memory mtl text time unordered-containers vector
···
homepage = "http://github.com/tekul/jose-jwt";
description = "JSON Object Signing and Encryption Library";
license = stdenv.lib.licenses.bsd3;
+
"jose-jwt_0_7_8" = callPackage
+
({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
+
, containers, criterion, cryptonite, doctest, either, hspec, HUnit
+
, memory, mtl, QuickCheck, text, time, transformers
+
, transformers-compat, unordered-containers, vector
+
sha256 = "0azkqllqc35hp2d2q50cwk472amhf0q5fkqs04a4kpnj50z6kqfk";
+
libraryHaskellDepends = [
+
aeson attoparsec base bytestring cereal containers cryptonite
+
either memory mtl text time transformers transformers-compat
+
unordered-containers vector
+
aeson base bytestring cryptonite doctest either hspec HUnit memory
+
mtl QuickCheck text unordered-containers vector
+
benchmarkHaskellDepends = [ base bytestring criterion cryptonite ];
+
homepage = "http://github.com/tekul/jose-jwt";
+
description = "JSON Object Signing and Encryption Library";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
···
sha256 = "15kwgpkryd865nls9zm6ya6jzmiygsb537ij7ps39dzasqbnl3an";
+
editedCabalFile = "03h9hh2bmplgz62hsh5zk6i1i39k51jxifkcb2j8kgpbf85wb4gv";
libraryHaskellDepends = [
aeson base containers generic-aeson generic-deriving mtl scientific
text time unordered-containers vector
···
+
sha256 = "0dg54vbn9cxcskyc92grz39zp863ki6da8kwdz0nfkfm5xzsxlrs";
libraryHaskellDepends = [
···
license = stdenv.lib.licenses.bsd3;
+
"jvm_0_4_0_1" = callPackage
({ mkDerivation, base, bytestring, choice, constraints, criterion
, deepseq, distributed-closure, exceptions, hspec, jni, singletons
+
sha256 = "0zazz893fxzh8hdc2k2irg0l5ic2v2h7z2cb60ngiarvrr07hpvl";
libraryHaskellDepends = [
base bytestring choice constraints distributed-closure exceptions
jni singletons text vector
···
license = stdenv.lib.licenses.bsd3;
+
"jvm-streaming_0_2_2" = callPackage
({ mkDerivation, base, distributed-closure, hspec, inline-java, jni
, jvm, singletons, streaming
+
sha256 = "1s0bla6yhw1ic637h2ss8f3aihc26ca5bndhsi5g02fn0gzw644m";
libraryHaskellDepends = [
base distributed-closure inline-java jni jvm singletons streaming
···
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
license = stdenv.lib.licenses.gpl3;
+
hydraPlatforms = stdenv.lib.platforms.none;
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
···
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
···
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
license = stdenv.lib.licenses.bsd3;
+
"lift-generics_0_1_2" = callPackage
+
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
+
, hspec, template-haskell
+
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
+
sha256 = "0kk05dp6n93jgxq4x1lrckjrca6lrwa7qklr3vpzc6iyrlbvv7qf";
+
libraryHaskellDepends = [
+
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
+
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
+
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
+
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
···
hydraPlatforms = stdenv.lib.platforms.none;
}) {llvm-config = null;};
+
"llvm-hs-pretty" = callPackage
+
({ mkDerivation, array, base, bytestring, directory, filepath
+
, llvm-hs, llvm-hs-pure, mtl, pretty-show, tasty, tasty-golden
+
, tasty-hspec, tasty-hunit, text, transformers, wl-pprint-text
+
pname = "llvm-hs-pretty";
+
sha256 = "1p16vhxx7w1hdb130c9mls45rwyq8hix1grnwdj92rbrqbjwk7l3";
+
libraryHaskellDepends = [
+
array base bytestring llvm-hs-pure text wl-pprint-text
+
base directory filepath llvm-hs llvm-hs-pure mtl pretty-show tasty
+
tasty-golden tasty-hspec tasty-hunit text transformers
+
homepage = "https://github.com/llvm-hs/llvm-hs-pretty";
+
description = "Pretty printer for LLVM IR";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"llvm-hs-pure" = callPackage
({ mkDerivation, attoparsec, base, bytestring, containers, mtl
, tasty, tasty-hunit, tasty-quickcheck, template-haskell
···
homepage = "https://github.com/verement/lmdb-simple#readme";
description = "Simple API for LMDB";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
···
+
sha256 = "0jhlf35h4db34ggq5gm53m71wbr3pddy6b3bbvmy9cd22d58nr6r";
libraryHaskellDepends = [
···
license = stdenv.lib.licenses.mit;
+
"mega-sdist_0_3_0_5" = callPackage
+
({ mkDerivation, base, bytestring, classy-prelude-conduit
+
, conduit-extra, directory, filepath, http-conduit, optparse-simple
+
, tar-conduit, temporary, text, typed-process, yaml
+
sha256 = "1rdx74bxiwrcp0k8h8028b65nbcmgcbpg7jnzli91y8nzr2qql6c";
+
executableHaskellDepends = [
+
base bytestring classy-prelude-conduit conduit-extra directory
+
filepath http-conduit optparse-simple tar-conduit temporary text
+
homepage = "https://github.com/snoyberg/mega-sdist#readme";
+
description = "Handles uploading to Hackage from mega repos";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"megaparsec" = callPackage
({ mkDerivation, base, bytestring, containers, criterion, deepseq
, exceptions, hspec, hspec-expectations, mtl, QuickCheck
···
license = stdenv.lib.licenses.bsd3;
+
"memory_0_14_10" = callPackage
+
({ mkDerivation, base, basement, bytestring, deepseq, foundation
+
, ghc-prim, tasty, tasty-hunit, tasty-quickcheck
+
sha256 = "01i1nx83n5lspwdhkhhjxxcp9agf9y70547dzs5m8zl043jmd0z4";
+
libraryHaskellDepends = [
+
base basement bytestring deepseq foundation ghc-prim
+
base foundation tasty tasty-hunit tasty-quickcheck
+
homepage = "https://github.com/vincenthz/hs-memory";
+
description = "memory and related abstraction stuff";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"memorypool" = callPackage
({ mkDerivation, base, containers, transformers, unsafe, vector }:
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"merkle-tree" = callPackage
+
({ mkDerivation, base, bytestring, cereal, cryptonite, memory
+
, protolude, QuickCheck, random, tasty, tasty-quickcheck
+
sha256 = "0k9ifkl8ywp0svn83rlczrq2s1aamwri2vx25cs42f64bgxr7ics";
+
editedCabalFile = "1ibsr79qmzykn2i7p8zvzp8v79lsr54gc3zdqmfgk2cjx1x8k6dz";
+
libraryHaskellDepends = [
+
base bytestring cereal cryptonite memory protolude random
+
base bytestring cereal cryptonite memory protolude QuickCheck
+
random tasty tasty-quickcheck
+
homepage = "https://github.com/adjoint-io/merkle-tree#readme";
+
description = "An implementation of a Merkle Tree and merkle tree proofs";
+
license = stdenv.lib.licenses.asl20;
+
hydraPlatforms = stdenv.lib.platforms.none;
"mersenne-random" = callPackage
({ mkDerivation, base, old-time }:
···
description = "Bindings to the Microsoft Translator API";
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"microspec" = callPackage
···
+
sha256 = "07p0f7a0nm7h8li8rl6adrszrz7hhzn19mfy0vgkw8axdaira66r";
executableHaskellDepends = [
···
license = stdenv.lib.licenses.bsd3;
+
"mixed-types-num_0_3_1_4" = callPackage
({ mkDerivation, base, convertible, hspec, hspec-smallcheck
, QuickCheck, smallcheck, template-haskell
pname = "mixed-types-num";
+
sha256 = "0061in4wv9hs5d8bvq5ycv8x176z3fz8fcfymwghmbjybbmgzzy4";
libraryHaskellDepends = [
base convertible hspec hspec-smallcheck QuickCheck smallcheck
···
+
sha256 = "0d5rvdb81239k8a6fyccad5mvlzq1k485dad2waxkidihakj6fk1";
enableSeparateDataOutput = true;
libraryHaskellDepends = [
aeson base containers data-default-class deepseq email-validate
···
+
sha256 = "0wsilw9mlh77qvxgpzay09b8xfsjz3dbrabd1wvw0whwf2cnzpp7";
enableSeparateDataOutput = true;
libraryHaskellDepends = [
base data-default-class foldl lucid mmark modern-uri text
···
license = stdenv.lib.licenses.bsd3;
+
"model_0_4_4" = callPackage
({ mkDerivation, base, containers, convertible, deepseq, doctest
, either, filemanip, ghc-prim, pretty, tasty, tasty-hunit
, tasty-quickcheck, transformers
+
sha256 = "1mmv1m78ychgqp0mblm56fszfmnxap3jwvxviy0h06s6wl2adq24";
libraryHaskellDepends = [
base containers convertible deepseq either pretty transformers
···
"monad-abort-fd" = callPackage
+
({ mkDerivation, base, mtl, transformers, transformers-abort
+
, transformers-base, transformers-compat
pname = "monad-abort-fd";
+
sha256 = "0a9ykj8cp817qlzvz7l5502zmwhiqa5236xvnsf93x38h34xwx5m";
libraryHaskellDepends = [
+
base mtl transformers transformers-abort transformers-base
homepage = "https://github.com/mvv/monad-abort-fd";
description = "A better error monad transformer";
···
sha256 = "14ki66l60la1mmm544vvzn930liaygj6zrql10nr192shf3v0cx3";
+
editedCabalFile = "19qsjwcdg39is6ipwl6hgr42c7gyc7p1cs5f8isxy90hb4xjghrh";
libraryHaskellDepends = [
base base-compat bytestring exceptions http-client http-client-tls
http-types monad-logger monadcryptorandom MonadRandom mtl text
···
license = stdenv.lib.licenses.mit;
+
"monad-logger_0_3_26" = callPackage
+
({ mkDerivation, base, blaze-builder, bytestring, conduit
+
, conduit-extra, exceptions, fast-logger, lifted-base
+
, monad-control, monad-loops, mtl, resourcet, stm, stm-chans
+
, template-haskell, text, transformers, transformers-base
+
, transformers-compat, unliftio-core
+
pname = "monad-logger";
+
sha256 = "0p7mdiv0n4wizcam2lw143szs584yzs0bq9lfrn90pgvz0q7k1ia";
+
libraryHaskellDepends = [
+
base blaze-builder bytestring conduit conduit-extra exceptions
+
fast-logger lifted-base monad-control monad-loops mtl resourcet stm
+
stm-chans template-haskell text transformers transformers-base
+
transformers-compat unliftio-core
+
homepage = "https://github.com/kazu-yamamoto/logger";
+
description = "A class of monads which can log messages";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"monad-logger-json" = callPackage
({ mkDerivation, aeson, base, monad-logger, template-haskell, text
···
({ mkDerivation, base, stm, transformers }:
+
sha256 = "1nj10lhijwvim7js2vl9b9qq7x55dx7bk6q4jmvpz99c2vqfhyy5";
libraryHaskellDepends = [ base stm transformers ];
homepage = "https://github.com/effectfully/monad-var#readme";
description = "Generic operations over variables";
···
license = stdenv.lib.licenses.mit;
+
"mono-traversable_1_0_5_0" = callPackage
+
({ mkDerivation, base, bytestring, containers, criterion, foldl
+
, hashable, hspec, HUnit, mwc-random, QuickCheck, semigroups, split
+
, text, transformers, unordered-containers, vector
+
pname = "mono-traversable";
+
sha256 = "1zrn7wp938di4mdc8q0z4imgg2hky7ap98ralzf8rdgqfrrvfpa6";
+
libraryHaskellDepends = [
+
base bytestring containers hashable split text transformers
+
unordered-containers vector vector-algorithms
+
base bytestring containers foldl hspec HUnit QuickCheck semigroups
+
text transformers unordered-containers vector
+
benchmarkHaskellDepends = [ base criterion mwc-random vector ];
+
homepage = "https://github.com/snoyberg/mono-traversable#readme";
+
description = "Type classes for mapping, folding, and traversing monomorphic containers";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"mono-traversable-instances" = callPackage
({ mkDerivation, base, comonad, containers, dlist, dlist-instances
, mono-traversable, semigroupoids, semigroups, transformers
···
pname = "myanimelist-export";
sha256 = "1d9fqna5qavp1lzpsg8yg816m3smybdsx25gafqr9wc2555rj1gg";
+
editedCabalFile = "1ni5bmhfra2rlxlv55iah865shyibz7bwl2zz6161v4s35bs68dj";
libraryHaskellDepends = [
···
"network-dns" = callPackage
+
({ mkDerivation, base, bytestring, containers, data-serializer
+
, data-textual, hashable, network-ip, parsers, posix-socket
+
, text-latin1, text-printer, type-hint
+
sha256 = "0q709qfhph93k8yni6047yr2zhswmc3cvizyyk63vmh3h2dwfmgs";
libraryHaskellDepends = [
+
base bytestring containers data-serializer data-textual hashable
+
network-ip parsers text-latin1 text-printer type-hint
+
executableHaskellDepends = [
+
base data-serializer data-textual network-ip posix-socket
homepage = "https://github.com/mvv/network-dns";
description = "Domain Name System data structures";
···
homepage = "http://github.com/jystic/network-info";
description = "Access the local computer's basic network configuration";
license = stdenv.lib.licenses.bsd3;
+
"network-info_0_2_0_9" = callPackage
+
({ mkDerivation, base }:
+
pname = "network-info";
+
sha256 = "0rmajccwhkf0p4inb8jjj0dzsksgn663w90km00xvf4mq3pkjab3";
+
libraryHaskellDepends = [ base ];
+
homepage = "http://github.com/jystic/network-info";
+
description = "Access the local computer's basic network configuration";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"network-interfacerequest" = callPackage
···
license = stdenv.lib.licenses.bsd3;
hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
}) {inherit (pkgs) nix;};
+
"nix-paths_1_0_1" = callPackage
+
({ mkDerivation, base, nix, nix-hash, process }:
+
sha256 = "1y09wl1ihxmc9p926g595f70pdcsx78r3q5n5rna23lpq8xicdxb";
+
libraryHaskellDepends = [ base process ];
+
libraryToolDepends = [ nix nix-hash ];
+
homepage = "https://github.com/peti/nix-paths";
+
description = "Knowledge of Nix's installation directories";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
+
}) {inherit (pkgs) nix; nix-hash = null;};
"nixfromnpm" = callPackage
({ mkDerivation, aeson, ansi-terminal, base, bytestring
···
license = stdenv.lib.licenses.bsd3;
+
"nonce_1_0_5" = callPackage
+
({ mkDerivation, base, base64-bytestring, bytestring, entropy, text
+
, transformers, unliftio, unliftio-core
+
sha256 = "15gbgfmby1mlk95c1q7qd38yc5xr4z7l58b3y59aixlsp4qspind";
+
libraryHaskellDepends = [
+
base base64-bytestring bytestring entropy text transformers
+
homepage = "https://github.com/prowdsponsor/nonce";
+
description = "Generate cryptographic nonces";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"nondeterminism" = callPackage
({ mkDerivation, base, containers, mtl, tasty, tasty-hunit }:
···
pname = "optparse-applicative-simple";
+
sha256 = "0kn740shja07mpaj9hy5blw1bcgy6ncpfyz3rqy3cglh2fzswsk2";
libraryHaskellDepends = [
+
attoparsec attoparsec-data base-prelude optparse-applicative text
testHaskellDepends = [ attoparsec-data rerebase ];
homepage = "https://github.com/nikita-volkov/optparse-applicative-simple";
···
license = stdenv.lib.licenses.bsd3;
+
"parser-combinators_0_2_1" = callPackage
pname = "parser-combinators";
+
sha256 = "1iai2i4kr7f8fbvvm4xw4hqcwnv26g0gaglpcim9r36jmzhf2yna";
libraryHaskellDepends = [ base ];
homepage = "https://github.com/mrkkrp/parser-combinators";
description = "Lightweight package providing commonly useful parser combinators";
···
license = stdenv.lib.licenses.bsd3;
+
"pedersen-commitment" = callPackage
+
({ mkDerivation, base, bytestring, containers, cryptonite, memory
+
, mtl, protolude, QuickCheck, tasty, tasty-hunit, tasty-quickcheck
+
pname = "pedersen-commitment";
+
sha256 = "10flwinxxs1vg2giqqyazcgxrykqsj6m0kgd62b8f4wzmygws4r1";
+
libraryHaskellDepends = [
+
base bytestring containers cryptonite memory mtl protolude text
+
base bytestring containers cryptonite memory mtl protolude
+
QuickCheck tasty tasty-hunit tasty-quickcheck text
+
homepage = "https://github.com/adjoint-io/pedersen-commitment#readme";
+
description = "An implementation of Pedersen commitment schemes";
+
license = stdenv.lib.licenses.asl20;
+
hydraPlatforms = stdenv.lib.platforms.none;
({ mkDerivation, base, containers, filepath, haskeline, logict, mtl
···
+
sha256 = "0f81jqs5k6gb2rnpqhawc5g2z3dziksjxrncjc844xlq3ybmr5an";
libraryHaskellDepends = [
aeson attoparsec base blaze-builder bytestring hashable
haskell-src-meta mtl postgresql-libpq scientific tagged
···
hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
+
"posix-socket" = callPackage
+
({ mkDerivation, base, bytestring, data-default-class, data-flags
+
, network-ip, transformers-base, unix
+
pname = "posix-socket";
+
sha256 = "0ivgvpdjwiwniw7xbmlab7myhy5a631liq4864plhkrkm3hcp44y";
+
libraryHaskellDepends = [
+
base bytestring data-default-class data-flags network-ip
+
homepage = "https://github.com/mvv/posix-socket";
+
description = "Bindings to the POSIX socket API";
+
license = stdenv.lib.licenses.bsd3;
"posix-timer" = callPackage
({ mkDerivation, base, transformers-base, unix }:
+
sha256 = "01s9hd23xcgdnryi72vj635435ccryv98a911l0zipxmvq4d8ri8";
libraryHaskellDepends = [ base transformers-base unix ];
homepage = "https://github.com/mvv/posix-timer";
description = "Bindings to POSIX clock and timer functions";
···
homepage = "https://github.com/diogob/postgres-websockets#readme";
description = "Middleware to map LISTEN/NOTIFY messages to Websockets";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"postgresql-binary" = callPackage
···
license = stdenv.lib.licenses.bsd3;
+
"postgresql-schema_0_1_14" = callPackage
+
({ mkDerivation, base, basic-prelude, optparse-applicative
+
, postgresql-simple, shelly, text, time
+
pname = "postgresql-schema";
+
sha256 = "0wnmhh8pzs9hzsmqkvr89jbdbbd1j87fnly2c80rsd7wr5qcrpkk";
+
enableSeparateDataOutput = true;
+
libraryHaskellDepends = [
+
base basic-prelude postgresql-simple shelly text
+
executableHaskellDepends = [
+
base basic-prelude optparse-applicative shelly text time
+
homepage = "https://github.com/mfine/postgresql-schema";
+
description = "PostgreSQL Schema Management";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"postgresql-simple" = callPackage
({ mkDerivation, aeson, attoparsec, base, base16-bytestring
, bytestring, bytestring-builder, case-insensitive, containers
···
hydraPlatforms = stdenv.lib.platforms.none;
+
({ mkDerivation, attoparsec, base, base-prelude, bug, bytestring
+
, directory, foldl, hashable, potoki-core, profunctors, QuickCheck
+
, quickcheck-instances, random, rerebase, tasty, tasty-hunit
+
, tasty-quickcheck, text, unagi-chan, unordered-containers, vector
+
sha256 = "12smxfa1s0i018cg8py9q8yzkirnvpfzygkzc8ck9d464gm82psv";
+
libraryHaskellDepends = [
+
attoparsec base base-prelude bug bytestring directory foldl
+
hashable potoki-core profunctors text unagi-chan
+
unordered-containers vector
+
attoparsec QuickCheck quickcheck-instances random rerebase tasty
+
tasty-hunit tasty-quickcheck
+
homepage = "https://github.com/nikita-volkov/potoki";
+
description = "Simple streaming in IO";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
+
"potoki-cereal" = callPackage
+
({ mkDerivation, base, base-prelude, bytestring, cereal, potoki
+
pname = "potoki-cereal";
+
sha256 = "04qfs8j2kgvavacpz7x9zdza0yfl4yw56g0bca28wh7q837y073y";
+
libraryHaskellDepends = [
+
base base-prelude bytestring cereal potoki potoki-core text
+
homepage = "https://github.com/nikita-volkov/potoki-cereal";
+
description = "Streaming serialization";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
+
"potoki-core" = callPackage
+
({ mkDerivation, base, deque, profunctors, QuickCheck
+
, quickcheck-instances, rerebase, stm, tasty, tasty-hunit
+
sha256 = "06d9hs15r6gr5yj9rcpw4klj3lxfjdd09nc0zwvmg1h3klqrqfxy";
+
libraryHaskellDepends = [ base deque profunctors stm ];
+
QuickCheck quickcheck-instances rerebase tasty tasty-hunit
+
homepage = "https://github.com/nikita-volkov/potoki-core";
+
description = "Low-level components of \"potoki\"";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
({ mkDerivation, base, bindings-potrace, bytestring, containers
, data-default, JuicyPixels, vector
···
({ mkDerivation, aeson, base, basic-prelude, exceptions
+
, fast-logger, lens, lifted-base, monad-control, monad-logger
+
, MonadRandom, mtl, network, resourcet, safe, shakers
+
, template-haskell, text, text-manipulate, time, transformers-base
+
, unordered-containers, uuid
+
sha256 = "04hc8cywmwwjxcgj0h26ahlnxj56awq9jnvpdgxgw5rvw4q4qqb3";
libraryHaskellDepends = [
+
aeson base basic-prelude exceptions fast-logger lens lifted-base
+
monad-control monad-logger MonadRandom mtl network resourcet safe
template-haskell text text-manipulate time transformers-base
unordered-containers uuid
···
license = stdenv.lib.licenses.mit;
+
"pretty-show_1_6_14" = callPackage
+
({ mkDerivation, array, base, filepath, ghc-prim, happy
+
, haskell-lexer, pretty
+
sha256 = "1izjjcf185hdl1fsh9j6idcdghan6dzgd8a5x0k5xqx1i24yrpb2";
+
enableSeparateDataOutput = true;
+
libraryHaskellDepends = [
+
array base filepath ghc-prim haskell-lexer pretty
+
libraryToolDepends = [ happy ];
+
executableHaskellDepends = [ base ];
+
homepage = "http://wiki.github.com/yav/pretty-show";
+
description = "Tools for working with derived `Show` instances and generic inspection of values";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"pretty-simple" = callPackage
({ mkDerivation, aeson, ansi-terminal, base, bytestring, containers
, criterion, doctest, Glob, mtl, parsec, text, transformers
···
"privileged-concurrency" = callPackage
+
({ mkDerivation, base, contravariant, lifted-base, stm, unliftio
pname = "privileged-concurrency";
+
sha256 = "0yapp7imds78rqb59rdr8bx82c6iifabf3x59n937srxiws55dik";
libraryHaskellDepends = [
+
base contravariant lifted-base stm unliftio unliftio-core
description = "Provides privilege separated versions of the concurrency primitives";
license = stdenv.lib.licenses.bsd3;
···
libraryHaskellDepends = [ base category ];
description = "Product category";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"product-isomorphic" = callPackage
···
homepage = "http://github.com/bitnomial/prometheus";
description = "Prometheus Haskell Client";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"prometheus-client" = callPackage
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"proxy-mapping" = callPackage
+
({ mkDerivation, base }:
+
pname = "proxy-mapping";
+
sha256 = "12lwn64znci7l5l7sa3g7hm0rmnjvykci7k65mz5c2zdwx3zgvdd";
+
libraryHaskellDepends = [ base ];
+
description = "Mapping of Proxy Types";
+
license = stdenv.lib.licenses.bsd3;
({ mkDerivation, aeson, base, bytestring, containers, directory
, edit-distance, either, filepath, fsnotify, hspec, http-client
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"q4c12-twofinger" = callPackage
+
({ mkDerivation, base, bifunctors, Cabal, cabal-doctest, deepseq
+
, doctest, lens, QuickCheck, semigroupoids, streams
+
pname = "q4c12-twofinger";
+
sha256 = "036c02x5vph24a43vr58acrwny9vidmmv7536sw5b9fiynfkd343";
+
setupHaskellDepends = [ base Cabal cabal-doctest ];
+
libraryHaskellDepends = [
+
base bifunctors deepseq QuickCheck semigroupoids streams
+
base doctest lens QuickCheck streams template-haskell
+
homepage = "https://github.com/quasicomputational/mega/tree/master/packages/twofinger";
+
description = "Efficient alternating finger trees";
+
license = stdenv.lib.licenses.bsd2;
+
hydraPlatforms = stdenv.lib.platforms.none;
"qc-oi-testgenerator" = callPackage
({ mkDerivation, base, fclabels, QuickCheck, template-haskell }:
···
"quantification" = callPackage
+
({ mkDerivation, aeson, base, containers, ghc-prim, hashable
+
, path-pieces, text, unordered-containers, vector
pname = "quantification";
+
sha256 = "0hljd4m55254kmcrp3iar8ya7ky5a73vk3vrmgandmb15fsp2wvy";
libraryHaskellDepends = [
+
aeson base containers ghc-prim hashable path-pieces text
+
unordered-containers vector
homepage = "https://github.com/andrewthad/quantification#readme";
description = "Rage against the quantification";
···
({ mkDerivation, aeson, base, prim-array, primitive, QuickCheck }:
pname = "quickcheck-classes";
+
sha256 = "03j2647wnmp7fyxbjk80rrfc0k8i530dnyl1zlgkq11xwlyn54sr";
libraryHaskellDepends = [
aeson base prim-array primitive QuickCheck
···
homepage = "https://github.com/andrewthad/quickcheck-classes#readme";
description = "QuickCheck common typeclasses";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"quickcheck-combinators" = callPackage
···
"rails-session" = callPackage
+
({ mkDerivation, base, base-compat, base16-bytestring
+
, base64-bytestring, bytestring, containers, cryptonite, filepath
+
, http-types, pbkdf, ruby-marshal, semigroups, string-conv, tasty
+
, tasty-hspec, transformers, vector
+
sha256 = "0r1jiy7x7497zk1gvg1zbpqx2vh2i0j9x7gzscgx6gylkjkkppir";
libraryHaskellDepends = [
+
base base-compat base16-bytestring base64-bytestring bytestring
+
containers cryptonite http-types pbkdf ruby-marshal string-conv
+
base bytestring filepath ruby-marshal semigroups tasty tasty-hspec
homepage = "http://github.com/iconnect/rails-session#readme";
···
+
sha256 = "0nxnw5b0qhjzb0zwak74x84f081p1giyzbvpinhx527ph4j96aqf";
libraryHaskellDepends = [
aeson base bytestring connection constraints data-default-class
extensible http-api-data http-client http-client-tls http-types
···
license = stdenv.lib.licenses.mit;
+
"random-class" = callPackage
+
({ mkDerivation, base, primitive, transformers, util }:
+
pname = "random-class";
+
sha256 = "11nda6dgi0f3b3bzy2wahdsadf382c06xrz1dx2gnq89ym7k7qbp";
+
libraryHaskellDepends = [ base primitive transformers util ];
+
description = "Class of random value generation";
+
license = stdenv.lib.licenses.bsd3;
"random-derive" = callPackage
({ mkDerivation, base, random, template-haskell }:
···
"rate-limit" = callPackage
+
({ mkDerivation, base, stm, time, time-units }:
+
sha256 = "0p0bnfnn790kkpgj6v6646fbczznf28a65zsf92xyiab00jw6ilb";
+
libraryHaskellDepends = [ base stm time time-units ];
homepage = "http://github.com/acw/rate-limit";
description = "A basic library for rate-limiting IO actions";
license = stdenv.lib.licenses.bsd3;
···
license = stdenv.lib.licenses.mit;
+
"rebase_1_2_2" = callPackage
({ mkDerivation, base, base-prelude, bifunctors, bytestring
, containers, contravariant, contravariant-extras, deepseq, dlist
, either, fail, hashable, mtl, profunctors, scientific
···
+
sha256 = "11p4wg2xissj4xzw80dww2srj2ylgw3wlnapykizy2fwjl1az9k4";
libraryHaskellDepends = [
base base-prelude bifunctors bytestring containers contravariant
contravariant-extras deepseq dlist either fail hashable mtl
···
pname = "relational-record-examples";
+
sha256 = "0p49sb8ssvhbhmq4wicj7b46q53vibw686rr3xfy6iz82j64mklb";
libraryHaskellDepends = [
···
"reprinter" = callPackage
+
({ mkDerivation, base, mtl, syb, syz, text, transformers, uniplate
+
sha256 = "1b3hdz7qq9qk7pbx0ny4ziagjm9hi9wfi9rl0aq0b8p70zzyjiq1";
libraryHaskellDepends = [
+
base mtl syb syz text transformers uniplate
+
homepage = "https://github.com/camfort/reprinter#readme";
description = "Scrap Your Reprinter";
license = stdenv.lib.licenses.asl20;
hydraPlatforms = stdenv.lib.platforms.none;
···
license = stdenv.lib.licenses.mit;
+
"rerebase_1_2_1" = callPackage
({ mkDerivation, rebase }:
+
sha256 = "02j119pabivn2x23mvvmzlkypxwi31p7s2fpakavhqfs6bmbnb2a";
libraryHaskellDepends = [ rebase ];
homepage = "https://github.com/nikita-volkov/rerebase";
description = "Reexports from \"base\" with a bunch of other standard libraries";
···
license = stdenv.lib.licenses.bsd3;
+
"resourcet_1_1_10" = callPackage
+
({ mkDerivation, base, containers, exceptions, hspec, lifted-base
+
, mmorph, monad-control, mtl, transformers, transformers-base
+
, transformers-compat, unliftio-core
+
sha256 = "1hhw9w85nj8i2azzj5sxixffdvciq96b0jhl0zz24038bij66cyl";
+
libraryHaskellDepends = [
+
base containers exceptions lifted-base mmorph monad-control mtl
+
transformers transformers-base transformers-compat unliftio-core
+
testHaskellDepends = [ base hspec lifted-base transformers ];
+
homepage = "http://github.com/snoyberg/conduit";
+
description = "Deterministic allocation and freeing of scarce resources";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
editedCabalFile = "0bh9zzya42dbpc5c7j7fnyphm5nndib1ycbmanplgx0b707x1sda";
, data-default-class, exceptions, fast-logger, formatting, HList
···
license = stdenv.lib.licenses.bsd3;
+
"retry_0_7_5_0" = callPackage
+
({ mkDerivation, base, data-default-class, exceptions, ghc-prim
+
, hspec, HUnit, mtl, QuickCheck, random, stm, time, transformers
+
sha256 = "1rganxc2lhbg5pch58bi29cv4m7zsddgwnkkjry8spwp3y8sh46p";
+
libraryHaskellDepends = [
+
base data-default-class exceptions ghc-prim random transformers
+
base data-default-class exceptions ghc-prim hspec HUnit mtl
+
QuickCheck random stm time transformers
+
homepage = "http://github.com/Soostone/retry";
+
description = "Retry combinators for monadic actions that may fail";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
({ mkDerivation, base, optparse-applicative, process }:
···
+
sha256 = "1zsbgq8f2a0sr575lkz6r5n0vq8jyn32q1sjxkw7d1zqkmzx1f0b";
libraryHaskellDepends = [
aeson aeson-diff async base blaze-html classy-prelude containers
data-default exceptions hedis http-api-data http-client-tls
···
+
sha256 = "18fav38bd2ysk8y5s24xxc6v381mag3g2lqpb9qayvcfj2zndx1x";
libraryHaskellDepends = [
···
({ mkDerivation, base, dunai, gloss, rhine }:
+
sha256 = "1sidp1f3is889g0kgdcbzpjrqndrvwvq6k713daqlkzarg9wngnj";
libraryHaskellDepends = [ base dunai gloss rhine ];
executableHaskellDepends = [ base ];
+
description = "Wrapper to run reactive programs written in Rhine with Gloss as backend";
license = stdenv.lib.licenses.bsd3;
···
+
sha256 = "1s1ivg8l2k7mg3qd5hvgdbqp7mhczfkrwcmsnybh1yq276hhj15n";
libraryHaskellDepends = [
aeson async attoparsec base bifunctors binary blaze-builder
bytestring containers data-default-class deepseq
···
+
sha256 = "0cyarnp2yqlj98zdbd51krpz3ls75vcl8am6h4wf98b6vdmx1jsx";
libraryHaskellDepends = [
array base parsec protocol-buffers protocol-buffers-descriptor
+
homepage = "http://github.com/riak-haskell-client/riak-haskell-client";
description = "Haskell types for the Riak protocol buffer API";
···
pname = "riak-protobuf-lens";
+
sha256 = "0i01p6ix5304hd9alahq5bpmcf1rzc9k2qqy6n7c002fmnwsw2zw";
libraryHaskellDepends = [
···
homepage = "https://github.com/gianlucaguarini/rob#readme";
description = "Simple projects generator";
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
···
sha256 = "0msnjz7ml0zycw9bssslxbg0nigziw7vs5km4q3vjbs8jpzpkr2w";
+
editedCabalFile = "0wsrd213480p3pqrd6i650fr092yv7dhla7a85p8154pn5gvbr0a";
libraryHaskellDepends = [
base binary bytestring containers deepseq hashable integer-gmp
integer-logarithms primitive text
···
sha256 = "006jys6kvckkmbnhf4jc51sh64hamkz464mr8ciiakybrfvixr3r";
+
editedCabalFile = "0wzcnpz8pyjk823vqnq5s8krsb8i6cw573hcschpd9x5ynq4li70";
setupHaskellDepends = [ base Cabal cabal-doctest ];
libraryHaskellDepends = [
base base-orphans bifunctors comonad containers contravariant
···
pname = "servant-aeson-specs";
+
sha256 = "13xakmbr0qykff695cj631g97nlcjmmzki68c2gg5sn9jl63yq1q";
libraryHaskellDepends = [
aeson aeson-pretty base bytestring directory filepath hspec
hspec-golden-aeson QuickCheck quickcheck-arbitrary-adt random
···
"servant-generic" = callPackage
+
({ mkDerivation, base, network-uri, servant, servant-server, text
pname = "servant-generic";
+
sha256 = "1zgw5j3wx4fyb9nhifslzsbfla3iagkvix86vb1x3d9fyz117wif";
libraryHaskellDepends = [ base servant servant-server ];
+
base network-uri servant servant-server text warp
description = "Specify Servant APIs with records";
license = stdenv.lib.licenses.mit;
···
pname = "servant-kotlin";
+
sha256 = "0dwm9aia14hr2gblcak7vyh7jgs1mnfwqq131rxyygf9d11wpx41";
libraryHaskellDepends = [
base containers directory formatting lens servant servant-foreign
···
license = stdenv.lib.licenses.bsd3;
+
"servant-match" = callPackage
+
({ mkDerivation, base, bytestring, hspec, http-types, network-uri
+
, servant, text, utf8-string
+
pname = "servant-match";
+
sha256 = "1jh817sflbkqmv38rpd20jfz5nbpyxz1n0gqx7446n745jnc2ga0";
+
libraryHaskellDepends = [
+
base bytestring http-types network-uri servant text utf8-string
+
testHaskellDepends = [ base hspec network-uri servant text ];
+
homepage = "https://github.com/cocreature/servant-match#readme";
+
description = "Standalone implementation of servant’s dispatching mechanism";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"servant-matrix-param" = callPackage
({ mkDerivation, aeson, base, bytestring, containers, doctest
, hspec, http-client, http-types, servant, servant-aeson-specs
···
({ mkDerivation, base, basic-prelude, deepseq, directory
+
, lifted-base, regex-compat, shake
+
sha256 = "08wnf9cv4qsrnx2m3l1nfh74q6i14ng2js4h7gj3z5dv1ki3xwm9";
libraryHaskellDepends = [
+
base basic-prelude deepseq directory lifted-base regex-compat shake
executableHaskellDepends = [ base ];
homepage = "https://github.com/swift-nav/shakers";
···
license = stdenv.lib.licenses.bsd3;
+
"shelly_1_7_0" = callPackage
({ mkDerivation, async, base, bytestring, containers, directory
, enclosed-exceptions, exceptions, hspec, HUnit, lifted-async
, lifted-base, monad-control, mtl, process, system-fileio
···
+
sha256 = "0jscygg381hzb4mjknrwsfw0q3j4sf1w4qrz1mf4k38794axx21q";
libraryHaskellDepends = [
···
license = stdenv.lib.licenses.bsd3;
+
"simple-sendfile_0_2_26" = callPackage
+
({ mkDerivation, base, bytestring, conduit, conduit-extra
+
, directory, hspec, HUnit, network, process, resourcet, unix
+
pname = "simple-sendfile";
+
sha256 = "0z2r971bjy9wwv9rhnzh0ldd0z9zvqwyrq9yhz7m4lnf0k0wqq6z";
+
libraryHaskellDepends = [ base bytestring network unix ];
+
base bytestring conduit conduit-extra directory hspec HUnit network
+
description = "Cross platform library for the sendfile system call";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"simple-server" = callPackage
({ mkDerivation, base, bytestring, concurrent-extra, containers
, hashtables, network, time, unbounded-delays
···
description = "Lenses for simpleirc types";
license = stdenv.lib.licenses.bsd2;
hydraPlatforms = stdenv.lib.platforms.none;
+
"simplemesh" = callPackage
+
({ mkDerivation, base, linear }:
+
sha256 = "1cq8h96kr1qnxqma7if3pmxcw05nrirpnw703r4cba75xwgwlqcl";
+
libraryHaskellDepends = [ base linear ];
+
homepage = "https://github.com/jonascarpay/simplemesh#readme";
+
description = "Generators for primitive meshes";
+
license = stdenv.lib.licenses.bsd3;
"simplenote" = callPackage
···
sha256 = "1h791s39nr057w5f2fr4v7p1czw9jm0dk5qrhr26qyw97j4ysngx";
+
editedCabalFile = "089942604ikg40v4nl25c4j856bylmmm06py4k2spz3y2z4k49rb";
libraryHaskellDepends = [
base dictionary-sharing template-haskell testing-type-modifiers
···
license = stdenv.lib.licenses.gpl2;
+
"skylighting_0_5" = callPackage
({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary
, blaze-html, bytestring, case-insensitive, containers, criterion
, Diff, directory, filepath, HUnit, hxt, mtl, pretty-show, random
···
+
sha256 = "1as4rdzn69jyn3lmzk257j6q208a8z695jsc82jwmlsdyva1m3ic";
libraryHaskellDepends = [
···
sha256 = "01xprcrgy0galalh27by3csbm8m2m9dxlw3y83s4qnassv8zf2xs";
+
editedCabalFile = "0ki4g5520i7bam1gmammbb0nh8ibmjskqfv7kw2qjzzg4i9q3x95";
libraryHaskellDepends = [
base bytestring conduit configurator data-default exceptions
http-client http-types iconv mtl resourcet text
···
sha256 = "03w389yhybzvc06gpxigibqga9mr7m41rkg1ki3n686j9xzm8210";
+
editedCabalFile = "1b3aivn9jfaax00id7x4cqvpmd6lgynslchlry0qsmq1lj466cdf";
libraryHaskellDepends = [
base configurator data-default HsOpenSSL http-client
http-client-openssl soap text
···
sha256 = "0xnzwzmhh2i5nci7xbnkr28hxm376fbmgjcwz7svk46k1vxvlfp4";
+
editedCabalFile = "0h6jgiifrphdphxfvgk95and4a86xp6afxi90v0b93cs2zyi0vsy";
libraryHaskellDepends = [
base configurator connection data-default http-client
http-client-tls soap text tls x509 x509-store x509-validation
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"sparkle_0_7" = callPackage
({ mkDerivation, base, binary, bytestring, Cabal, choice
, distributed-closure, filepath, inline-java, jni, jvm
, jvm-streaming, process, regex-tdfa, singletons, streaming, text
···
+
sha256 = "01w4b2r4pdlip4nkyc0gwh9322a8046bf1hjprj4y51f209skb7z";
enableSeparateDataOutput = true;
···
({ mkDerivation, aeson, annotated-wl-pprint, ansi-terminal, async
+
, attoparsec, base, base64-bytestring, bindings-uname
+
, blaze-builder, bytestring, Cabal, clock, conduit, conduit-extra
+
, containers, cryptonite, cryptonite-conduit, deepseq, directory
+
, echo, exceptions, extra, fast-logger, file-embed, filelock
+
, filepath, fsnotify, generic-deriving, gitrev, hackage-security
+
, hashable, hastache, hpack, hpc, hspec, http-client
+
, http-client-tls, http-conduit, http-types, memory, microlens
+
, microlens-mtl, mintty, monad-logger, mono-traversable, mtl
+
, neat-interpolation, network-uri, open-browser
+
, optparse-applicative, optparse-simple, path, path-io, persistent
+
, persistent-sqlite, persistent-template, pid1, pretty, primitive
+
, process, project-template, QuickCheck, regex-applicative-text
+
, resourcet, retry, semigroups, smallcheck, split, stm, store
+
, store-core, streaming-commons, tar, template-haskell, temporary
+
, text, text-metrics, th-reify-many, time, tls, transformers
+
, unicode-transforms, unix, unix-compat, unliftio
+
, unordered-containers, vector, yaml, zip-archive, zlib
+
sha256 = "0mf95h83qrgidkfvwm47w262fprsh8g5rf9mzkc1v2ifbn9b93v9";
+
editedCabalFile = "103w999pac6337idj241iil52rssjp4vn5r5bvgl72sn64wxkm4x";
setupHaskellDepends = [ base Cabal filepath ];
libraryHaskellDepends = [
aeson annotated-wl-pprint ansi-terminal async attoparsec base
+
base64-bytestring bindings-uname blaze-builder bytestring Cabal
+
clock conduit conduit-extra containers cryptonite
+
cryptonite-conduit deepseq directory echo exceptions extra
+
fast-logger file-embed filelock filepath fsnotify generic-deriving
+
hackage-security hashable hastache hpack hpc http-client
+
http-client-tls http-conduit http-types memory microlens
+
microlens-mtl mintty monad-logger mono-traversable mtl
+
neat-interpolation network-uri open-browser optparse-applicative
+
path path-io persistent persistent-sqlite persistent-template pid1
+
pretty primitive process project-template regex-applicative-text
+
resourcet retry semigroups split stm store store-core
+
streaming-commons tar template-haskell temporary text text-metrics
+
th-reify-many time tls transformers unicode-transforms unix
+
unix-compat unliftio unordered-containers vector yaml zip-archive
executableHaskellDepends = [
+
aeson annotated-wl-pprint ansi-terminal async attoparsec base
+
base64-bytestring bindings-uname blaze-builder bytestring Cabal
+
clock conduit conduit-extra containers cryptonite
+
cryptonite-conduit deepseq directory echo exceptions extra
+
fast-logger file-embed filelock filepath fsnotify generic-deriving
+
gitrev hackage-security hashable hastache hpack hpc http-client
+
http-client-tls http-conduit http-types memory microlens
+
microlens-mtl mintty monad-logger mono-traversable mtl
+
neat-interpolation network-uri open-browser optparse-applicative
+
optparse-simple path path-io persistent persistent-sqlite
+
persistent-template pid1 pretty primitive process project-template
+
regex-applicative-text resourcet retry semigroups split stm store
+
store-core streaming-commons tar template-haskell temporary text
+
text-metrics th-reify-many time tls transformers unicode-transforms
+
unix unix-compat unliftio unordered-containers vector yaml
+
aeson annotated-wl-pprint ansi-terminal async attoparsec base
+
base64-bytestring bindings-uname blaze-builder bytestring Cabal
+
clock conduit conduit-extra containers cryptonite
+
cryptonite-conduit deepseq directory echo exceptions extra
+
fast-logger file-embed filelock filepath fsnotify generic-deriving
+
hackage-security hashable hastache hpack hpc hspec http-client
+
http-client-tls http-conduit http-types memory microlens
+
microlens-mtl mintty monad-logger mono-traversable mtl
+
neat-interpolation network-uri open-browser optparse-applicative
+
path path-io persistent persistent-sqlite persistent-template pid1
+
pretty primitive process project-template QuickCheck
+
regex-applicative-text resourcet retry semigroups smallcheck split
+
stm store store-core streaming-commons tar template-haskell
+
temporary text text-metrics th-reify-many time tls transformers
+
unicode-transforms unix unix-compat unliftio unordered-containers
+
vector yaml zip-archive zlib
preCheck = "export HOME=$TMPDIR";
···
license = stdenv.lib.licenses.mit;
+
"stack-yaml" = callPackage
+
({ mkDerivation, base, bytestring, directory, doctest, filepath
+
sha256 = "14cs9mds6xfy39nzyariisqxkzpkzi0r86ldb0kw60g4wgy9m6m5";
+
libraryHaskellDepends = [
+
base bytestring directory filepath text yaml
+
testHaskellDepends = [ base doctest Glob ];
+
homepage = "https://github.com/phlummox/stack-yaml";
+
description = "Parse a stack.yaml file";
+
license = stdenv.lib.licenses.mit;
"stack2nix" = callPackage
({ mkDerivation, async, base, bytestring, Cabal, containers
, data-fix, directory, filepath, Glob, hnix, monad-parallel
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"stratosphere_0_14_0" = callPackage
({ mkDerivation, aeson, aeson-pretty, base, bytestring, hashable
, hspec, hspec-discover, lens, template-haskell, text
+
sha256 = "11y97l0qsyab8hk126qi4lj8a8d13wp8zhk2qsqwy31rcmjipr0s";
libraryHaskellDepends = [
···
homepage = "https://github.com/michaelt/streaming";
description = "an elementary streaming prelude and general stream type";
license = stdenv.lib.licenses.bsd3;
+
"streaming_0_2_0_0" = callPackage
+
({ mkDerivation, base, containers, exceptions, ghc-prim, mmorph
+
, mtl, transformers, transformers-base
+
sha256 = "08l7x3cbska45pv754nnkms1m6jmgi0qv4apsvdmc2mni4cb5jkn";
+
libraryHaskellDepends = [
+
base containers exceptions ghc-prim mmorph mtl transformers
+
homepage = "https://github.com/haskell-streaming/streaming";
+
description = "an elementary streaming prelude and general stream type";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"streaming-binary" = callPackage
···
license = stdenv.lib.licenses.mit;
+
"streamly" = callPackage
+
({ mkDerivation, atomic-primops, base, containers, criterion
+
, exceptions, hspec, lifted-base, lockfree-queue, monad-control
+
, mtl, stm, transformers, transformers-base
+
sha256 = "1apw961n69rix4vvb7bsdald0w1qnal1vawi66nw64cyn696sbzi";
+
editedCabalFile = "0cx4s17r2nn6xwa9lpcn7scvbqqxi6ihxyb20axhj5rim8iz94hm";
+
libraryHaskellDepends = [
+
atomic-primops base containers exceptions lifted-base
+
lockfree-queue monad-control mtl stm transformers transformers-base
+
testHaskellDepends = [ base containers hspec ];
+
benchmarkHaskellDepends = [ atomic-primops base criterion mtl ];
+
homepage = "https://github.com/composewell/streamly";
+
description = "Beautiful Streaming, Concurrent and Reactive Composition";
+
license = stdenv.lib.licenses.bsd3;
"streamproc" = callPackage
···
+
sha256 = "1lrp6llvl0g469gjgl7rl67qj8zn1ssbg61n6qwkb8lqqqpq03mq";
libraryHaskellDepends = [
attoparsec attoparsec-data base base-prelude base64-bytestring
bifunctors bytestring bytestring-tree-builder hashable http-media
···
+
({ mkDerivation, base, containers, hspec }:
+
sha256 = "0vf5crr60nixklxndpay1lp9yvhxjzmza8g5b5gz97hkyqicaid7";
+
libraryHaskellDepends = [ base containers ];
+
testHaskellDepends = [ base containers hspec ];
homepage = "https://github.com/code5hot/subzero#readme";
description = "Helps when going \"seed values\" -> alternatives and optional -> answers";
license = stdenv.lib.licenses.gpl2;
···
license = stdenv.lib.licenses.bsd3;
+
"tasty-rerun_1_1_8" = callPackage
+
({ mkDerivation, base, containers, mtl, optparse-applicative
+
, reducers, split, stm, tagged, tasty, transformers
+
sha256 = "0yg8cicfn3qaazvp4rbanzy3dyk95k3y1kkd4bykvkl9v4076788";
+
libraryHaskellDepends = [
+
base containers mtl optparse-applicative reducers split stm tagged
+
homepage = "http://github.com/ocharles/tasty-rerun";
+
description = "Run tests by filtering the test tree depending on the result of previous test runs";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"tasty-silver" = callPackage
({ mkDerivation, ansi-terminal, async, base, bytestring, containers
, deepseq, directory, filepath, mtl, optparse-applicative, process
···
+
sha256 = "0y9kscqn5pg99q9672l6axcnkbxjxahr7azlcw8mjwix46g5chsn";
enableSeparateDataOutput = true;
libraryHaskellDepends = [
aeson base bytestring http-api-data http-client http-media
···
sha256 = "1kh7ak9qlxsr34hxccfgyz1ga90xxiaxqndk3jaln1f495w9rjil";
+
editedCabalFile = "05j5i1sfg1k94prhwmg6z50w0flb9k181nhabwr3m9gkrrqzb4b4";
libraryHaskellDepends = [
base mtl QuickCheck tagshare template-haskell
···
+
sha256 = "076im75jx1g37cvhvfc6a7my6m81rcgdww6y97p0ldwjbv88gsk3";
executableHaskellDepends = [
···
license = stdenv.lib.licenses.bsd3;
+
"text-show_3_7" = callPackage
({ mkDerivation, array, base, base-compat, base-orphans, bifunctors
, bytestring, bytestring-builder, containers, contravariant
, criterion, deepseq, deriving-compat, generic-deriving
···
+
sha256 = "11wnvnc87rrzg949b00vbx3pbcxskrapdy9dklh6szq6pcc38irr";
libraryHaskellDepends = [
array base base-compat bifunctors bytestring bytestring-builder
containers contravariant generic-deriving ghc-boot-th ghc-prim
···
sha256 = "0jl8ippnsy5zmy52cvpn252hm2g7xqp1zb1xcrbgr00pmdxpvwyw";
+
editedCabalFile = "0mxl547dy7pp95kh3bvmdhsfcrmxcx8rzc94nnmcs3ahrbyw1nl1";
libraryHaskellDepends = [
aeson base bifunctors binary containers data-default-class deepseq
hashable keys mtl profunctors QuickCheck semigroupoids transformers
···
license = stdenv.lib.licenses.gpl3;
+
"tidal_0_9_5" = callPackage
+
({ mkDerivation, base, colour, containers, hashable, hosc
+
, mersenne-random-pure64, mtl, parsec, safe, tasty, tasty-hunit
+
, text, time, websockets
+
sha256 = "1p288qc8g6jxf8l1d1wkcq4aqgyx2wpv7fn7ff9mikgj1xjixhqc";
+
libraryHaskellDepends = [
+
base colour containers hashable hosc mersenne-random-pure64 mtl
+
parsec safe text time websockets
+
testHaskellDepends = [ base tasty tasty-hunit ];
+
homepage = "http://tidalcycles.org/";
+
description = "Pattern language for improvised music";
+
license = stdenv.lib.licenses.gpl3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"tidal-midi" = callPackage
({ mkDerivation, base, containers, PortMidi, tidal, time
+
sha256 = "0yjbrsg2lwj6x32ly0j6b4ms6i1s447jk2b7c6qp85pblaanmzqc";
libraryHaskellDepends = [
base containers PortMidi tidal time transformers
···
homepage = "https://github.com/y-taka-23/time-machine#readme";
description = "A library to mock the current time";
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
···
libraryHaskellDepends = [ auto-update base clock psqueues tls ];
description = "In-memory TLS session manager";
license = stdenv.lib.licenses.bsd3;
+
"tls-session-manager_0_0_0_2" = callPackage
+
({ mkDerivation, auto-update, base, clock, psqueues, tls }:
+
pname = "tls-session-manager";
+
sha256 = "0rvmln545vghsx8zhxp44f0f6pzma8cylarmfhhysy55ipywr1n5";
+
libraryHaskellDepends = [ auto-update base clock psqueues tls ];
+
description = "In-memory TLS session manager";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
···
license = stdenv.lib.licenses.mit;
+
"typed-process_0_2_0_0" = callPackage
+
({ mkDerivation, async, base, base64-bytestring, bytestring, hspec
+
, process, stm, temporary, transformers
+
pname = "typed-process";
+
sha256 = "1vc6ig5r5ajdr9d28fk1q0cb4p7nahbknn9fkzli4n9l9bk4xhdf";
+
libraryHaskellDepends = [
+
async base bytestring process stm transformers
+
async base base64-bytestring bytestring hspec process stm temporary
+
homepage = "https://haskell-lang.org/library/typed-process";
+
description = "Run external processes, with strong typing of streams";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"typed-spreadsheet" = callPackage
({ mkDerivation, async, base, diagrams-cairo, diagrams-gtk
, diagrams-lib, foldl, gtk, microlens, stm, text, transformers
···
sha256 = "10nkcmql6ryh3vp02yxk3i1f6fbxdcsjk6s5ani89qa05448xqkw";
+
editedCabalFile = "088dcgyg9bzm5qczcddssjfwywk9lsj10lq7byh4f9rnsf0jppna";
libraryHaskellDepends = [ base deepseq profunctors tagged vinyl ];
benchmarkHaskellDepends = [ base criterion deepseq lens ];
description = "Extensible type-safe unions";
···
license = stdenv.lib.licenses.bsd3;
+
"unix-compat_0_5_0_1" = callPackage
({ mkDerivation, base, unix }:
+
sha256 = "1gdf3h2knbymkivm784vq51mbcyj5y91r480awyxj5cw8gh9kwn2";
libraryHaskellDepends = [ base unix ];
homepage = "http://github.com/jystic/unix-compat";
description = "Portable POSIX-compatibility layer";
···
license = stdenv.lib.licenses.mit;
+
"unliftio_0_2_0_0" = callPackage
+
({ mkDerivation, async, base, deepseq, directory, filepath
+
, transformers, unix, unliftio-core
+
sha256 = "03bbhm91n0xlc207n8zzlnxp2cifr1zrcnqdys6884l062bh1xig";
+
libraryHaskellDepends = [
+
async base deepseq directory filepath transformers unix
+
homepage = "https://github.com/fpco/unliftio/tree/master/unliftio#readme";
+
description = "The MonadUnliftIO typeclass for unlifting monads to IO (batteries included)";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"unliftio-core" = callPackage
({ mkDerivation, base, transformers }:
···
+
sha256 = "1m0ljqgfbs5f45mi25h1hv4q2svhjlq17xprvmaq042334cbim0s";
libraryHaskellDepends = [ base ];
description = "Utilities";
license = stdenv.lib.licenses.bsd3;
···
+
sha256 = "0gs6qjahb3xl59cpbwcaqxsbzg28yw80fjyziqfd0s3vca4c9abm";
libraryHaskellDepends = [
aeson base bytestring http-client http-client-tls http-types text
···
pname = "vault-tool-server";
+
sha256 = "07j25ksqk5fnyp3gnp79jj4l3ax3y5wf29s2kwkq9r2pjb8577g4";
libraryHaskellDepends = [
aeson async base bytestring filepath http-client process temporary
···
homepage = "http://github.com/pjones/vimeta";
description = "Frontend for video metadata tagging tools";
license = stdenv.lib.licenses.bsd2;
+
hydraPlatforms = stdenv.lib.platforms.none;
···
license = stdenv.lib.licenses.mit;
+
"vinyl_0_7_0" = callPackage
({ mkDerivation, base, criterion, doctest, ghc-prim, hspec, lens
, linear, mwc-random, primitive, should-not-typecheck, singletons
+
sha256 = "1gch1cx10466j2cyj7q4x0s3g9sjy35l5j9mvq4sfnf4sql1cfps";
libraryHaskellDepends = [ base ghc-prim ];
base doctest hspec lens should-not-typecheck singletons
···
+
sha256 = "1g81dbcarbllij1h197j0g1x65jb4pcd8qwfwza9i4jn4sfmgps1";
libraryHaskellDepends = [
base containers GLUtil linear OpenGL tagged transformers vector
···
license = stdenv.lib.licenses.bsd3;
+
"wai-middleware-rollbar_0_7_0" = callPackage
({ mkDerivation, aeson, base, bytestring, case-insensitive
, containers, hostname, hspec, hspec-golden-aeson, http-client
, http-conduit, http-types, lens, lens-aeson, network, QuickCheck
···
pname = "wai-middleware-rollbar";
+
sha256 = "0vs03d3xm8hmahd72znkk4zw0fz33mbs5pvqins6kyizcgi4j5f5";
libraryHaskellDepends = [
aeson base bytestring case-insensitive hostname http-client
http-conduit http-types network text time unordered-containers uuid
···
hydraPlatforms = stdenv.lib.platforms.none;
+
"wai-session-postgresql_0_2_1_2" = callPackage
+
({ mkDerivation, base, bytestring, cereal, cookie, data-default
+
, entropy, postgresql-simple, resource-pool, text, time
+
, transformers, wai, wai-session
+
pname = "wai-session-postgresql";
+
sha256 = "10xc34a1l6g2lr8b4grvv17281689gdb8q1vh3kkip5lk7fp1m9r";
+
libraryHaskellDepends = [
+
base bytestring cereal cookie data-default entropy
+
postgresql-simple resource-pool text time transformers wai
+
base bytestring data-default postgresql-simple text wai-session
+
homepage = "https://github.com/hce/postgresql-session#readme";
+
description = "PostgreSQL backed Wai session store";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"wai-session-tokyocabinet" = callPackage
({ mkDerivation, base, bytestring, cereal, errors
, tokyocabinet-haskell, transformers, wai-session
···
license = stdenv.lib.licenses.bsd3;
+
"weeder_0_1_9" = callPackage
+
({ mkDerivation, aeson, base, bytestring, cmdargs, deepseq
+
, directory, extra, filepath, foundation, hashable, process, text
+
, unordered-containers, vector, yaml
+
sha256 = "1k5q34zyw2ajy7k5imxygs86q0a245ax5ch4kgff12pfpyz0jmz7";
+
executableHaskellDepends = [
+
aeson base bytestring cmdargs deepseq directory extra filepath
+
foundation hashable process text unordered-containers vector yaml
+
homepage = "https://github.com/ndmitchell/weeder#readme";
+
description = "Detect dead code";
+
license = stdenv.lib.licenses.bsd3;
+
hydraPlatforms = stdenv.lib.platforms.none;
({ mkDerivation, base, bytestring-trie, containers, deepseq, mtl
, process, random, split, template-haskell, temporary
···
+
sha256 = "138a8az5500ys2yvwif17vbmsmisd0r3q4yc8azfrd09y359ndlq";
libraryHaskellDepends = [
···
homepage = "https://gitlab.com/k0001/xmlbf";
description = "xeno backend support for the xmlbf library";
license = stdenv.lib.licenses.asl20;
+
hydraPlatforms = stdenv.lib.platforms.none;
"xmlbf-xmlhtml" = callPackage
···
homepage = "https://gitlab.com/k0001/xmlbf";
description = "xmlhtml backend support for the xmlbf library";
license = stdenv.lib.licenses.asl20;
+
hydraPlatforms = stdenv.lib.platforms.none;
···
license = stdenv.lib.licenses.mit;
+
"yesod-auth_1_4_21" = callPackage
+
({ mkDerivation, aeson, authenticate, base, base16-bytestring
+
, base64-bytestring, binary, blaze-builder, blaze-html
+
, blaze-markup, byteable, bytestring, conduit, conduit-extra
+
, containers, cryptonite, data-default, email-validate, file-embed
+
, http-client, http-conduit, http-types, lifted-base, memory
+
, mime-mail, network-uri, nonce, persistent, persistent-template
+
, random, resourcet, safe, shakespeare, template-haskell, text
+
, time, transformers, unordered-containers, wai, yesod-core
+
, yesod-form, yesod-persistent
+
sha256 = "1qqwg9l65m9q3l8z0r1bnihqb5rbbp2c2w6gbk49kx9127rf4488";
+
libraryHaskellDepends = [
+
aeson authenticate base base16-bytestring base64-bytestring binary
+
blaze-builder blaze-html blaze-markup byteable bytestring conduit
+
conduit-extra containers cryptonite data-default email-validate
+
file-embed http-client http-conduit http-types lifted-base memory
+
mime-mail network-uri nonce persistent persistent-template random
+
resourcet safe shakespeare template-haskell text time transformers
+
unordered-containers wai yesod-core yesod-form yesod-persistent
+
homepage = "http://www.yesodweb.com/";
+
description = "Authentication for Yesod";
+
license = stdenv.lib.licenses.mit;
+
hydraPlatforms = stdenv.lib.platforms.none;
"yesod-auth-account" = callPackage
({ mkDerivation, base, blaze-html, bytestring, hspec, monad-logger
, mtl, nonce, persistent, persistent-sqlite, pwstore-fast
···
homepage = "https://github.com/Qinka/Yu";
description = "The core of Yu";
license = stdenv.lib.licenses.gpl3;
+
hydraPlatforms = stdenv.lib.platforms.none;
"yu-launch" = callPackage
···
homepage = "https://github.com/Qinka/Yu";
description = "The launcher for Yu";
license = stdenv.lib.licenses.gpl3;
+
hydraPlatforms = stdenv.lib.platforms.none;
pyrox.dev