master..a0053fe · typeable/nixpkgs-stackage

git.iko.soy/typeable/nixpkgs-stackage

671 files changed+5768781−635480

unifiedsplit

.travis.yml+3−12

@@ -2,16 +2,7 @@ language: nix

33install:

44 - mkdir -p ~/.config/nixpkgs/overlays

5− - ln -s "$(pwd)/default.nix" ~/.config/nixpkgs/overlays/stackage-overlay.nix

6−

5+ - ln -s "$(pwd)/haskell-overlay.nix" ~/.config/nixpkgs/overlays/stackage-overlay.nix

76script:

8− - nix-build nixpkgs.nix -A stackage2nix --dry-run

9−

10−jobs:

11− include:

12− - env: NIXPKGS=pinned

13− - env: NIXPKGS=unstable

14− before_script: nix-env -i stackage2nix --dry-run

15− allow_failures:

16− - env: NIXPKGS=unstable

17−

7+ - nix-env -i stackage2nix

8+ - stackage2nix --version

README.md+9−41

@@ -1,24 +1,21 @@

1−# nixpkgs-stackage

1+# Nix

3−[![Build Status](https://travis-ci.org/typeable/nixpkgs-stackage.svg?branch=master)](https://travis-ci.org/typeable/nixpkgs-stackage)

3+Nixpgs overlay

5−Nixpkgs overlay adding Stackage Haskell packages at the `pkgs.haskell.packages.stackage`

5+## Packages

7−# Install

7+- Stackage LTS releases

8+- [stackage2nix][]

9−Symlink the current `./default.nix` into the `~/.config/nixpkgs/overlays` folder.

10+## Install

11+

12+Symlink the current `./haskell-overlay.nix` into the `~/.config/nixpkgs/overlays` folder.

1013

1114```

1215cd ~/.config/nixpkgs/overlays

13−ln -s /path/to/default.nix stackage-overlay.nix

16+ln -s /path/to/haskell-overlay.nix stackage-overlay.nix

1417```

1518

16−## Contents

17−

18−- Stackage LTS releases at `pkgs.haskell.packages.stackage`

19−- [stackage2nix][] at `pkgs`

20−- build utils at `pkgs.haskell.packages.stackage.lib`

21−

2219## Haskell overlay

2320

2421List LTS packages:

@@ -41,33 +38,4 @@ Update script will add missing lts releases to `stackage` directory:

4138./update.sh

4239```

4340

44−# Examples

45−

46−Build derivation for `stackage2nix` from `stackage2nix.json` source.

47−

48−``` nix

49−let

50− nixpkgs = import <nixpkgs> {

51− overlays = [ (import ../default.nix) ];

52− };

53− inherit (nixpkgs) pkgs lib;

54−

55− stackage2nixSrc = pkgs.fetchFromGitHub (lib.importJSON ./stackage2nix.json);

56−

57− stackage = nixpkgs.haskell.packages.stackage.lib.callStackage2nix "stackage2nix" stackage2nixSrc {

58− inherit nixpkgs;

59− };

60−in

61− stackage

62−```

63−

64−Build:

65−

66−```

67−nix-build example.nix -A stackage2nix

68−```

69−

70−See [examples](./examples) directory for more

71−

72−

7341[stackage2nix]: https://github.com/typeable/stackage2nix

cache-version.txtdeleted−1

@@ -1 +0,0 @@

1−2019-05-14

cacheVersion.txtnew file+1

@@ -0,0 +1 @@

1+2017-12-30

default.nix+5−68

@@ -1,70 +1,7 @@

1−self: super:

1+# Nixpkgs overlay which aggregates overlays for tools and products

3−let

3+{ nixpkgs ? import <nixpkgs> {} }:

5− # from pkgs/stdenv/generic/make-derivation.nix

6− # This parameter is sometimes a string, sometimes null, and sometimes a list, yuck

7− normalizedConfigureFlags = configureFlags: let inherit (super) lib; in

8− (/**/ if lib.isString configureFlags then [configureFlags]

9− else if configureFlags == null then []

10− else configureFlags);

11−

12− stackage2nixPackages = import ./stackage2nix/stackage-packages.nix { nixpkgs = self; };

13−

14−in {

15− haskell = super.haskell // {

16− packages = super.haskell.packages // {

17− stackage = super.callPackage ./stackage {} // {

18− lib = super.callPackage ./lib.nix {};

19− };

20− };

21− };

22−

23− stackage2nix = self.callPackage ./stackage2nix {

24− drv = super.haskell.lib.disableSharedExecutables stackage2nixPackages.stackage2nix;

25− };

26−

27− stackage2nixWrapper = import ./stackage2nix/impure.nix {

28− cacheVersion = builtins.readFile ./cache-version.txt;

29− inherit self;

30− };

31−

32− stackage2nix-static = import ./stackage2nix/impure.nix {

33− drv =

34− let

35− stackagePackages = import ./stackage2nix/stackage-packages.nix { nixpkgs = self; };

36− in self.haskell.lib.overrideCabal stackagePackages.stackage2nix (drv: {

37− enableSharedExecutables = false;

38− enableSharedLibraries = false;

39− configureFlags = [

40− "--ghc-option=-optl=-static"

41− "--ghc-option=-optl=-L${self.glibc.static}/lib"

42− "--ghc-option=-optl=-L${self.gmp.override { withStatic = true; }}/lib"

43− "--ghc-option=-optl=-L${self.icu-static.static}/lib"

44− "--ghc-option=-optl=-L${self.openssl-static.static}/lib"

45− "--ghc-option=-optl=-L${self.zlib.static}/lib"

46− ];

47− });

48− cacheVersion = builtins.readFile ./cache-version.txt;

49− inherit self;

50− };

51−

52− icu-static = super.icu.overrideAttrs (attrs: {

53− dontDisableStatic = true;

54− configureFlags = normalizedConfigureFlags attrs.configureFlags ++ [ "--enable-static" ];

55− outputs = attrs.outputs ++ [ "static" ];

56− postInstall = ''

57− moveToOutput "lib/*.a" "$static"

58− '' + (if attrs ? postInstall then attrs.postInstall else "");

59− });

60−

61− openssl-static = super.openssl.overrideAttrs (attrs: {

62− dontDisableStatic = true;

63− outputs = attrs.outputs ++ [ "static" ];

64− postInstall = ''

65− mkdir -p $static/lib;

66− cp -v *.a $static/lib;

67− '' + (if attrs ? postInstall then attrs.postInstall else "");

68− });

69−

70−}

5+with nixpkgs.lib;

6+let haskellOverlay = import ./haskell-overlay.nix;

7+in fix (extends haskellOverlay (_: nixpkgs))

examples/example-override-pinned.nixdeleted−16

@@ -1,16 +0,0 @@

1−# Stackage packages with Nixpkgs pinned to specific revision

2−

3−let

4− nixpkgs = import ./nixpkgs-pinned.nix {};

5− inherit (nixpkgs) pkgs lib haskell;

6−

7− stackage2nixSrc = pkgs.fetchFromGitHub (lib.importJSON ./stackage2nix.json);

8−

9− stackagePackages = haskell.packages.stackage.lib.callStackage2nix "stackage2nix" stackage2nixSrc { inherit nixpkgs; };

10− stackage = stackagePackages.override {

11− overrides = self: super: {

12− stackage2nix = haskell.lib.disableSharedExecutables super.stackage2nix;

13− };

14− };

15−in

16− stackage

examples/example-override.nixdeleted−20

@@ -1,20 +0,0 @@

1−# Stackage packages accept `overrides` like Nixpkgs `haskellPackages`

2−

3−let

4− _pkgs = import <nixpkgs> {};

5− _stackageOverlay = _pkgs.fetchFromGitHub (_pkgs.lib.importJSON ./nixpkgs-stackage.json);

6− nixpkgs = import <nixpkgs> {

7− overlays = [ (import _stackageOverlay) ];

8− };

9− inherit (nixpkgs) pkgs lib haskell;

10−

11− stackage2nixSrc = pkgs.fetchFromGitHub (lib.importJSON ./stackage2nix.json);

12−

13− stackagePackages = haskell.packages.stackage.lib.callStackage2nix "stackage2nix" stackage2nixSrc { inherit nixpkgs; };

14− stackage = stackagePackages.override {

15− overrides = self: super: {

16− stackage2nix = haskell.lib.disableSharedExecutables super.stackage2nix;

17− };

18− };

19−in

20− stackage

examples/example.nixdeleted−16

@@ -1,16 +0,0 @@

1−# Produces Stackage packages set with `stackage2nix` package

2−# from `${stackage2nixSrc}/stack.yaml`

3−#

4−# nix-build ./example.nix -A stackage2nix

5−

6−let

7− nixpkgs = import <nixpkgs> {

8− overlays = [ (import ../default.nix) ];

9− };

10− inherit (nixpkgs) pkgs lib;

11−

12− stackage2nixSrc = pkgs.fetchFromGitHub (lib.importJSON ./stackage2nix.json);

13−

14− stackage = nixpkgs.haskell.packages.stackage.lib.callStackage2nix "stackage2nix" stackage2nixSrc;

15−in

16− stackage

examples/nixpkgs-pinned.nixdeleted−15

@@ -1,15 +0,0 @@

1−# Nixpkgs with Stackage overlay pinned to specific version set in `nixpkgs.json`

2−

3−{ overlays ? []

4−, system ? null

5−, config ? { } }:

6−

7−let

8− _pkgs = import <nixpkgs> {};

9− _pkgsPath = _pkgs.fetchFromGitHub (_pkgs.lib.importJSON ../nixpkgs.json);

10− _stackageOverlayLocal = ../.;

11−in

12− import _pkgsPath ({

13− overlays = [ (import _stackageOverlayLocal) ] ++ overlays;

14− config = config // { allowUnfree = true; };

15− } // (if system != null then { inherit system; } else { }))

examples/stackage2nix.jsondeleted−6

@@ -1,6 +0,0 @@

1−{

2− "owner": "typeable",

3− "repo": "stackage2nix",

4− "rev": "8d6e70044a4bafa0f8d5bdc011ac00634549a13b",

5− "sha256": "1lcs8ii0nqlyg1lj50zjabw8z4crkk59dpfyykpxraa9whkklg4d"

6−}

haskell-overlay.nixnew file+14

@@ -0,0 +1,14 @@

1+self: super:

3+{

4+ haskell = super.haskell // {

5+ packages = super.haskell.packages // {

6+ stackage = super.callPackage ./stackage {};

7+ };

8+ };

10+ stackage2nix = import ./stackage2nix {

11+ nixpkgs = self;

12+ cacheVersion = builtins.readFile ./cacheVersion.txt;

13+ };

14+}

lib.nixdeleted−67

@@ -1,67 +0,0 @@

1−{ stdenv, lib, cacert, glibcLocales, stackage2nix, stackage2nixWrapper }:

2−

3−rec {

4−

5− stackage2nixGeneric = { drv, pname, installPhase, name, src }:

6− stdenv.mkDerivation {

7−

8− name = "${pname}-${name}";

9−

10− phases = [ "installPhase" ];

11− buildInputs = [ drv ];

12− preferLocalBuild = true;

13−

14− SSL_CERT_FILE="${cacert}/etc/ssl/certs/ca-bundle.crt";

15− LANG = "en_US.UTF-8";

16− LOCALE_ARCHIVE = lib.optionalString stdenv.isLinux "${glibcLocales}/lib/locale/locale-archive";

17−

18− inherit installPhase;

19− };

20−

21− stackage2nixWrapperSrc = { name, src }: stackage2nixGeneric {

22− drv = stackage2nixWrapper;

23− pname = "stackage2nixWrapper";

24− installPhase = ''

25− export HOME="$TMP"

26− mkdir -p $out

27− cd $out

28− stackage2nix "${src}"

29− '';

30−

31− inherit name src;

32− };

33−

34− stackage2nixSrc = { name, src }: stackage2nixGeneric {

35− drv = stackage2nix;

36− pname = "stackage2nix";

37− installPhase = ''

38− export HOME="$TMP"

39− mkdir -p $out

40− cd $out

41− stackage2nix "${src}"

42− '';

43−

44− inherit name src;

45− };

46−

47− stackage2nixSrcArgs = { name, src, stackage-lts, all-cabal-hashes, hackage-db }: stackage2nixGeneric {

48− drv = stackage2nix;

49− pname = "stackage2nixArgs";

50− installPhase = ''

51− export HOME="$TMP"

52− mkdir -p $out

53− cd $out

54− stackage2nix --all-cabal-hashes ${all-cabal-hashes} --lts-haskell ${stackage-lts} --hackage-db ${hackage-db}

55− '';

56−

57− inherit name src;

58− };

59−

60− callStackage2nix = name: src: import (stackage2nixSrc { inherit name src; });

61−

62− callStackage2nixWrapper = name: src: import (stackage2nixWrapperSrc { inherit name src; });

63−

64− callStackage2nixArgs = name: src: stackage-lts: all-cabal-hashes: hackage-db:

65− import (stackage2nixSrcArgs { inherit name src stackage-lts all-cabal-hashes hackage-db; });

66−

67−}

nixpkgs.jsondeleted−6

@@ -1,6 +0,0 @@

1−{

2− "owner": "NixOS",

3− "repo": "nixpkgs-channels",

4− "rev": "d6c6c7fcec6dbd2b8ab14f0b35d56c7733872baa",

5− "sha256": "1bq59575b58lmh5w8bh7pwp17c3p2nm651bz1i3q224c4zsj9294"

6−}

nixpkgs.nixdeleted−15

@@ -1,15 +0,0 @@

1−# Nixpkgs with Stackage overlay pinned to `nixpkgs.json` revision

2−

3−{ pkgsPath ? null

4−, overlays ? []

5−, system ? null }:

6−

7−let

8− _pkgs = import <nixpkgs> {};

9− _pkgsPath = if pkgsPath != null

10− then pkgsPath

11− else _pkgs.fetchFromGitHub (_pkgs.lib.importJSON ./nixpkgs.json);

12−in

13− import _pkgsPath ({

14− overlays = [ (import ./default.nix) ] ++ overlays;

15− } // (if system != null then { inherit system; } else {}))

release.nix+18−25

@@ -1,49 +1,42 @@

11{ supportedSystems ? [ "x86_64-linux" "i686-linux" ]

22, supportedReleases ? null

3−, inHydra ? true

4−, pkgs ? import <nixpkgs> {}

5−}:

3+, inHydra ? true }:

75let

8− inherit (pkgs) lib;

9−

10− release = import (pkgs.path + "/pkgs/top-level/release-lib.nix") {

11− inherit supportedSystems;

12− nixpkgsArgs = { overlays = [ (import ./default.nix) ]; };

13− };

14−

15− # supportedStackageReleases :: [StackageVersion]

6+ lib = (import <nixpkgs> {}).lib;

167 supportedStackageReleases =

178 if supportedReleases == null

189 then

19− lib.unique

20− (map (builtins.replaceStrings ["."] [""])

21− (builtins.filter (x: x != "")

22− (lib.splitString "\n"

23− (builtins.readFile ./supported-stackage-releases.txt))))

10+ builtins.filter (x: x != "")

11+ (lib.splitString "\n"

12+ (builtins.readFile ./supported-stackage-releases.txt))

2413 else

2514 supportedReleases;

15+ release = import <nixpkgs/pkgs/top-level/release-lib.nix> {

16+ inherit supportedSystems;

17+ nixpkgsArgs = { overlays = [ (import ./haskell-overlay.nix) ]; };

18+ };

2619

2720 # hasSupportedSystem :: System -> Derivation -> Bool

2821 hasSupportedSystem = system: pkg:

2922 # Test `isAttrs pkg` to ensure that pkg is a derivation

3023 lib.isAttrs pkg && lib.elem system pkg.meta.platforms;

3124

32− # genJobSetFiltered :: System -> StackageVersion -> AttrSet

33− genJobSetFiltered = system: stackage:

25+ # genJobSetFiltered :: StackageRelease -> System -> AttrSet

26+ genJobSetFiltered = lts: system:

3427 lib.filterAttrs

3528 (_: pkg: hasSupportedSystem system pkg)

36− (release.pkgsFor system).haskell.packages.stackage."${stackage}";

29+ (release.pkgsFor system).haskell.packages.stackage."${lts}";

3730

38− # genJobSetFull :: System -> StackageVersion -> AttrSet

39− genJobSetFull = system: stackage:

40− (release.pkgsFor system).haskell.packages.stackage."${stackage}";

31+ # genJobSetFull :: StackageRelease -> System -> AttrSet

32+ genJobSetFull = lts: system:

33+ (release.pkgsFor system).haskell.packages.stackage."${lts}";

4134

4235 # genJobSet :: StackageRelease -> System -> AttrSet

4336 genJobSet = if inHydra then genJobSetFull else genJobSetFiltered;

4437

4538in

46− lib.genAttrs supportedSystems (system:

47− lib.genAttrs supportedStackageReleases (stackage:

48− genJobSet system stackage

39+ lib.genAttrs supportedStackageReleases (stackage:

40+ lib.genAttrs supportedSystems (system:

41+ genJobSet stackage system

4942 ))

stackage/default.nix+198−22

@@ -1,25 +1,201 @@

11{ callPackage }:

22{

3− lts-130 = callPackage ./lts-13.0 {};

4− lts-131 = callPackage ./lts-13.1 {};

5− lts-132 = callPackage ./lts-13.2 {};

6− lts-133 = callPackage ./lts-13.3 {};

7− lts-134 = callPackage ./lts-13.4 {};

8− lts-135 = callPackage ./lts-13.5 {};

9− lts-136 = callPackage ./lts-13.6 {};

10− lts-137 = callPackage ./lts-13.7 {};

11− lts-138 = callPackage ./lts-13.8 {};

12− lts-139 = callPackage ./lts-13.9 {};

13− lts-1310 = callPackage ./lts-13.10 {};

14− lts-1311 = callPackage ./lts-13.11 {};

15− lts-1312 = callPackage ./lts-13.12 {};

16− lts-1313 = callPackage ./lts-13.13 {};

17− lts-1314 = callPackage ./lts-13.14 {};

18− lts-1315 = callPackage ./lts-13.15 {};

19− lts-1316 = callPackage ./lts-13.16 {};

20− lts-1317 = callPackage ./lts-13.17 {};

21− lts-1318 = callPackage ./lts-13.18 {};

22− lts-1319 = callPackage ./lts-13.19 {};

23− lts-1320 = callPackage ./lts-13.20 {};

24− lts-1321 = callPackage ./lts-13.21 {};

3+ lts-00 = callPackage ./lts-0.0 {};

4+ lts-01 = callPackage ./lts-0.1 {};

5+ lts-02 = callPackage ./lts-0.2 {};

6+ lts-03 = callPackage ./lts-0.3 {};

7+ lts-04 = callPackage ./lts-0.4 {};

8+ lts-05 = callPackage ./lts-0.5 {};

9+ lts-06 = callPackage ./lts-0.6 {};

10+ lts-07 = callPackage ./lts-0.7 {};

11+ lts-10 = callPackage ./lts-1.0 {};

12+ lts-11 = callPackage ./lts-1.1 {};

13+ lts-12 = callPackage ./lts-1.2 {};

14+ lts-14 = callPackage ./lts-1.4 {};

15+ lts-15 = callPackage ./lts-1.5 {};

16+ lts-17 = callPackage ./lts-1.7 {};

17+ lts-18 = callPackage ./lts-1.8 {};

18+ lts-19 = callPackage ./lts-1.9 {};

19+ lts-110 = callPackage ./lts-1.10 {};

20+ lts-111 = callPackage ./lts-1.11 {};

21+ lts-112 = callPackage ./lts-1.12 {};

22+ lts-113 = callPackage ./lts-1.13 {};

23+ lts-114 = callPackage ./lts-1.14 {};

24+ lts-115 = callPackage ./lts-1.15 {};

25+ lts-20 = callPackage ./lts-2.0 {};

26+ lts-21 = callPackage ./lts-2.1 {};

27+ lts-22 = callPackage ./lts-2.2 {};

28+ lts-23 = callPackage ./lts-2.3 {};

29+ lts-24 = callPackage ./lts-2.4 {};

30+ lts-25 = callPackage ./lts-2.5 {};

31+ lts-26 = callPackage ./lts-2.6 {};

32+ lts-27 = callPackage ./lts-2.7 {};

33+ lts-28 = callPackage ./lts-2.8 {};

34+ lts-29 = callPackage ./lts-2.9 {};

35+ lts-210 = callPackage ./lts-2.10 {};

36+ lts-211 = callPackage ./lts-2.11 {};

37+ lts-212 = callPackage ./lts-2.12 {};

38+ lts-213 = callPackage ./lts-2.13 {};

39+ lts-214 = callPackage ./lts-2.14 {};

40+ lts-215 = callPackage ./lts-2.15 {};

41+ lts-216 = callPackage ./lts-2.16 {};

42+ lts-217 = callPackage ./lts-2.17 {};

43+ lts-218 = callPackage ./lts-2.18 {};

44+ lts-219 = callPackage ./lts-2.19 {};

45+ lts-220 = callPackage ./lts-2.20 {};

46+ lts-221 = callPackage ./lts-2.21 {};

47+ lts-222 = callPackage ./lts-2.22 {};

48+ lts-30 = callPackage ./lts-3.0 {};

49+ lts-31 = callPackage ./lts-3.1 {};

50+ lts-32 = callPackage ./lts-3.2 {};

51+ lts-33 = callPackage ./lts-3.3 {};

52+ lts-34 = callPackage ./lts-3.4 {};

53+ lts-35 = callPackage ./lts-3.5 {};

54+ lts-36 = callPackage ./lts-3.6 {};

55+ lts-37 = callPackage ./lts-3.7 {};

56+ lts-38 = callPackage ./lts-3.8 {};

57+ lts-39 = callPackage ./lts-3.9 {};

58+ lts-310 = callPackage ./lts-3.10 {};

59+ lts-311 = callPackage ./lts-3.11 {};

60+ lts-312 = callPackage ./lts-3.12 {};

61+ lts-313 = callPackage ./lts-3.13 {};

62+ lts-314 = callPackage ./lts-3.14 {};

63+ lts-315 = callPackage ./lts-3.15 {};

64+ lts-316 = callPackage ./lts-3.16 {};

65+ lts-317 = callPackage ./lts-3.17 {};

66+ lts-318 = callPackage ./lts-3.18 {};

67+ lts-319 = callPackage ./lts-3.19 {};

68+ lts-320 = callPackage ./lts-3.20 {};

69+ lts-321 = callPackage ./lts-3.21 {};

70+ lts-322 = callPackage ./lts-3.22 {};

71+ lts-40 = callPackage ./lts-4.0 {};

72+ lts-41 = callPackage ./lts-4.1 {};

73+ lts-42 = callPackage ./lts-4.2 {};

74+ lts-50 = callPackage ./lts-5.0 {};

75+ lts-51 = callPackage ./lts-5.1 {};

76+ lts-52 = callPackage ./lts-5.2 {};

77+ lts-53 = callPackage ./lts-5.3 {};

78+ lts-54 = callPackage ./lts-5.4 {};

79+ lts-55 = callPackage ./lts-5.5 {};

80+ lts-56 = callPackage ./lts-5.6 {};

81+ lts-57 = callPackage ./lts-5.7 {};

82+ lts-58 = callPackage ./lts-5.8 {};

83+ lts-59 = callPackage ./lts-5.9 {};

84+ lts-510 = callPackage ./lts-5.10 {};

85+ lts-511 = callPackage ./lts-5.11 {};

86+ lts-512 = callPackage ./lts-5.12 {};

87+ lts-513 = callPackage ./lts-5.13 {};

88+ lts-514 = callPackage ./lts-5.14 {};

89+ lts-515 = callPackage ./lts-5.15 {};

90+ lts-516 = callPackage ./lts-5.16 {};

91+ lts-517 = callPackage ./lts-5.17 {};

92+ lts-518 = callPackage ./lts-5.18 {};

93+ lts-60 = callPackage ./lts-6.0 {};

94+ lts-61 = callPackage ./lts-6.1 {};

95+ lts-62 = callPackage ./lts-6.2 {};

96+ lts-63 = callPackage ./lts-6.3 {};

97+ lts-64 = callPackage ./lts-6.4 {};

98+ lts-65 = callPackage ./lts-6.5 {};

99+ lts-66 = callPackage ./lts-6.6 {};

100+ lts-67 = callPackage ./lts-6.7 {};

101+ lts-68 = callPackage ./lts-6.8 {};

102+ lts-69 = callPackage ./lts-6.9 {};

103+ lts-610 = callPackage ./lts-6.10 {};

104+ lts-611 = callPackage ./lts-6.11 {};

105+ lts-612 = callPackage ./lts-6.12 {};

106+ lts-613 = callPackage ./lts-6.13 {};

107+ lts-614 = callPackage ./lts-6.14 {};

108+ lts-615 = callPackage ./lts-6.15 {};

109+ lts-616 = callPackage ./lts-6.16 {};

110+ lts-617 = callPackage ./lts-6.17 {};

111+ lts-618 = callPackage ./lts-6.18 {};

112+ lts-619 = callPackage ./lts-6.19 {};

113+ lts-620 = callPackage ./lts-6.20 {};

114+ lts-621 = callPackage ./lts-6.21 {};

115+ lts-622 = callPackage ./lts-6.22 {};

116+ lts-623 = callPackage ./lts-6.23 {};

117+ lts-624 = callPackage ./lts-6.24 {};

118+ lts-625 = callPackage ./lts-6.25 {};

119+ lts-626 = callPackage ./lts-6.26 {};

120+ lts-627 = callPackage ./lts-6.27 {};

121+ lts-628 = callPackage ./lts-6.28 {};

122+ lts-629 = callPackage ./lts-6.29 {};

123+ lts-630 = callPackage ./lts-6.30 {};

124+ lts-631 = callPackage ./lts-6.31 {};

125+ lts-632 = callPackage ./lts-6.32 {};

126+ lts-633 = callPackage ./lts-6.33 {};

127+ lts-634 = callPackage ./lts-6.34 {};

128+ lts-635 = callPackage ./lts-6.35 {};

129+ lts-70 = callPackage ./lts-7.0 {};

130+ lts-71 = callPackage ./lts-7.1 {};

131+ lts-72 = callPackage ./lts-7.2 {};

132+ lts-73 = callPackage ./lts-7.3 {};

133+ lts-74 = callPackage ./lts-7.4 {};

134+ lts-75 = callPackage ./lts-7.5 {};

135+ lts-76 = callPackage ./lts-7.6 {};

136+ lts-77 = callPackage ./lts-7.7 {};

137+ lts-78 = callPackage ./lts-7.8 {};

138+ lts-79 = callPackage ./lts-7.9 {};

139+ lts-710 = callPackage ./lts-7.10 {};

140+ lts-711 = callPackage ./lts-7.11 {};

141+ lts-712 = callPackage ./lts-7.12 {};

142+ lts-713 = callPackage ./lts-7.13 {};

143+ lts-714 = callPackage ./lts-7.14 {};

144+ lts-715 = callPackage ./lts-7.15 {};

145+ lts-716 = callPackage ./lts-7.16 {};

146+ lts-717 = callPackage ./lts-7.17 {};

147+ lts-718 = callPackage ./lts-7.18 {};

148+ lts-719 = callPackage ./lts-7.19 {};

149+ lts-720 = callPackage ./lts-7.20 {};

150+ lts-721 = callPackage ./lts-7.21 {};

151+ lts-722 = callPackage ./lts-7.22 {};

152+ lts-723 = callPackage ./lts-7.23 {};

153+ lts-724 = callPackage ./lts-7.24 {};

154+ lts-80 = callPackage ./lts-8.0 {};

155+ lts-81 = callPackage ./lts-8.1 {};

156+ lts-82 = callPackage ./lts-8.2 {};

157+ lts-83 = callPackage ./lts-8.3 {};

158+ lts-84 = callPackage ./lts-8.4 {};

159+ lts-85 = callPackage ./lts-8.5 {};

160+ lts-86 = callPackage ./lts-8.6 {};

161+ lts-87 = callPackage ./lts-8.7 {};

162+ lts-88 = callPackage ./lts-8.8 {};

163+ lts-89 = callPackage ./lts-8.9 {};

164+ lts-810 = callPackage ./lts-8.10 {};

165+ lts-811 = callPackage ./lts-8.11 {};

166+ lts-812 = callPackage ./lts-8.12 {};

167+ lts-813 = callPackage ./lts-8.13 {};

168+ lts-814 = callPackage ./lts-8.14 {};

169+ lts-815 = callPackage ./lts-8.15 {};

170+ lts-816 = callPackage ./lts-8.16 {};

171+ lts-817 = callPackage ./lts-8.17 {};

172+ lts-818 = callPackage ./lts-8.18 {};

173+ lts-819 = callPackage ./lts-8.19 {};

174+ lts-820 = callPackage ./lts-8.20 {};

175+ lts-821 = callPackage ./lts-8.21 {};

176+ lts-822 = callPackage ./lts-8.22 {};

177+ lts-823 = callPackage ./lts-8.23 {};

178+ lts-824 = callPackage ./lts-8.24 {};

179+ lts-90 = callPackage ./lts-9.0 {};

180+ lts-91 = callPackage ./lts-9.1 {};

181+ lts-92 = callPackage ./lts-9.2 {};

182+ lts-93 = callPackage ./lts-9.3 {};

183+ lts-94 = callPackage ./lts-9.4 {};

184+ lts-95 = callPackage ./lts-9.5 {};

185+ lts-96 = callPackage ./lts-9.6 {};

186+ lts-97 = callPackage ./lts-9.7 {};

187+ lts-98 = callPackage ./lts-9.8 {};

188+ lts-99 = callPackage ./lts-9.9 {};

189+ lts-910 = callPackage ./lts-9.10 {};

190+ lts-911 = callPackage ./lts-9.11 {};

191+ lts-912 = callPackage ./lts-9.12 {};

192+ lts-913 = callPackage ./lts-9.13 {};

193+ lts-914 = callPackage ./lts-9.14 {};

194+ lts-915 = callPackage ./lts-9.15 {};

195+ lts-916 = callPackage ./lts-9.16 {};

196+ lts-917 = callPackage ./lts-9.17 {};

197+ lts-918 = callPackage ./lts-9.18 {};

198+ lts-919 = callPackage ./lts-9.19 {};

199+ lts-920 = callPackage ./lts-9.20 {};

200+ lts-100 = callPackage ./lts-10.0 {};

25201}

stackage/lts-0.0/configuration-packages.nixnew file+47

@@ -0,0 +1,47 @@

1+# Generated by stackage2nix 0.5.0 from "/nix/store/5hv357jpjvwz6dk84fmcz1mj7agww772-stackage-lts/lts-0.0.yaml"

2+{ pkgs, haskellLib }:

4+with haskellLib; self: super: {

6+ # core packages

7+ "Cabal" = null;

8+ "array" = null;

9+ "base" = null;

10+ "bin-package-db" = null;

11+ "binary" = null;

12+ "bytestring" = null;

13+ "containers" = null;

14+ "deepseq" = null;

15+ "directory" = null;

16+ "filepath" = null;

17+ "ghc-prim" = null;

18+ "haskeline" = null;

19+ "haskell2010" = null;

20+ "haskell98" = null;

21+ "hoopl" = null;

22+ "hpc" = null;

23+ "integer-gmp" = null;

24+ "old-locale" = null;

25+ "old-time" = null;

26+ "pretty" = null;

27+ "process" = null;

28+ "rts" = null;

29+ "template-haskell" = null;

30+ "terminfo" = null;

31+ "time" = null;

32+ "transformers" = null;

33+ "unix" = null;

34+ "xhtml" = null;

35+ # break cycle: text QuickCheck test-framework xml test-framework-hunit test-framework-quickcheck2

36+ "QuickCheck" = dontCheck super.QuickCheck;

37+ "text" = dontCheck super.text;

38+ # break cycle: hspec-meta hspec-expectations hspec hspec-core silently nanospec hspec-discover stringbuilder markdown-unlit

39+ "markdown-unlit" = dontCheck super.markdown-unlit;

40+ "stringbuilder" = dontCheck super.stringbuilder;

41+ "hspec-discover" = dontCheck super.hspec-discover;

42+ "nanospec" = dontCheck super.nanospec;

43+ "hspec-expectations" = dontCheck super.hspec-expectations;

44+ # break cycle: statistics monad-par mwc-random vector-algorithms

45+ "mwc-random" = dontCheck super.mwc-random;

46+

47+}

stackage/lts-0.0/default.nixnew file+14

@@ -0,0 +1,14 @@

1+# Generated by stackage2nix 0.5.0 from "/nix/store/5hv357jpjvwz6dk84fmcz1mj7agww772-stackage-lts/lts-0.0.yaml"

2+{ callPackage, pkgs, overrides ? (self: super: {})

3+, packageSetConfig ? (sefl: super: {})

4+}:

6+let

7+ haskellLib = pkgs.haskell.lib;

8+in callPackage (<nixpkgs/pkgs/development/haskell-modules>) {

9+ ghc = pkgs.haskell.compiler.ghc783;

10+ compilerConfig = import ./configuration-packages.nix { inherit pkgs haskellLib; };

11+ initialPackages = import ./packages.nix;

12+ configurationCommon = if builtins.pathExists ./configuration-common.nix then import ./configuration-common.nix else args: self: super: {};

13+ inherit haskellLib overrides packageSetConfig;

14+}

stackage/lts-0.0/packages.nixnew file+17455

@@ -0,0 +1,17455 @@

1+# Generated by stackage2nix 0.5.0 from "/nix/store/5hv357jpjvwz6dk84fmcz1mj7agww772-stackage-lts/lts-0.0.yaml"

2+{ pkgs, stdenv, callPackage }:

4+self: {

5+ "AC-Vector" = callPackage

6+ ({ mkDerivation, base }:

7+ mkDerivation {

8+ pname = "AC-Vector";

9+ version = "2.3.2";

10+ sha256 = "04ahf6ldfhvzbml9xd6yplygn8ih7b8zz7cw03hkr053g5kzylay";

11+ configureFlags = [

12+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14+ "-fsplitbase" "-f-test-hlint"

15+ ];

16+ libraryHaskellDepends = [ base ];

17+ description = "Efficient geometric vectors and transformations";

18+ license = stdenv.lib.licenses.bsd3;

19+ }) {};

20+ "BlastHTTP" = callPackage

21+ ({ mkDerivation, base, biocore, blastxml, bytestring, conduit, HTTP

22+ , http-conduit, hxt, mtl, network, transformers

23+ }:

24+ mkDerivation {

25+ pname = "BlastHTTP";

26+ version = "1.0.1";

27+ sha256 = "1qxf2lqsbwmfqkzabx8qpavf3da4lq3j1v1rdsv42gl27lqhbayi";

28+ revision = "2";

29+ editedCabalFile = "025kaax8mdva3833h9rxbb2qmybiyd33xfnqbhzzzp0zig5yi0p1";

30+ configureFlags = [

31+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

32+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

33+ "-fsplitbase" "-f-test-hlint"

34+ ];

35+ libraryHaskellDepends = [

36+ base biocore blastxml bytestring conduit HTTP http-conduit hxt mtl

37+ network transformers

38+ ];

39+ homepage = "https://github.com/eggzilla/BlastHTTP";

40+ description = "Libary to interface with the NCBI blast REST interface";

41+ license = stdenv.lib.licenses.gpl3;

42+ }) {};

43+ "BlogLiterately" = callPackage

44+ ({ mkDerivation, base, blaze-html, bool-extras, bytestring, cmdargs

45+ , containers, data-default, directory, filepath, HaXml, haxr

46+ , highlighting-kate, hscolour, lens, mtl, pandoc, pandoc-citeproc

47+ , pandoc-types, parsec, process, split, strict, temporary

48+ , transformers, utf8-string

49+ }:

50+ mkDerivation {

51+ pname = "BlogLiterately";

52+ version = "0.7.1.7";

53+ sha256 = "05i0v5mrmnxbmrqrm473z6hs9j4c2jv1l81i4kdmm2wia6p93s90";

54+ revision = "3";

55+ editedCabalFile = "0k074dcfxi9pj2kxwp22byy5vjgl11yamd8djy8s23z6l7dzbvq4";

56+ configureFlags = [

57+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

58+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

59+ "-fsplitbase" "-f-test-hlint"

60+ ];

61+ isLibrary = true;

62+ isExecutable = true;

63+ libraryHaskellDepends = [

64+ base blaze-html bool-extras bytestring cmdargs containers

65+ data-default directory filepath HaXml haxr highlighting-kate

66+ hscolour lens mtl pandoc pandoc-citeproc pandoc-types parsec

67+ process split strict temporary transformers utf8-string

68+ ];

69+ executableHaskellDepends = [ base cmdargs utf8-string ];

70+ homepage = "http://byorgey.wordpress.com/blogliterately/";

71+ description = "A tool for posting Haskelly articles to blogs";

72+ license = "GPL";

73+ }) {};

74+ "BlogLiterately-diagrams" = callPackage

75+ ({ mkDerivation, base, BlogLiterately, containers, diagrams-builder

76+ , diagrams-cairo, diagrams-lib, directory, filepath, pandoc, safe

77+ }:

78+ mkDerivation {

79+ pname = "BlogLiterately-diagrams";

80+ version = "0.1.4.3";

81+ sha256 = "0p65nyslcvf4qzgrwsi59xil8i5sgh1xfyz431lf4f00nsqb0s2h";

82+ revision = "1";

83+ editedCabalFile = "0ga0zxyi5wfaqbsv7a6p5r69xr5lvxqj3hi8yqlivflvc1r6mfd9";

84+ configureFlags = [

85+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

86+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

87+ "-fsplitbase" "-f-test-hlint"

88+ ];

89+ isLibrary = true;

90+ isExecutable = true;

91+ libraryHaskellDepends = [

92+ base BlogLiterately containers diagrams-builder diagrams-cairo

93+ diagrams-lib directory filepath pandoc safe

94+ ];

95+ executableHaskellDepends = [ base BlogLiterately ];

96+ description = "Include images in blog posts with inline diagrams code";

97+ license = stdenv.lib.licenses.bsd3;

98+ }) {};

99+ "Boolean" = callPackage

100+ ({ mkDerivation, base }:

101+ mkDerivation {

102+ pname = "Boolean";

103+ version = "0.2.3";

104+ sha256 = "1lsm06y7hgjp9qmlr6csf24x3wgna7sbf8dgh6sfl2rhs7fn8kgn";

105+ configureFlags = [

106+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

107+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

108+ "-fsplitbase" "-f-test-hlint"

109+ ];

110+ libraryHaskellDepends = [ base ];

111+ description = "Generalized booleans and numbers";

112+ license = stdenv.lib.licenses.bsd3;

113+ }) {};

114+ "BoundedChan" = callPackage

115+ ({ mkDerivation, array, base }:

116+ mkDerivation {

117+ pname = "BoundedChan";

118+ version = "1.0.3.0";

119+ sha256 = "0vf4mlw08n056g5256cf46m5xsijng5gvjx7ccm4r132gznyl72k";

120+ configureFlags = [

121+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

122+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

123+ "-fsplitbase" "-f-test-hlint"

124+ ];

125+ libraryHaskellDepends = [ array base ];

126+ description = "Implementation of bounded channels";

127+ license = stdenv.lib.licenses.bsd3;

128+ }) {};

129+ "Chart" = callPackage

130+ ({ mkDerivation, array, base, colour, data-default-class, lens, mtl

131+ , old-locale, operational, time

132+ }:

133+ mkDerivation {

134+ pname = "Chart";

135+ version = "1.3.2";

136+ sha256 = "0y4xkqdmbyyaxf810dgz0zsfmywlx07c26s9wkk155iriz0yz4m9";

137+ configureFlags = [

138+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

139+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

140+ "-fsplitbase" "-f-test-hlint"

141+ ];

142+ libraryHaskellDepends = [

143+ array base colour data-default-class lens mtl old-locale

144+ operational time

145+ ];

146+ homepage = "https://github.com/timbod7/haskell-chart/wiki";

147+ description = "A library for generating 2D Charts and Plots";

148+ license = stdenv.lib.licenses.bsd3;

149+ }) {};

150+ "Chart-diagrams" = callPackage

151+ ({ mkDerivation, base, blaze-svg, bytestring, Chart, colour

152+ , containers, data-default-class, diagrams-core, diagrams-lib

153+ , diagrams-postscript, diagrams-svg, lens, mtl, old-locale

154+ , operational, SVGFonts, text, time

155+ }:

156+ mkDerivation {

157+ pname = "Chart-diagrams";

158+ version = "1.3.2";

159+ sha256 = "0q5qvzzl5wirlj26a6zpnyq95lpzzkwiqq0mkh25aa3qzzbg4y6g";

160+ configureFlags = [

161+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

162+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

163+ "-fsplitbase" "-f-test-hlint"

164+ ];

165+ enableSeparateDataOutput = true;

166+ libraryHaskellDepends = [

167+ base blaze-svg bytestring Chart colour containers

168+ data-default-class diagrams-core diagrams-lib diagrams-postscript

169+ diagrams-svg lens mtl old-locale operational SVGFonts text time

170+ ];

171+ homepage = "https://github.com/timbod7/haskell-chart/wiki";

172+ description = "Diagrams backend for Charts";

173+ license = stdenv.lib.licenses.bsd3;

174+ }) {};

175+ "ChasingBottoms" = callPackage

176+ ({ mkDerivation, array, base, containers, mtl, QuickCheck, random

177+ , syb

178+ }:

179+ mkDerivation {

180+ pname = "ChasingBottoms";

181+ version = "1.3.0.8";

182+ sha256 = "1f6jg4j17s3y7hcz9gp7cffa77p57xgzv15ng5ypcxpq603721dv";

183+ configureFlags = [

184+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

185+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

186+ "-fsplitbase" "-f-test-hlint"

187+ ];

188+ isLibrary = true;

189+ isExecutable = true;

190+ libraryHaskellDepends = [

191+ base containers mtl QuickCheck random syb

192+ ];

193+ executableHaskellDepends = [

194+ array base containers mtl QuickCheck random syb

195+ ];

196+ description = "For testing partial and infinite values";

197+ license = stdenv.lib.licenses.mit;

198+ }) {};

199+ "DAV" = callPackage

200+ ({ mkDerivation, base, bytestring, case-insensitive, containers

201+ , data-default, either, errors, exceptions, http-client

202+ , http-client-tls, http-types, lens, mtl, network

203+ , optparse-applicative, transformers, transformers-base

204+ , utf8-string, xml-conduit, xml-hamlet

205+ }:

206+ mkDerivation {

207+ pname = "DAV";

208+ version = "1.0.3";

209+ sha256 = "1wrs3rdk4sarzi4w1pma8h751mjw5x1l8c6w30wv7fg0rmk2cayd";

210+ configureFlags = [

211+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

212+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

213+ "-fsplitbase" "-f-test-hlint"

214+ ];

215+ isLibrary = true;

216+ isExecutable = true;

217+ libraryHaskellDepends = [

218+ base bytestring case-insensitive containers data-default either

219+ errors exceptions http-client http-client-tls http-types lens mtl

220+ transformers transformers-base utf8-string xml-conduit xml-hamlet

221+ ];

222+ executableHaskellDepends = [

223+ base bytestring case-insensitive containers data-default either

224+ errors exceptions http-client http-client-tls http-types lens mtl

225+ network optparse-applicative transformers transformers-base

226+ utf8-string xml-conduit xml-hamlet

227+ ];

228+ homepage = "http://floss.scru.org/hDAV";

229+ description = "RFC 4918 WebDAV support";

230+ license = stdenv.lib.licenses.gpl3;

231+ }) {};

232+ "Diff" = callPackage

233+ ({ mkDerivation, array, base, pretty }:

234+ mkDerivation {

235+ pname = "Diff";

236+ version = "0.3.0";

237+ sha256 = "0k7fj4icnh25x21cmrnbqq0sjgxrr2ffhn8bz89qmy5h9dznvy98";

238+ revision = "1";

239+ editedCabalFile = "0irxjhg95jlb048g5sn5j298c2wbcn82fawj0zx2ymq4hvfxc5ph";

240+ configureFlags = [

241+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

242+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

243+ "-fsplitbase" "-f-test-hlint"

244+ ];

245+ libraryHaskellDepends = [ array base pretty ];

246+ description = "O(ND) diff algorithm in haskell";

247+ license = stdenv.lib.licenses.bsd3;

248+ }) {};

249+ "FenwickTree" = callPackage

250+ ({ mkDerivation, base, QuickCheck, template-haskell }:

251+ mkDerivation {

252+ pname = "FenwickTree";

253+ version = "0.1.1";

254+ sha256 = "0rarglwvfa6jmd2cir59syh1plfxgvdin49avi43ygkb9g21icjf";

255+ configureFlags = [

256+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

257+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

258+ "-fsplitbase" "-f-test-hlint"

259+ ];

260+ enableSeparateDataOutput = true;

261+ libraryHaskellDepends = [ base QuickCheck template-haskell ];

262+ testHaskellDepends = [ base QuickCheck template-haskell ];

263+ homepage = "https://github.com/mgajda/FenwickTree";

264+ description = "Data structure for fast query and update of cumulative sums";

265+ license = stdenv.lib.licenses.bsd3;

266+ }) {};

267+ "GLURaw" = callPackage

268+ ({ mkDerivation, base, freeglut, mesa, OpenGLRaw }:

269+ mkDerivation {

270+ pname = "GLURaw";

271+ version = "1.4.0.1";

272+ sha256 = "1k0f1vbbrsfc7jb4qbif4w4q87lsis5gvq7jd2n8zzslxd5n8mcn";

273+ revision = "1";

274+ editedCabalFile = "06c63jxrg4hrd7cxza13v553y2g8flz76my5dq81j1kc87xjacfq";

275+ configureFlags = [

276+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

277+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

278+ "-fsplitbase" "-f-test-hlint"

279+ ];

280+ libraryHaskellDepends = [ base OpenGLRaw ];

281+ librarySystemDepends = [ freeglut mesa ];

282+ homepage = "http://www.haskell.org/haskellwiki/Opengl";

283+ description = "A raw binding for the OpenGL graphics system";

284+ license = stdenv.lib.licenses.bsd3;

285+ }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

286+ "GLUT" = callPackage

287+ ({ mkDerivation, array, base, containers, freeglut, mesa, OpenGL

288+ , OpenGLRaw

289+ }:

290+ mkDerivation {

291+ pname = "GLUT";

292+ version = "2.5.1.1";

293+ sha256 = "0n9dkdjmpnbcjg0ll0ny7mw21xwwix0gxy0hq6yagmgaakhpg0aa";

294+ revision = "1";

295+ editedCabalFile = "00mv87skns5gh81hb028nfiqz5xdl9ap0mv6nbw6w42naam6wflm";

296+ configureFlags = [

297+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

298+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

299+ "-fsplitbase" "-f-test-hlint"

300+ ];

301+ libraryHaskellDepends = [ array base containers OpenGL OpenGLRaw ];

302+ librarySystemDepends = [ freeglut mesa ];

303+ doHaddock = false;

304+ doCheck = false;

305+ homepage = "http://www.haskell.org/haskellwiki/Opengl";

306+ description = "A binding for the OpenGL Utility Toolkit";

307+ license = stdenv.lib.licenses.bsd3;

308+ }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

309+ "Glob" = callPackage

310+ ({ mkDerivation, base, containers, directory, dlist, filepath

311+ , transformers

312+ }:

313+ mkDerivation {

314+ pname = "Glob";

315+ version = "0.7.5";

316+ sha256 = "0hdyi49zp2yr4h4wgngl8ajrss1p309c3pn0alj543yrh33bnqq0";

317+ revision = "1";

318+ editedCabalFile = "16whzn47hxs8miihs3iplc2dh33z07v44ln7kav2m75g3aprr6r1";

319+ configureFlags = [

320+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

321+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

322+ "-fsplitbase" "-f-test-hlint"

323+ ];

324+ libraryHaskellDepends = [

325+ base containers directory dlist filepath transformers

326+ ];

327+ homepage = "http://iki.fi/matti.niemenmaa/glob/";

328+ description = "Globbing library";

329+ license = stdenv.lib.licenses.bsd3;

330+ }) {};

331+ "HCodecs" = callPackage

332+ ({ mkDerivation, array, base, bytestring, QuickCheck, random }:

333+ mkDerivation {

334+ pname = "HCodecs";

335+ version = "0.5";

336+ sha256 = "0mhp1alx0p9lzq3vm0k802f8ndm2386sshprn9zb8xq8bsd11gxi";

337+ configureFlags = [

338+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

339+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

340+ "-fsplitbase" "-f-test-hlint"

341+ ];

342+ libraryHaskellDepends = [

343+ array base bytestring QuickCheck random

344+ ];

345+ testHaskellDepends = [ array base bytestring QuickCheck random ];

346+ homepage = "http://www-db.informatik.uni-tuebingen.de/team/giorgidze";

347+ description = "A library to read, write and manipulate MIDI, WAVE, and SoundFont2 files";

348+ license = stdenv.lib.licenses.bsd3;

349+ }) {};

350+ "HStringTemplate" = callPackage

351+ ({ mkDerivation, array, base, blaze-builder, bytestring, containers

352+ , deepseq, directory, filepath, mtl, old-locale, old-time, parsec

353+ , pretty, syb, template-haskell, text, time, utf8-string, void

354+ }:

355+ mkDerivation {

356+ pname = "HStringTemplate";

357+ version = "0.7.3";

358+ sha256 = "1gw4v16nk0878qplcx6by2bl4280lwyn9a252p6ldaqlbk9vygw8";

359+ revision = "2";

360+ editedCabalFile = "1jsl7wgagccbznasz8swllb2wpa2hd6d7k46s7b0g5f2wnj2xd7k";

361+ configureFlags = [

362+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

363+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

364+ "-fsplitbase" "-f-test-hlint"

365+ ];

366+ libraryHaskellDepends = [

367+ array base blaze-builder bytestring containers deepseq directory

368+ filepath mtl old-locale old-time parsec pretty syb template-haskell

369+ text time utf8-string void

370+ ];

371+ description = "StringTemplate implementation in Haskell";

372+ license = stdenv.lib.licenses.bsd3;

373+ }) {};

374+ "HTF" = callPackage

375+ ({ mkDerivation, aeson, aeson-pretty, array, base

376+ , base64-bytestring, bytestring, containers, cpphs, Diff, directory

377+ , filepath, haskell-lexer, haskell-src, HUnit, lifted-base

378+ , monad-control, mtl, old-time, pretty, process, QuickCheck, random

379+ , regex-compat, temporary, text, time, unix, unordered-containers

380+ , vector, xmlgen

381+ }:

382+ mkDerivation {

383+ pname = "HTF";

384+ version = "0.12.2.3";

385+ sha256 = "0g5z2ypn6i7wpz1439c6qjmi8lw2b86zaljkgwchjn8r8gvw4mbm";

386+ configureFlags = [

387+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

388+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

389+ "-fsplitbase" "-f-test-hlint"

390+ ];

391+ isLibrary = true;

392+ isExecutable = true;

393+ libraryHaskellDepends = [

394+ aeson array base base64-bytestring bytestring containers cpphs Diff

395+ directory haskell-lexer haskell-src HUnit lifted-base monad-control

396+ mtl old-time pretty process QuickCheck random regex-compat text

397+ time unix vector xmlgen

398+ ];

399+ executableHaskellDepends = [

400+ array base cpphs directory haskell-lexer HUnit mtl old-time random

401+ text

402+ ];

403+ testHaskellDepends = [

404+ aeson aeson-pretty base bytestring directory filepath HUnit mtl

405+ process random regex-compat temporary text unordered-containers

406+ ];

407+ doHaddock = false;

408+ doCheck = false;

409+ homepage = "https://github.com/skogsbaer/HTF/";

410+ description = "The Haskell Test Framework";

411+ license = "LGPL";

412+ }) {};

413+ "HTTP" = callPackage

414+ ({ mkDerivation, array, base, bytestring, mtl, network, old-time

415+ , parsec

416+ }:

417+ mkDerivation {

418+ pname = "HTTP";

419+ version = "4000.2.18";

420+ sha256 = "1jn0ikbdwhd32qjwpnsmpnmy0dxhmwfhf8851ifxik91fn7j5j4k";

421+ configureFlags = [

422+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

423+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

424+ "-fsplitbase" "-f-test-hlint"

425+ ];

426+ libraryHaskellDepends = [

427+ array base bytestring mtl network old-time parsec

428+ ];

429+ doHaddock = false;

430+ doCheck = false;

431+ homepage = "https://github.com/haskell/HTTP";

432+ description = "A library for client-side HTTP";

433+ license = stdenv.lib.licenses.bsd3;

434+ }) {};

435+ "HUnit" = callPackage

436+ ({ mkDerivation, base, deepseq }:

437+ mkDerivation {

438+ pname = "HUnit";

439+ version = "1.2.5.2";

440+ sha256 = "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a";

441+ configureFlags = [

442+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

443+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

444+ "-fsplitbase" "-f-test-hlint"

445+ ];

446+ enableSeparateDataOutput = true;

447+ libraryHaskellDepends = [ base deepseq ];

448+ homepage = "http://hunit.sourceforge.net/";

449+ description = "A unit testing framework for Haskell";

450+ license = stdenv.lib.licenses.bsd3;

451+ }) {};

452+ "HaTeX" = callPackage

453+ ({ mkDerivation, base, bytestring, containers, matrix, parsec

454+ , QuickCheck, tasty, tasty-quickcheck, text, transformers

455+ , wl-pprint-extras

456+ }:

457+ mkDerivation {

458+ pname = "HaTeX";

459+ version = "3.15.0.0";

460+ sha256 = "1rhxml458d8y0vxns2rp76yvfk66496mvab81i71km653n6g5kky";

461+ configureFlags = [

462+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

463+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

464+ "-fsplitbase" "-f-test-hlint"

465+ ];

466+ libraryHaskellDepends = [

467+ base bytestring containers matrix parsec QuickCheck text

468+ transformers wl-pprint-extras

469+ ];

470+ testHaskellDepends = [

471+ base QuickCheck tasty tasty-quickcheck text

472+ ];

473+ homepage = "http://wrongurl.net/haskell/HaTeX";

474+ description = "The Haskell LaTeX library";

475+ license = stdenv.lib.licenses.bsd3;

476+ }) {};

477+ "HaXml" = callPackage

478+ ({ mkDerivation, base, bytestring, containers, directory, filepath

479+ , polyparse, pretty, random

480+ }:

481+ mkDerivation {

482+ pname = "HaXml";

483+ version = "1.24.1";

484+ sha256 = "1pvqgczksxasayvdb6d4g7ya7g7w1v9hsa35kaxm9bcic9y8q9az";

485+ configureFlags = [

486+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

487+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

488+ "-fsplitbase" "-f-test-hlint"

489+ ];

490+ isLibrary = true;

491+ isExecutable = true;

492+ libraryHaskellDepends = [

493+ base bytestring containers filepath polyparse pretty random

494+ ];

495+ executableHaskellDepends = [ directory ];

496+ homepage = "http://www.cs.york.ac.uk/fp/HaXml/";

497+ description = "Utilities for manipulating XML documents";

498+ license = "LGPL";

499+ }) {};

500+ "HandsomeSoup" = callPackage

501+ ({ mkDerivation, base, containers, hspec, HTTP, hxt, hxt-http

502+ , MaybeT, mtl, network, network-uri, parsec, transformers

503+ }:

504+ mkDerivation {

505+ pname = "HandsomeSoup";

506+ version = "0.3.5";

507+ sha256 = "1d1zanlr1mdxjc69xvbxg5kn5bc08gd960j6lb1x3grhcgmj9krm";

508+ configureFlags = [

509+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

510+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

511+ "-fsplitbase" "-f-test-hlint"

512+ ];

513+ isLibrary = true;

514+ isExecutable = true;

515+ enableSeparateDataOutput = true;

516+ libraryHaskellDepends = [

517+ base containers HTTP hxt hxt-http MaybeT mtl network network-uri

518+ parsec transformers

519+ ];

520+ executableHaskellDepends = [ base hxt ];

521+ testHaskellDepends = [ base hspec hxt ];

522+ homepage = "https://github.com/egonSchiele/HandsomeSoup";

523+ description = "Work with HTML more easily in HXT";

524+ license = stdenv.lib.licenses.bsd3;

525+ }) {};

526+ "JuicyPixels" = callPackage

527+ ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl

528+ , primitive, transformers, vector, zlib

529+ }:

530+ mkDerivation {

531+ pname = "JuicyPixels";

532+ version = "3.1.7.1";

533+ sha256 = "0mhsknqdrhxnm622mgrswvj4kvksh87x18s5ddgk4ylf0s2fjlap";

534+ revision = "1";

535+ editedCabalFile = "1z0j1skpclsq6g1kv3nzgkfndqwp76r8zkn992f8nk3f4bwd36ww";

536+ configureFlags = [

537+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

538+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

539+ "-fsplitbase" "-f-test-hlint"

540+ ];

541+ libraryHaskellDepends = [

542+ base binary bytestring containers deepseq mtl primitive

543+ transformers vector zlib

544+ ];

545+ homepage = "https://github.com/Twinside/Juicy.Pixels";

546+ description = "Picture loading/serialization (in png, jpeg, bitmap, gif, tiff and radiance)";

547+ license = stdenv.lib.licenses.bsd3;

548+ }) {};

549+ "JuicyPixels-repa" = callPackage

550+ ({ mkDerivation, base, bytestring, JuicyPixels, repa, vector }:

551+ mkDerivation {

552+ pname = "JuicyPixels-repa";

553+ version = "0.7";

554+ sha256 = "0fn9i3w8s2ifyg0zsdryyw1nm0c5ybaq0c6jxcggs79x0ngi0mm5";

555+ revision = "1";

556+ editedCabalFile = "1a4879p2wnb4parg8zax1cwcxrpcpfp349qxf9bn0l0bwvdddp5h";

557+ configureFlags = [

558+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

559+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

560+ "-fsplitbase" "-f-test-hlint"

561+ ];

562+ libraryHaskellDepends = [

563+ base bytestring JuicyPixels repa vector

564+ ];

565+ description = "Convenience functions to obtain array representations of images";

566+ license = stdenv.lib.licenses.bsd3;

567+ }) {};

568+ "MaybeT" = callPackage

569+ ({ mkDerivation, base, mtl }:

570+ mkDerivation {

571+ pname = "MaybeT";

572+ version = "0.1.2";

573+ sha256 = "0cmnfs22ldai0z172rdsvryzsh33a70yax21v03nhr92a4b62plr";

574+ revision = "1";

575+ editedCabalFile = "1045p10l7smabidysk52m16sgqgfpa70ny8nwyn56238i02cd7ir";

576+ configureFlags = [

577+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

578+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

579+ "-fsplitbase" "-f-test-hlint"

580+ ];

581+ libraryHaskellDepends = [ base mtl ];

582+ description = "MaybeT monad transformer";

583+ license = stdenv.lib.licenses.bsd3;

584+ }) {};

585+ "MemoTrie" = callPackage

586+ ({ mkDerivation, base, void }:

587+ mkDerivation {

588+ pname = "MemoTrie";

589+ version = "0.6.2";

590+ sha256 = "1g4b82s30bqkfids3iywf873nyn8h7l8rp8l3xl58smj5lbi3p4x";

591+ revision = "1";

592+ editedCabalFile = "0n0k85vvn423nkbjq3q23lzxbam9pvqj9fgby1n8bnp386v4gb2a";

593+ configureFlags = [

594+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

595+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

596+ "-fsplitbase" "-f-test-hlint"

597+ ];

598+ libraryHaskellDepends = [ base void ];

599+ homepage = "http://haskell.org/haskellwiki/MemoTrie";

600+ description = "Trie-based memo functions";

601+ license = stdenv.lib.licenses.bsd3;

602+ }) {};

603+ "MissingH" = callPackage

604+ ({ mkDerivation, array, base, containers, directory

605+ , errorcall-eq-instance, filepath, hslogger, HUnit, mtl, network

606+ , old-locale, old-time, parsec, process, QuickCheck, random

607+ , regex-compat, testpack, time, unix

608+ }:

609+ mkDerivation {

610+ pname = "MissingH";

611+ version = "1.3.0.1";

612+ sha256 = "1cwdhgqqv2riqwhsgyrpmqyzvg19lx6zp1g7xdp4rikh7rkn03ds";

613+ revision = "1";

614+ editedCabalFile = "181ql081aw6j27c2192hb56clsp60gfa0gn4km58qvps3v7gjysx";

615+ configureFlags = [

616+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

617+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

618+ "-fsplitbase" "-f-test-hlint"

619+ ];

620+ libraryHaskellDepends = [

621+ array base containers directory filepath hslogger HUnit mtl network

622+ old-locale old-time parsec process random regex-compat time unix

623+ ];

624+ testHaskellDepends = [

625+ array base containers directory errorcall-eq-instance filepath

626+ hslogger HUnit mtl network old-locale old-time parsec process

627+ QuickCheck random regex-compat testpack time unix

628+ ];

629+ homepage = "http://software.complete.org/missingh";

630+ description = "Large utility library";

631+ license = stdenv.lib.licenses.bsd3;

632+ }) {};

633+ "MonadCatchIO-transformers" = callPackage

634+ ({ mkDerivation, base, extensible-exceptions, monads-tf

635+ , transformers

636+ }:

637+ mkDerivation {

638+ pname = "MonadCatchIO-transformers";

639+ version = "0.3.1.2";

640+ sha256 = "1r5c4qz6yp1qrsmk9di35d5kk2dcnaxh2mg3n5kdim991ydzsi1d";

641+ revision = "1";

642+ editedCabalFile = "0783d24gx2fnlapxlipgf2vg5kwlsfmcqvy3llw14vy1yz6xz9i0";

643+ configureFlags = [

644+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

645+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

646+ "-fsplitbase" "-f-test-hlint"

647+ ];

648+ libraryHaskellDepends = [

649+ base extensible-exceptions monads-tf transformers

650+ ];

651+ description = "Monad-transformer compatible version of the Control.Exception module";

652+ license = stdenv.lib.licenses.bsd3;

653+ }) {};

654+ "MonadPrompt" = callPackage

655+ ({ mkDerivation, base, mtl }:

656+ mkDerivation {

657+ pname = "MonadPrompt";

658+ version = "1.0.0.5";

659+ sha256 = "1nmy7dfzrkd8yfv5i9vlmjq9khnyi76ayvkzgcf783v5hfzcn4mh";

660+ configureFlags = [

661+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

662+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

663+ "-fsplitbase" "-f-test-hlint"

664+ ];

665+ libraryHaskellDepends = [ base mtl ];

666+ description = "MonadPrompt, implementation & examples";

667+ license = stdenv.lib.licenses.bsd3;

668+ }) {};

669+ "MonadRandom" = callPackage

670+ ({ mkDerivation, base, mtl, random, transformers }:

671+ mkDerivation {

672+ pname = "MonadRandom";

673+ version = "0.3.0.1";

674+ sha256 = "0bbj6rkxskrvl14lngpggql4q41pw21cj4z8h592mizrxjfa3rj0";

675+ revision = "2";

676+ editedCabalFile = "1cbxcf2igzv8qd7lssczdph1vr3y73mz30mh7g9scjql7g621zji";

677+ configureFlags = [

678+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

679+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

680+ "-fsplitbase" "-f-test-hlint"

681+ ];

682+ libraryHaskellDepends = [ base mtl random transformers ];

683+ description = "Random-number generation monad";

684+ license = "unknown";

685+ }) {};

686+ "MusicBrainz" = callPackage

687+ ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra

688+ , HTTP, http-conduit, http-types, monad-control, old-locale

689+ , resourcet, text, time, transformers, vector, xml-conduit

690+ , xml-types

691+ }:

692+ mkDerivation {

693+ pname = "MusicBrainz";

694+ version = "0.2.2";

695+ sha256 = "1byliyx6ykhd62n0zsvhaa94s77qj8lya5m7cq031zh5zkx6j7l3";

696+ revision = "1";

697+ editedCabalFile = "1kiaqf0zq7y2b6j66zwlwcsq080wzk6sragby9g890ivdi35npsa";

698+ configureFlags = [

699+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

700+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

701+ "-fsplitbase" "-f-test-hlint"

702+ ];

703+ libraryHaskellDepends = [

704+ aeson base bytestring conduit conduit-extra HTTP http-conduit

705+ http-types monad-control old-locale resourcet text time

706+ transformers vector xml-conduit xml-types

707+ ];

708+ homepage = "http://floss.scru.org/hMusicBrainz";

709+ description = "interface to MusicBrainz XML2 web service";

710+ license = stdenv.lib.licenses.gpl3;

711+ }) {};

712+ "NumInstances" = callPackage

713+ ({ mkDerivation, base }:

714+ mkDerivation {

715+ pname = "NumInstances";

716+ version = "1.4";

717+ sha256 = "0ycnwn09izajv330l7a31mc0alifqmxjsn9qmfswwnbg6i4jmnyb";

718+ configureFlags = [

719+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

720+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

721+ "-fsplitbase" "-f-test-hlint"

722+ ];

723+ libraryHaskellDepends = [ base ];

724+ homepage = "https://github.com/conal/NumInstances";

725+ description = "Instances of numeric classes for functions and tuples";

726+ license = stdenv.lib.licenses.bsd3;

727+ }) {};

728+ "Octree" = callPackage

729+ ({ mkDerivation, AC-Vector, base, QuickCheck }:

730+ mkDerivation {

731+ pname = "Octree";

732+ version = "0.5.3";

733+ sha256 = "0wfzvy5r0m0v5f366q7rn9sdxl0r0xpqy6d2ig7si75wm2qaimx6";

734+ configureFlags = [

735+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

736+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

737+ "-fsplitbase" "-f-test-hlint"

738+ ];

739+ libraryHaskellDepends = [ AC-Vector base QuickCheck ];

740+ doHaddock = false;

741+ doCheck = false;

742+ homepage = "https://github.com/mgajda/octree";

743+ description = "Simple unbalanced Octree for storing data about 3D points";

744+ license = stdenv.lib.licenses.bsd3;

745+ }) {};

746+ "OneTuple" = callPackage

747+ ({ mkDerivation, base }:

748+ mkDerivation {

749+ pname = "OneTuple";

750+ version = "0.2.1";

751+ sha256 = "1x52b68zh3k9lnps5s87kzan7dzvqp6mrwgayjq15w9dv6v78vsb";

752+ configureFlags = [

753+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

754+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

755+ "-fsplitbase" "-f-test-hlint"

756+ ];

757+ libraryHaskellDepends = [ base ];

758+ description = "Singleton Tuple";

759+ license = stdenv.lib.licenses.bsd3;

760+ }) {};

761+ "OpenGL" = callPackage

762+ ({ mkDerivation, base, bytestring, GLURaw, OpenGLRaw, text }:

763+ mkDerivation {

764+ pname = "OpenGL";

765+ version = "2.9.2.0";

766+ sha256 = "1sa5jmhj0az6sik6swv2vgzhv9gj34dbq2px23ag1a4yrk5gcn0p";

767+ revision = "3";

768+ editedCabalFile = "18bbn7rk82flszhq5kgfn2bhh5cfvxjhwn6q50jfaiprsd0gk85g";

769+ configureFlags = [

770+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

771+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

772+ "-fsplitbase" "-f-test-hlint"

773+ ];

774+ libraryHaskellDepends = [ base bytestring GLURaw OpenGLRaw text ];

775+ homepage = "http://www.haskell.org/haskellwiki/Opengl";

776+ description = "A binding for the OpenGL graphics system";

777+ license = stdenv.lib.licenses.bsd3;

778+ }) {};

779+ "OpenGLRaw" = callPackage

780+ ({ mkDerivation, base, ghc-prim, mesa }:

781+ mkDerivation {

782+ pname = "OpenGLRaw";

783+ version = "1.5.0.0";

784+ sha256 = "04lsidv82fl7yb2fnqpx7q0vgiwxbswh8g7dv9q9s9i2jwiaaal5";

785+ configureFlags = [

786+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

787+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

788+ "-fsplitbase" "-f-test-hlint"

789+ ];

790+ libraryHaskellDepends = [ base ghc-prim ];

791+ librarySystemDepends = [ mesa ];

792+ homepage = "http://www.haskell.org/haskellwiki/Opengl";

793+ description = "A raw binding for the OpenGL graphics system";

794+ license = stdenv.lib.licenses.bsd3;

795+ }) {inherit (pkgs) mesa;};

796+ "QuasiText" = callPackage

797+ ({ mkDerivation, attoparsec, base, haskell-src-meta

798+ , template-haskell, text

799+ }:

800+ mkDerivation {

801+ pname = "QuasiText";

802+ version = "0.1.2.5";

803+ sha256 = "10y2lirprxyh9m47qxq0plihc22xvmkhq6lfbx3i19vfvkbhnbwx";

804+ configureFlags = [

805+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

806+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

807+ "-fsplitbase" "-f-test-hlint"

808+ ];

809+ libraryHaskellDepends = [

810+ attoparsec base haskell-src-meta template-haskell text

811+ ];

812+ homepage = "https://github.com/mikeplus64/QuasiText";

813+ description = "A QuasiQuoter for Text";

814+ license = stdenv.lib.licenses.bsd3;

815+ }) {};

816+ "QuickCheck" = callPackage

817+ ({ mkDerivation, base, random, template-haskell, test-framework

818+ , tf-random, transformers

819+ }:

820+ mkDerivation {

821+ pname = "QuickCheck";

822+ version = "2.7.6";

823+ sha256 = "09y5l0062l9i5jp9v6811kvkk4zpy0mizwaw44abgz0x1h59gn40";

824+ revision = "1";

825+ editedCabalFile = "0d9hr7kwpg9akdhzypds22l3wslxnkb2ipns3821c1nailrldzs5";

826+ configureFlags = [

827+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

828+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

829+ "-fsplitbase" "-f-test-hlint"

830+ ];

831+ libraryHaskellDepends = [

832+ base random template-haskell tf-random transformers

833+ ];

834+ testHaskellDepends = [ base template-haskell test-framework ];

835+ homepage = "https://github.com/nick8325/quickcheck";

836+ description = "Automatic testing of Haskell programs";

837+ license = stdenv.lib.licenses.bsd3;

838+ }) {};

839+ "ReadArgs" = callPackage

840+ ({ mkDerivation, base, system-filepath, text }:

841+ mkDerivation {

842+ pname = "ReadArgs";

843+ version = "1.2.2";

844+ sha256 = "1v6yr5zzrrj31prfzxxh1n27sfnkqpkw34v3a47rcnm444ba58a7";

845+ configureFlags = [

846+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

847+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

848+ "-fsplitbase" "-f-test-hlint"

849+ ];

850+ isLibrary = true;

851+ isExecutable = true;

852+ libraryHaskellDepends = [ base system-filepath text ];

853+ executableHaskellDepends = [ base system-filepath text ];

854+ doCheck = false;

855+ homepage = "http://github.com/rampion/ReadArgs";

856+ description = "Simple command line argument parsing";

857+ license = stdenv.lib.licenses.bsd3;

858+ }) {};

859+ "SHA" = callPackage

860+ ({ mkDerivation, array, base, binary, bytestring }:

861+ mkDerivation {

862+ pname = "SHA";

863+ version = "1.6.4.1";

864+ sha256 = "03fwpl8hrl9q197w8v1glqi5g1d51c7hz4m8zi5s8x1yvpbwcfvl";

865+ configureFlags = [

866+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

867+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

868+ "-fsplitbase" "-f-test-hlint"

869+ ];

870+ isLibrary = true;

871+ isExecutable = true;

872+ libraryHaskellDepends = [ array base binary bytestring ];

873+ description = "Implementations of the SHA suite of message digest functions";

874+ license = stdenv.lib.licenses.bsd3;

875+ }) {};

876+ "SVGFonts" = callPackage

877+ ({ mkDerivation, attoparsec, base, blaze-markup, blaze-svg

878+ , containers, data-default-class, diagrams-lib, directory, parsec

879+ , split, text, tuple, vector, vector-space, xml

880+ }:

881+ mkDerivation {

882+ pname = "SVGFonts";

883+ version = "1.4.0.3";

884+ sha256 = "0jkjcf27xqjzv9lny7j181kcma26wngrq3vzw2sp2hwkdcjryyin";

885+ configureFlags = [

886+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

887+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

888+ "-fsplitbase" "-f-test-hlint"

889+ ];

890+ enableSeparateDataOutput = true;

891+ libraryHaskellDepends = [

892+ attoparsec base blaze-markup blaze-svg containers

893+ data-default-class diagrams-lib directory parsec split text tuple

894+ vector vector-space xml

895+ ];

896+ description = "Fonts from the SVG-Font format";

897+ license = stdenv.lib.licenses.bsd3;

898+ }) {};

899+ "SafeSemaphore" = callPackage

900+ ({ mkDerivation, base, containers, HUnit, stm }:

901+ mkDerivation {

902+ pname = "SafeSemaphore";

903+ version = "0.10.1";

904+ sha256 = "0rpg9j6fy70i0b9dkrip9d6wim0nac0snp7qzbhykjkqlcvvgr91";

905+ revision = "1";

906+ editedCabalFile = "1k61gqgfh6n3sj8ni8sfvpcm39nqc2msjfxk2pgmhfabvv48w5hv";

907+ configureFlags = [

908+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

909+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

910+ "-fsplitbase" "-f-test-hlint"

911+ ];

912+ libraryHaskellDepends = [ base containers stm ];

913+ testHaskellDepends = [ base HUnit ];

914+ homepage = "https://github.com/ChrisKuklewicz/SafeSemaphore";

915+ description = "Much safer replacement for QSemN, QSem, and SampleVar";

916+ license = stdenv.lib.licenses.bsd3;

917+ }) {};

918+ "Spock" = callPackage

919+ ({ mkDerivation, aeson, base, base64-bytestring, blaze-html

920+ , bytestring, case-insensitive, containers, digestive-functors

921+ , directory, hashable, hspec, hspec-wai, http-types, monad-control

922+ , mtl, old-locale, path-pieces, random, reroute, resource-pool

923+ , resourcet, stm, text, time, transformers, transformers-base

924+ , unordered-containers, vault, wai, wai-extra, warp

925+ }:

926+ mkDerivation {

927+ pname = "Spock";

928+ version = "0.7.5.1";

929+ sha256 = "05vw1dnpzf1khczspv8b5g3z3dqw26klv4c5201jz8sjq6nap2ki";

930+ configureFlags = [

931+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

932+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

933+ "-fsplitbase" "-f-test-hlint"

934+ ];

935+ libraryHaskellDepends = [

936+ aeson base base64-bytestring blaze-html bytestring case-insensitive

937+ containers digestive-functors directory hashable http-types

938+ monad-control mtl old-locale path-pieces random reroute

939+ resource-pool resourcet stm text time transformers

940+ transformers-base unordered-containers vault wai wai-extra warp

941+ ];

942+ testHaskellDepends = [ base hspec hspec-wai http-types text wai ];

943+ homepage = "https://github.com/agrafix/Spock";

944+ description = "Another Haskell web framework for rapid development";

945+ license = stdenv.lib.licenses.bsd3;

946+ }) {};

947+ "X11" = callPackage

948+ ({ mkDerivation, base, data-default, libX11, libXext, libXinerama

949+ , libXrandr, libXrender

950+ }:

951+ mkDerivation {

952+ pname = "X11";

953+ version = "1.6.1.2";

954+ sha256 = "1kzjcynm3rr83ihqx2y2d852jc49da4p18gv6jzm7g87z22x85jj";

955+ configureFlags = [

956+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

957+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

958+ "-fsplitbase" "-f-test-hlint"

959+ ];

960+ libraryHaskellDepends = [ base data-default ];

961+ librarySystemDepends = [

962+ libX11 libXext libXinerama libXrandr libXrender

963+ ];

964+ homepage = "https://github.com/haskell-pkg-janitors/X11";

965+ description = "A binding to the X11 graphics library";

966+ license = stdenv.lib.licenses.bsd3;

967+ }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXext;

968+ inherit (pkgs.xorg) libXinerama; inherit (pkgs.xorg) libXrandr;

969+ inherit (pkgs.xorg) libXrender;};

970+ "Yampa" = callPackage

971+ ({ mkDerivation, base, random }:

972+ mkDerivation {

973+ pname = "Yampa";

974+ version = "0.9.6";

975+ sha256 = "0a1m0sb0i3kkxbp10vpqd6iw83ksm4alavrg04arzrv71p3skyg0";

976+ revision = "1";

977+ editedCabalFile = "13jvcb1ak0yzq5036x8pymrphl1v7i2sa23kjn2v5gcxig2kvxxc";

978+ configureFlags = [

979+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

980+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

981+ "-fsplitbase" "-f-test-hlint"

982+ ];

983+ libraryHaskellDepends = [ base random ];

984+ homepage = "http://www.haskell.org/haskellwiki/Yampa";

985+ description = "Library for programming hybrid systems";

986+ license = stdenv.lib.licenses.bsd3;

987+ }) {};

988+ "YampaSynth" = callPackage

989+ ({ mkDerivation, array, base, bytestring, containers, HCodecs

990+ , Yampa

991+ }:

992+ mkDerivation {

993+ pname = "YampaSynth";

994+ version = "0.2";

995+ sha256 = "028a7lrfyikvky52s19kffssnry1grnip3sm7z55bs5fazma1im1";

996+ configureFlags = [

997+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

998+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

999+ "-fsplitbase" "-f-test-hlint"

1000+ ];

1001+ isLibrary = false;

1002+ isExecutable = true;

1003+ enableSeparateDataOutput = true;

1004+ executableHaskellDepends = [

1005+ array base bytestring containers HCodecs Yampa

1006+ ];

1007+ doHaddock = false;

1008+ homepage = "http://www-db.informatik.uni-tuebingen.de/team/giorgidze";

1009+ description = "Software synthesizer";

1010+ license = stdenv.lib.licenses.bsd3;

1011+ }) {};

1012+ "abstract-deque" = callPackage

1013+ ({ mkDerivation, array, base, containers, random, time }:

1014+ mkDerivation {

1015+ pname = "abstract-deque";

1016+ version = "0.3";

1017+ sha256 = "18jwswjxwzc9bjiy4ds6hw2a74ki797jmfcifxd2ga4kh7ri1ah9";

1018+ configureFlags = [

1019+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1020+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1021+ "-fsplitbase" "-f-test-hlint"

1022+ ];

1023+ libraryHaskellDepends = [ array base containers random time ];

1024+ homepage = "https://github.com/rrnewton/haskell-lockfree/wiki";

1025+ description = "Abstract, parameterized interface to mutable Deques";

1026+ license = stdenv.lib.licenses.bsd3;

1027+ }) {};

1028+ "abstract-par" = callPackage

1029+ ({ mkDerivation, base, deepseq }:

1030+ mkDerivation {

1031+ pname = "abstract-par";

1032+ version = "0.3.3";

1033+ sha256 = "0q6qsniw4wks2pw6wzncb1p1j3k6al5njnvm2v5n494hplwqg2i4";

1034+ configureFlags = [

1035+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1036+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1037+ "-fsplitbase" "-f-test-hlint"

1038+ ];

1039+ libraryHaskellDepends = [ base deepseq ];

1040+ homepage = "https://github.com/simonmar/monad-par";

1041+ description = "Type classes generalizing the functionality of the 'monad-par' library";

1042+ license = stdenv.lib.licenses.bsd3;

1043+ }) {};

1044+ "accelerate" = callPackage

1045+ ({ mkDerivation, array, base, containers, fclabels, ghc-prim

1046+ , hashable, hashtables, pretty, template-haskell

1047+ , unordered-containers

1048+ }:

1049+ mkDerivation {

1050+ pname = "accelerate";

1051+ version = "0.15.0.0";

1052+ sha256 = "1hi3zm1swm9fank9w98009pwcgccw6w2j2ilb970sbxyb0xf8nps";

1053+ revision = "2";

1054+ editedCabalFile = "0k6damdq8kjxlscrc7rbbag0a05q9vjiyx86rda5lnfvgxya9klq";

1055+ configureFlags = [

1056+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1057+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1058+ "-fsplitbase" "-f-test-hlint"

1059+ ];

1060+ libraryHaskellDepends = [

1061+ array base containers fclabels ghc-prim hashable hashtables pretty

1062+ template-haskell unordered-containers

1063+ ];

1064+ homepage = "https://github.com/AccelerateHS/accelerate/";

1065+ description = "An embedded language for accelerated array processing";

1066+ license = stdenv.lib.licenses.bsd3;

1067+ }) {};

1068+ "ace" = callPackage

1069+ ({ mkDerivation, attoparsec, base, bifunctors, blaze-html

1070+ , blaze-markup, data-default, hspec, HUnit, mtl, parsec, text

1071+ }:

1072+ mkDerivation {

1073+ pname = "ace";

1074+ version = "0.6";

1075+ sha256 = "0f07j2rj9ylvdrijwwlpx66mj503mhjfq1x2mylpxkr6kmjjniyk";

1076+ configureFlags = [

1077+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1078+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1079+ "-fsplitbase" "-f-test-hlint"

1080+ ];

1081+ libraryHaskellDepends = [

1082+ attoparsec base blaze-html blaze-markup data-default parsec text

1083+ ];

1084+ testHaskellDepends = [

1085+ base bifunctors hspec HUnit mtl parsec text

1086+ ];

1087+ description = "Attempto Controlled English parser and printer";

1088+ license = stdenv.lib.licenses.bsd3;

1089+ }) {};

1090+ "action-permutations" = callPackage

1091+ ({ mkDerivation, base }:

1092+ mkDerivation {

1093+ pname = "action-permutations";

1094+ version = "0.0.0.1";

1095+ sha256 = "0rhlzpwshixpnqma7sk28f22dkwz39b6lcwnzmd31rcnz5cyw6d4";

1096+ configureFlags = [

1097+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1098+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1099+ "-fsplitbase" "-f-test-hlint"

1100+ ];

1101+ libraryHaskellDepends = [ base ];

1102+ description = "Execute a set of actions (e.g. parsers) in each possible order";

1103+ license = stdenv.lib.licenses.bsd3;

1104+ }) {};

1105+ "active" = callPackage

1106+ ({ mkDerivation, array, base, newtype, QuickCheck, semigroupoids

1107+ , semigroups, vector-space

1108+ }:

1109+ mkDerivation {

1110+ pname = "active";

1111+ version = "0.1.0.17";

1112+ sha256 = "1asp0han2737vfk92gasij804z4jsw8v2bc0m4nrmn3v80vmh7qb";

1113+ configureFlags = [

1114+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1115+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1116+ "-fsplitbase" "-f-test-hlint"

1117+ ];

1118+ libraryHaskellDepends = [

1119+ array base newtype semigroupoids semigroups vector-space

1120+ ];

1121+ testHaskellDepends = [

1122+ array base newtype QuickCheck semigroupoids semigroups vector-space

1123+ ];

1124+ description = "Abstractions for animation";

1125+ license = stdenv.lib.licenses.bsd3;

1126+ }) {};

1127+ "ad" = callPackage

1128+ ({ mkDerivation, array, base, comonad, containers, criterion

1129+ , data-reify, directory, doctest, erf, filepath, free, nats

1130+ , reflection, transformers

1131+ }:

1132+ mkDerivation {

1133+ pname = "ad";

1134+ version = "4.2.1.1";

1135+ sha256 = "1zdpfh4k93ygrm91m7lw1la6n4yvaq3k2sqswgia04naf2wcmjka";

1136+ configureFlags = [

1137+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1138+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1139+ "-fsplitbase" "-f-test-hlint"

1140+ ];

1141+ libraryHaskellDepends = [

1142+ array base comonad containers data-reify erf free nats reflection

1143+ transformers

1144+ ];

1145+ testHaskellDepends = [ base directory doctest filepath ];

1146+ benchmarkHaskellDepends = [ base criterion erf ];

1147+ homepage = "http://github.com/ekmett/ad";

1148+ description = "Automatic Differentiation";

1149+ license = stdenv.lib.licenses.bsd3;

1150+ }) {};

1151+ "adjunctions" = callPackage

1152+ ({ mkDerivation, array, base, comonad, containers, contravariant

1153+ , distributive, free, mtl, profunctors, semigroupoids, semigroups

1154+ , tagged, transformers, void

1155+ }:

1156+ mkDerivation {

1157+ pname = "adjunctions";

1158+ version = "4.2";

1159+ sha256 = "07r56r6kyd6wlcxxnsnnyv59pyc8s1gsy54kzwmk9yknks5rij9i";

1160+ configureFlags = [

1161+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1162+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1163+ "-fsplitbase" "-f-test-hlint"

1164+ ];

1165+ libraryHaskellDepends = [

1166+ array base comonad containers contravariant distributive free mtl

1167+ profunctors semigroupoids semigroups tagged transformers void

1168+ ];

1169+ homepage = "http://github.com/ekmett/adjunctions/";

1170+ description = "Adjunctions and representable functors";

1171+ license = stdenv.lib.licenses.bsd3;

1172+ }) {};

1173+ "aeson" = callPackage

1174+ ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq

1175+ , dlist, ghc-prim, hashable, HUnit, mtl, old-locale, QuickCheck

1176+ , scientific, syb, template-haskell, test-framework

1177+ , test-framework-hunit, test-framework-quickcheck2, text, time

1178+ , unordered-containers, vector

1179+ }:

1180+ mkDerivation {

1181+ pname = "aeson";

1182+ version = "0.8.0.2";

1183+ sha256 = "1mc8cwmswx69r77wv7dfim525jqajnlxbcx5xf3ygpszzf6mh1q7";

1184+ revision = "1";

1185+ editedCabalFile = "0g4l7iq24klbmfprj4j31jcskzg0igwq6abp30vi6vlmr9rfcql0";

1186+ configureFlags = [

1187+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1188+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1189+ "-fsplitbase" "-f-test-hlint"

1190+ ];

1191+ libraryHaskellDepends = [

1192+ attoparsec base bytestring containers deepseq dlist ghc-prim

1193+ hashable mtl old-locale scientific syb template-haskell text time

1194+ unordered-containers vector

1195+ ];

1196+ testHaskellDepends = [

1197+ attoparsec base bytestring containers ghc-prim HUnit QuickCheck

1198+ template-haskell test-framework test-framework-hunit

1199+ test-framework-quickcheck2 text time unordered-containers vector

1200+ ];

1201+ homepage = "https://github.com/bos/aeson";

1202+ description = "Fast JSON parsing and encoding";

1203+ license = stdenv.lib.licenses.bsd3;

1204+ }) {};

1205+ "aeson-pretty" = callPackage

1206+ ({ mkDerivation, aeson, attoparsec, base, bytestring, cmdargs, text

1207+ , unordered-containers, vector

1208+ }:

1209+ mkDerivation {

1210+ pname = "aeson-pretty";

1211+ version = "0.7.2";

1212+ sha256 = "03ap81853qi8yd9kdgczllrrni23a6glsfxrwj8zab6ipjrbh234";

1213+ configureFlags = [

1214+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1215+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1216+ "-fsplitbase" "-f-test-hlint"

1217+ ];

1218+ isLibrary = true;

1219+ isExecutable = true;

1220+ libraryHaskellDepends = [

1221+ aeson base bytestring text unordered-containers vector

1222+ ];

1223+ executableHaskellDepends = [

1224+ aeson attoparsec base bytestring cmdargs

1225+ ];

1226+ homepage = "http://github.com/informatikr/aeson-pretty";

1227+ description = "JSON pretty-printing library and command-line tool";

1228+ license = stdenv.lib.licenses.bsd3;

1229+ }) {};

1230+ "aeson-qq" = callPackage

1231+ ({ mkDerivation, aeson, base, ghc-prim, haskell-src-meta, hspec

1232+ , parsec, template-haskell, text, vector

1233+ }:

1234+ mkDerivation {

1235+ pname = "aeson-qq";

1236+ version = "0.7.4";

1237+ sha256 = "0wnc9pdjvd15gfkdxzf084393vwmxv2xaxdchzgal1qhwa1mak4v";

1238+ configureFlags = [

1239+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1240+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1241+ "-fsplitbase" "-f-test-hlint"

1242+ ];

1243+ libraryHaskellDepends = [

1244+ aeson base haskell-src-meta parsec template-haskell text vector

1245+ ];

1246+ testHaskellDepends = [

1247+ aeson base ghc-prim haskell-src-meta hspec parsec template-haskell

1248+ text vector

1249+ ];

1250+ homepage = "http://github.com/zalora/aeson-qq";

1251+ description = "JSON quasiquoter for Haskell";

1252+ license = stdenv.lib.licenses.mit;

1253+ }) {};

1254+ "aeson-utils" = callPackage

1255+ ({ mkDerivation, aeson, attoparsec, base, bytestring, scientific

1256+ , text

1257+ }:

1258+ mkDerivation {

1259+ pname = "aeson-utils";

1260+ version = "0.2.2.1";

1261+ sha256 = "0sj4kdcxcj2wnf3s109yxq8gghz976hkiqs19bjcp6qkzdf5w6sd";

1262+ revision = "2";

1263+ editedCabalFile = "0b9ks5b6y5xajb499903sc684wknrzfx2pygrn3s0s4drwxa01pk";

1264+ configureFlags = [

1265+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1266+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1267+ "-fsplitbase" "-f-test-hlint"

1268+ ];

1269+ libraryHaskellDepends = [

1270+ aeson attoparsec base bytestring scientific text

1271+ ];

1272+ description = "Utilities for working with Aeson";

1273+ license = stdenv.lib.licenses.bsd3;

1274+ }) {};

1275+ "alex" = callPackage

1276+ ({ mkDerivation, array, base, containers, directory, happy, perl

1277+ , process, QuickCheck

1278+ }:

1279+ mkDerivation {

1280+ pname = "alex";

1281+ version = "3.1.3";

1282+ sha256 = "14hajxpqb6va5mclp2k682bgw9sbmd372vw41kq5aq815bkschcd";

1283+ revision = "1";

1284+ editedCabalFile = "16d0b44va8jd7xhjv60b4rb23vb89jjwyaycghvdx8racjzdi26d";

1285+ configureFlags = [

1286+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1287+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1288+ "-fsplitbase" "-f-test-hlint"

1289+ ];

1290+ isLibrary = false;

1291+ isExecutable = true;

1292+ executableHaskellDepends = [

1293+ array base containers directory QuickCheck

1294+ ];

1295+ executableToolDepends = [ happy ];

1296+ testHaskellDepends = [ base process ];

1297+ testToolDepends = [ perl ];

1298+ doHaddock = false;

1299+ doCheck = false;

1300+ homepage = "http://www.haskell.org/alex/";

1301+ description = "Alex is a tool for generating lexical analysers in Haskell";

1302+ license = stdenv.lib.licenses.bsd3;

1303+ }) {inherit (pkgs) perl;};

1304+ "amqp" = callPackage

1305+ ({ mkDerivation, base, binary, bytestring, clock, connection

1306+ , containers, data-binary-ieee754, hspec, hspec-expectations

1307+ , monad-control, network, split, text, vector, xml

1308+ }:

1309+ mkDerivation {

1310+ pname = "amqp";

1311+ version = "0.10.1";

1312+ sha256 = "1a2d17h1zhd2yv1zhd0vvr4g1v6nr188gwv12qwljs1v9y4jkbmc";

1313+ configureFlags = [

1314+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1315+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1316+ "-fsplitbase" "-f-test-hlint"

1317+ ];

1318+ isLibrary = true;

1319+ isExecutable = true;

1320+ libraryHaskellDepends = [

1321+ base binary bytestring clock connection containers

1322+ data-binary-ieee754 monad-control network split text vector

1323+ ];

1324+ executableHaskellDepends = [ base containers xml ];

1325+ testHaskellDepends = [

1326+ base binary bytestring clock connection containers

1327+ data-binary-ieee754 hspec hspec-expectations network split text

1328+ vector

1329+ ];

1330+ doHaddock = false;

1331+ doCheck = false;

1332+ homepage = "https://github.com/hreinhardt/amqp";

1333+ description = "Client library for AMQP servers (currently only RabbitMQ)";

1334+ license = stdenv.lib.licenses.bsd3;

1335+ }) {};

1336+ "ansi-terminal" = callPackage

1337+ ({ mkDerivation, base, unix }:

1338+ mkDerivation {

1339+ pname = "ansi-terminal";

1340+ version = "0.6.2.1";

1341+ sha256 = "1xmp8wpcyvqys777qpyfx99bhlnvmr7jil7r78j5n6fx3mkkhnln";

1342+ configureFlags = [

1343+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1344+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1345+ "-fsplitbase" "-f-test-hlint"

1346+ ];

1347+ isLibrary = true;

1348+ isExecutable = true;

1349+ libraryHaskellDepends = [ base unix ];

1350+ executableHaskellDepends = [ base unix ];

1351+ homepage = "https://github.com/feuerbach/ansi-terminal";

1352+ description = "Simple ANSI terminal support, with Windows compatibility";

1353+ license = stdenv.lib.licenses.bsd3;

1354+ }) {};

1355+ "ansi-wl-pprint" = callPackage

1356+ ({ mkDerivation, ansi-terminal, base }:

1357+ mkDerivation {

1358+ pname = "ansi-wl-pprint";

1359+ version = "0.6.7.1";

1360+ sha256 = "1by11bg1bd7z18hqgayk0w76hy5n63kmdl14gainlvfgr9jw506r";

1361+ revision = "1";

1362+ editedCabalFile = "059p6bb5izjhiszpm8waa5id2wk1753ylsjx97ngb93hhj3xkdis";

1363+ configureFlags = [

1364+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1365+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1366+ "-fsplitbase" "-f-test-hlint"

1367+ ];

1368+ isLibrary = true;

1369+ isExecutable = true;

1370+ libraryHaskellDepends = [ ansi-terminal base ];

1371+ executableHaskellDepends = [ ansi-terminal base ];

1372+ homepage = "http://github.com/batterseapower/ansi-wl-pprint";

1373+ description = "The Wadler/Leijen Pretty Printer for colored ANSI terminal output";

1374+ license = stdenv.lib.licenses.bsd3;

1375+ }) {};

1376+ "appar" = callPackage

1377+ ({ mkDerivation, base, bytestring }:

1378+ mkDerivation {

1379+ pname = "appar";

1380+ version = "0.1.4";

1381+ sha256 = "09jb9ij78fdkz2qk66rw99q19qnm504dpv0yq0pjsl6xwjmndsjq";

1382+ configureFlags = [

1383+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1384+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1385+ "-fsplitbase" "-f-test-hlint"

1386+ ];

1387+ libraryHaskellDepends = [ base bytestring ];

1388+ description = "A simple applicative parser";

1389+ license = stdenv.lib.licenses.bsd3;

1390+ }) {};

1391+ "approximate" = callPackage

1392+ ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq

1393+ , directory, distributive, doctest, filepath, generic-deriving

1394+ , ghc-prim, hashable, hashable-extras, lens, log-domain, pointed

1395+ , safecopy, semigroupoids, semigroups, simple-reflect, vector

1396+ }:

1397+ mkDerivation {

1398+ pname = "approximate";

1399+ version = "0.2.1.1";

1400+ sha256 = "18ac2z1yqqksqmq9ch36ja3qjn9v6cgyzxs64lnnp98mgcwsmhwr";

1401+ configureFlags = [

1402+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1403+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1404+ "-fsplitbase" "-f-test-hlint"

1405+ ];

1406+ libraryHaskellDepends = [

1407+ base binary bytes cereal comonad deepseq distributive

1408+ generic-deriving ghc-prim hashable hashable-extras lens log-domain

1409+ pointed safecopy semigroupoids semigroups vector

1410+ ];

1411+ testHaskellDepends = [

1412+ base directory doctest filepath generic-deriving semigroups

1413+ simple-reflect

1414+ ];

1415+ homepage = "http://github.com/analytics/approximate/";

1416+ description = "Approximate discrete values and numbers";

1417+ license = stdenv.lib.licenses.bsd3;

1418+ }) {};

1419+ "arbtt" = callPackage

1420+ ({ mkDerivation, aeson, array, base, binary, bytestring

1421+ , bytestring-progress, containers, deepseq, directory, filepath

1422+ , HUnit, libXScrnSaver, old-locale, parsec, pcre-light

1423+ , process-extras, strict, tasty, tasty-golden, tasty-hunit

1424+ , terminal-progress-bar, time, transformers, unix, utf8-string, X11

1425+ }:

1426+ mkDerivation {

1427+ pname = "arbtt";

1428+ version = "0.8.1.4";

1429+ sha256 = "15ydb425nvqfzajx09q713wy5xa7awbzfjlsidk17vf7qbhfjn7z";

1430+ configureFlags = [

1431+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1432+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1433+ "-fsplitbase" "-f-test-hlint"

1434+ ];

1435+ isLibrary = false;

1436+ isExecutable = true;

1437+ executableHaskellDepends = [

1438+ aeson array base binary bytestring bytestring-progress containers

1439+ deepseq directory filepath old-locale parsec pcre-light strict

1440+ terminal-progress-bar time transformers unix utf8-string X11

1441+ ];

1442+ executableSystemDepends = [ libXScrnSaver ];

1443+ testHaskellDepends = [

1444+ base binary bytestring containers deepseq directory HUnit

1445+ old-locale parsec pcre-light process-extras tasty tasty-golden

1446+ tasty-hunit time transformers unix utf8-string

1447+ ];

1448+ doHaddock = false;

1449+ homepage = "http://arbtt.nomeata.de/";

1450+ description = "Automatic Rule-Based Time Tracker";

1451+ license = "GPL";

1452+ }) {inherit (pkgs.xorg) libXScrnSaver;};

1453+ "arithmoi" = callPackage

1454+ ({ mkDerivation, array, base, containers, ghc-prim, integer-gmp

1455+ , mtl, random

1456+ }:

1457+ mkDerivation {

1458+ pname = "arithmoi";

1459+ version = "0.4.1.1";

1460+ sha256 = "02wrm24dpcsdsjaic30416axad5s4y822si1am4smb2qvrhps9ix";

1461+ revision = "2";

1462+ editedCabalFile = "12i9f720hnjk554phd32phamq4hb89srw66hvaalszl85m01xw4b";

1463+ configureFlags = [

1464+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1465+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1466+ "-fsplitbase" "-f-test-hlint"

1467+ ];

1468+ libraryHaskellDepends = [

1469+ array base containers ghc-prim integer-gmp mtl random

1470+ ];

1471+ homepage = "https://bitbucket.org/dafis/arithmoi";

1472+ description = "Efficient basic number-theoretic functions. Primes, powers, integer logarithms.";

1473+ license = stdenv.lib.licenses.mit;

1474+ }) {};

1475+ "arrow-list" = callPackage

1476+ ({ mkDerivation, base, containers, mtl }:

1477+ mkDerivation {

1478+ pname = "arrow-list";

1479+ version = "0.6.1.5";

1480+ sha256 = "0i0rwjrrvbi9fmwdzmz6vzkkr63pl2df653anjwcw3xr7ccb16xm";

1481+ configureFlags = [

1482+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1483+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1484+ "-fsplitbase" "-f-test-hlint"

1485+ ];

1486+ libraryHaskellDepends = [ base containers mtl ];

1487+ homepage = "https://github.com/silkapp/arrow-list";

1488+ description = "List arrows for Haskell";

1489+ license = stdenv.lib.licenses.bsd3;

1490+ }) {};

1491+ "asn1-data" = callPackage

1492+ ({ mkDerivation, base, bytestring, cereal, mtl, text }:

1493+ mkDerivation {

1494+ pname = "asn1-data";

1495+ version = "0.7.1";

1496+ sha256 = "10s7mxygw6w8a8mx090msvbl8pji8m68lsxxyr5bp7p887naia7r";

1497+ revision = "1";

1498+ editedCabalFile = "07zdlmgf5yp7sv4gpvadplr86rfw14mzmdg95h7ymfc8d83h33vc";

1499+ configureFlags = [

1500+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1501+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1502+ "-fsplitbase" "-f-test-hlint"

1503+ ];

1504+ isLibrary = true;

1505+ isExecutable = true;

1506+ enableSeparateDataOutput = true;

1507+ libraryHaskellDepends = [ base bytestring cereal mtl text ];

1508+ homepage = "http://github.com/vincenthz/hs-asn1-data";

1509+ description = "ASN1 data reader and writer in RAW, BER and DER forms";

1510+ license = stdenv.lib.licenses.bsd3;

1511+ }) {};

1512+ "asn1-encoding" = callPackage

1513+ ({ mkDerivation, asn1-types, base, bytestring, hourglass, mtl

1514+ , tasty, tasty-quickcheck, text

1515+ }:

1516+ mkDerivation {

1517+ pname = "asn1-encoding";

1518+ version = "0.9.0";

1519+ sha256 = "02x3lzyl4gavl3lc2lrg8rknyvs6r2hf8kmm7xrmma5m857iks8p";

1520+ configureFlags = [

1521+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1522+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1523+ "-fsplitbase" "-f-test-hlint"

1524+ ];

1525+ libraryHaskellDepends = [

1526+ asn1-types base bytestring hourglass mtl

1527+ ];

1528+ testHaskellDepends = [

1529+ asn1-types base bytestring hourglass mtl tasty tasty-quickcheck

1530+ text

1531+ ];

1532+ homepage = "http://github.com/vincenthz/hs-asn1";

1533+ description = "ASN1 data reader and writer in RAW, BER and DER forms";

1534+ license = stdenv.lib.licenses.bsd3;

1535+ }) {};

1536+ "asn1-parse" = callPackage

1537+ ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring, mtl

1538+ , text

1539+ }:

1540+ mkDerivation {

1541+ pname = "asn1-parse";

1542+ version = "0.9.0";

1543+ sha256 = "0m093wwndyxvy72qlnb70bp8w5ahimrlv1dp972l9s9l5jc4pjg3";

1544+ revision = "1";

1545+ editedCabalFile = "134wf7szi4zg88wvi4awhkndbzawgprz3059jxpp4jhmd0hxs97n";

1546+ configureFlags = [

1547+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1548+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1549+ "-fsplitbase" "-f-test-hlint"

1550+ ];

1551+ libraryHaskellDepends = [

1552+ asn1-encoding asn1-types base bytestring mtl text

1553+ ];

1554+ homepage = "http://github.com/vincenthz/hs-asn1";

1555+ description = "Simple monadic parser for ASN1 stream types";

1556+ license = stdenv.lib.licenses.bsd3;

1557+ }) {};

1558+ "asn1-types" = callPackage

1559+ ({ mkDerivation, base, bytestring, hourglass }:

1560+ mkDerivation {

1561+ pname = "asn1-types";

1562+ version = "0.3.0";

1563+ sha256 = "1am8nmfarv7ymy3rqm0js2i82v6n6qwz0lnzb1qdmy4ligcdm65r";

1564+ configureFlags = [

1565+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1566+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1567+ "-fsplitbase" "-f-test-hlint"

1568+ ];

1569+ libraryHaskellDepends = [ base bytestring hourglass ];

1570+ homepage = "http://github.com/vincenthz/hs-asn1-types";

1571+ description = "ASN.1 types";

1572+ license = stdenv.lib.licenses.bsd3;

1573+ }) {};

1574+ "async" = callPackage

1575+ ({ mkDerivation, base, HUnit, stm, test-framework

1576+ , test-framework-hunit

1577+ }:

1578+ mkDerivation {

1579+ pname = "async";

1580+ version = "2.0.1.6";

1581+ sha256 = "06fzkqjliccxqiygms7v1xff3wlkg54n9xwzv7m1yxylkzlikjkz";

1582+ configureFlags = [

1583+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1584+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1585+ "-fsplitbase" "-f-test-hlint"

1586+ ];

1587+ libraryHaskellDepends = [ base stm ];

1588+ testHaskellDepends = [

1589+ base HUnit test-framework test-framework-hunit

1590+ ];

1591+ homepage = "https://github.com/simonmar/async";

1592+ description = "Run IO operations asynchronously and wait for their results";

1593+ license = stdenv.lib.licenses.bsd3;

1594+ }) {};

1595+ "atto-lisp" = callPackage

1596+ ({ mkDerivation, attoparsec, base, blaze-builder, blaze-textual

1597+ , bytestring, containers, deepseq, HUnit, test-framework

1598+ , test-framework-hunit, text

1599+ }:

1600+ mkDerivation {

1601+ pname = "atto-lisp";

1602+ version = "0.2.2";

1603+ sha256 = "13lhdalam4gn9faa58c3c7nssdwp2y0jsfl1lnnvr3dx6wzp0jhc";

1604+ revision = "1";

1605+ editedCabalFile = "1ypjd6cknbr8dfrgfs9wv0amv2s28ibgxlvyfsnann4wv19rgczy";

1606+ configureFlags = [

1607+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1608+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1609+ "-fsplitbase" "-f-test-hlint"

1610+ ];

1611+ libraryHaskellDepends = [

1612+ attoparsec base blaze-builder blaze-textual bytestring containers

1613+ deepseq text

1614+ ];

1615+ testHaskellDepends = [

1616+ attoparsec base bytestring HUnit test-framework

1617+ test-framework-hunit text

1618+ ];

1619+ homepage = "http://github.com/nominolo/atto-lisp";

1620+ description = "Efficient parsing and serialisation of S-Expressions";

1621+ license = stdenv.lib.licenses.bsd3;

1622+ }) {};

1623+ "attoparsec" = callPackage

1624+ ({ mkDerivation, array, base, bytestring, containers, criterion

1625+ , deepseq, directory, filepath, parsec, QuickCheck, scientific

1626+ , test-framework, test-framework-quickcheck2, text

1627+ , unordered-containers, vector

1628+ }:

1629+ mkDerivation {

1630+ pname = "attoparsec";

1631+ version = "0.12.1.2";

1632+ sha256 = "1vazyr3fdahdg1q503sbj0zv4xj7sm7j32mjm856bm51j2s0rhlc";

1633+ configureFlags = [

1634+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1635+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1636+ "-fsplitbase" "-f-test-hlint"

1637+ ];

1638+ libraryHaskellDepends = [

1639+ array base bytestring containers deepseq scientific text

1640+ ];

1641+ testHaskellDepends = [

1642+ array base bytestring deepseq QuickCheck scientific test-framework

1643+ test-framework-quickcheck2 text vector

1644+ ];

1645+ benchmarkHaskellDepends = [

1646+ array base bytestring criterion deepseq directory filepath parsec

1647+ scientific text unordered-containers vector

1648+ ];

1649+ homepage = "https://github.com/bos/attoparsec";

1650+ description = "Fast combinator parsing for bytestrings and text";

1651+ license = stdenv.lib.licenses.bsd3;

1652+ }) {};

1653+ "attoparsec-conduit" = callPackage

1654+ ({ mkDerivation, base, conduit }:

1655+ mkDerivation {

1656+ pname = "attoparsec-conduit";

1657+ version = "1.1.0";

1658+ sha256 = "18xn3nzxfghcd88cana1jw85ijv0ysw3bp36fb6r5wsf6m79z01y";

1659+ configureFlags = [

1660+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1661+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1662+ "-fsplitbase" "-f-test-hlint"

1663+ ];

1664+ libraryHaskellDepends = [ base conduit ];

1665+ doHaddock = false;

1666+ doCheck = false;

1667+ homepage = "http://github.com/snoyberg/conduit";

1668+ description = "Consume attoparsec parsers via conduit. (deprecated)";

1669+ license = stdenv.lib.licenses.mit;

1670+ }) {};

1671+ "attoparsec-enumerator" = callPackage

1672+ ({ mkDerivation, attoparsec, base, bytestring, enumerator, text }:

1673+ mkDerivation {

1674+ pname = "attoparsec-enumerator";

1675+ version = "0.3.3";

1676+ sha256 = "0z57bbw97v92dkjp57zj9nfzsdas2n1qfw472k1aa84iqb6hbw9w";

1677+ configureFlags = [

1678+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1679+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1680+ "-fsplitbase" "-f-test-hlint"

1681+ ];

1682+ libraryHaskellDepends = [

1683+ attoparsec base bytestring enumerator text

1684+ ];

1685+ homepage = "https://john-millikin.com/software/attoparsec-enumerator/";

1686+ description = "Pass input from an enumerator to an Attoparsec parser";

1687+ license = stdenv.lib.licenses.mit;

1688+ }) {};

1689+ "attoparsec-expr" = callPackage

1690+ ({ mkDerivation, attoparsec, base }:

1691+ mkDerivation {

1692+ pname = "attoparsec-expr";

1693+ version = "0.1.1.1";

1694+ sha256 = "09305lp9q3cgvpv4d878c34dk07g7p13hc07hrp2xlwl7rc3nac3";

1695+ configureFlags = [

1696+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1697+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1698+ "-fsplitbase" "-f-test-hlint"

1699+ ];

1700+ libraryHaskellDepends = [ attoparsec base ];

1701+ description = "Port of parsec's expression parser to attoparsec";

1702+ license = stdenv.lib.licenses.bsd3;

1703+ }) {};

1704+ "authenticate" = callPackage

1705+ ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring

1706+ , case-insensitive, conduit, containers, http-conduit, http-types

1707+ , monad-control, network, resourcet, tagstream-conduit, text

1708+ , transformers, unordered-containers, xml-conduit

1709+ }:

1710+ mkDerivation {

1711+ pname = "authenticate";

1712+ version = "1.3.2.10";

1713+ sha256 = "1dy38k5jpms3xrkw1zh7vjmx06yr5iibgh50m5i2wky2wmryqkf4";

1714+ configureFlags = [

1715+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1716+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1717+ "-fsplitbase" "-f-test-hlint"

1718+ ];

1719+ libraryHaskellDepends = [

1720+ aeson attoparsec base blaze-builder bytestring case-insensitive

1721+ conduit containers http-conduit http-types monad-control network

1722+ resourcet tagstream-conduit text transformers unordered-containers

1723+ xml-conduit

1724+ ];

1725+ homepage = "http://github.com/yesodweb/authenticate";

1726+ description = "Authentication methods for Haskell web applications";

1727+ license = stdenv.lib.licenses.bsd3;

1728+ }) {};

1729+ "auto-update" = callPackage

1730+ ({ mkDerivation, base }:

1731+ mkDerivation {

1732+ pname = "auto-update";

1733+ version = "0.1.2";

1734+ sha256 = "0ccix41jjpqkzvnfr5md1cbhsa9fkv6dy7yw73j8dnvqbqnz1z0l";

1735+ configureFlags = [

1736+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1737+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1738+ "-fsplitbase" "-f-test-hlint"

1739+ ];

1740+ libraryHaskellDepends = [ base ];

1741+ homepage = "https://github.com/yesodweb/wai";

1742+ description = "Efficiently run periodic, on-demand actions";

1743+ license = stdenv.lib.licenses.mit;

1744+ }) {};

1745+ "aws" = callPackage

1746+ ({ mkDerivation, aeson, attoparsec, base, base16-bytestring

1747+ , base64-bytestring, blaze-builder, byteable, bytestring

1748+ , case-insensitive, cereal, conduit, conduit-extra, containers

1749+ , cryptohash, data-default, directory, errors, filepath

1750+ , http-client, http-conduit, http-types, lifted-base, monad-control

1751+ , mtl, network, old-locale, QuickCheck, quickcheck-instances

1752+ , resourcet, safe, scientific, tagged, tasty, tasty-quickcheck

1753+ , text, time, transformers, transformers-base, unordered-containers

1754+ , utf8-string, vector, xml-conduit

1755+ }:

1756+ mkDerivation {

1757+ pname = "aws";

1758+ version = "0.11";

1759+ sha256 = "19q7r74c5xw04vpwl2fwm675bvkp3vhlak63iqfl1927z2jsyva9";

1760+ revision = "1";

1761+ editedCabalFile = "04vcp6xvqvfp7szkvl311yg25cdcxgggw7bpwbd4ak3cjj5cgcb0";

1762+ configureFlags = [

1763+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1764+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1765+ "-fsplitbase" "-f-test-hlint"

1766+ ];

1767+ isLibrary = true;

1768+ isExecutable = true;

1769+ libraryHaskellDepends = [

1770+ aeson attoparsec base base16-bytestring base64-bytestring

1771+ blaze-builder byteable bytestring case-insensitive cereal conduit

1772+ conduit-extra containers cryptohash data-default directory filepath

1773+ http-conduit http-types lifted-base monad-control mtl network

1774+ old-locale resourcet safe scientific tagged text time transformers

1775+ unordered-containers utf8-string vector xml-conduit

1776+ ];

1777+ testHaskellDepends = [

1778+ aeson base bytestring errors http-client lifted-base monad-control

1779+ mtl QuickCheck quickcheck-instances resourcet tagged tasty

1780+ tasty-quickcheck text time transformers transformers-base

1781+ ];

1782+ doHaddock = false;

1783+ doCheck = false;

1784+ homepage = "http://github.com/aristidb/aws";

1785+ description = "Amazon Web Services (AWS) for Haskell";

1786+ license = stdenv.lib.licenses.bsd3;

1787+ }) {};

1788+ "bake" = callPackage

1789+ ({ mkDerivation, aeson, base, bytestring, cmdargs, deepseq

1790+ , directory, extra, filepath, hashable, HTTP, http-types, process

1791+ , random, shake, text, time, wai, warp

1792+ }:

1793+ mkDerivation {

1794+ pname = "bake";

1795+ version = "0.2";

1796+ sha256 = "1j7m9q5vk35sqs6if9rzb72avi7xbjhbcv0hpg9qvn9nvs38dgiw";

1797+ configureFlags = [

1798+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1799+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1800+ "-fsplitbase" "-f-test-hlint"

1801+ ];

1802+ isLibrary = true;

1803+ isExecutable = true;

1804+ enableSeparateDataOutput = true;

1805+ libraryHaskellDepends = [

1806+ aeson base bytestring cmdargs deepseq directory extra filepath

1807+ hashable HTTP http-types random shake text time wai warp

1808+ ];

1809+ executableHaskellDepends = [

1810+ aeson base bytestring cmdargs deepseq directory extra filepath

1811+ hashable HTTP http-types process random shake text time wai warp

1812+ ];

1813+ homepage = "https://github.com/ndmitchell/bake#readme";

1814+ description = "Continuous integration system";

1815+ license = stdenv.lib.licenses.bsd3;

1816+ }) {};

1817+ "barecheck" = callPackage

1818+ ({ mkDerivation, base, containers, QuickCheck, text, time }:

1819+ mkDerivation {

1820+ pname = "barecheck";

1821+ version = "0.2.0.6";

1822+ sha256 = "0avz5pdnvd3kjgp9swpdfxddp60gqpamwd7j4xl8xdj3b2di5zk0";

1823+ configureFlags = [

1824+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1825+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1826+ "-fsplitbase" "-f-test-hlint"

1827+ ];

1828+ libraryHaskellDepends = [ base containers QuickCheck text time ];

1829+ homepage = "http://github.com/massysett/barecheck";

1830+ description = "QuickCheck implementations for common types";

1831+ license = stdenv.lib.licenses.bsd3;

1832+ }) {};

1833+ "base-compat" = callPackage

1834+ ({ mkDerivation, base, errorcall-eq-instance, hspec, QuickCheck

1835+ , setenv

1836+ }:

1837+ mkDerivation {

1838+ pname = "base-compat";

1839+ version = "0.5.0";

1840+ sha256 = "1zlpfpfnaqf8rrha19arh882bc560dcw2zwi4j3qrn3lzyh8s1d1";

1841+ revision = "1";

1842+ editedCabalFile = "04s7a4v2z8bjxlrynbx12xbmj3yraalppp7k6ad019zspzmf0bzy";

1843+ configureFlags = [

1844+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1845+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1846+ "-fsplitbase" "-f-test-hlint"

1847+ ];

1848+ libraryHaskellDepends = [ base errorcall-eq-instance setenv ];

1849+ testHaskellDepends = [ base hspec QuickCheck ];

1850+ description = "A compatibility layer for base";

1851+ license = stdenv.lib.licenses.mit;

1852+ }) {};

1853+ "base-prelude" = callPackage

1854+ ({ mkDerivation, base }:

1855+ mkDerivation {

1856+ pname = "base-prelude";

1857+ version = "0.1.6";

1858+ sha256 = "1lc8j3wfaqh42pqshlizkpr67ghkr1m90m1g9xiw8h36p8n72fcm";

1859+ revision = "1";

1860+ editedCabalFile = "187vmgimc4z560kmw366ivxn5q5dr2l35ckfcb61sp1ajc2j5j30";

1861+ configureFlags = [

1862+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1863+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1864+ "-fsplitbase" "-f-test-hlint"

1865+ ];

1866+ libraryHaskellDepends = [ base ];

1867+ doHaddock = false;

1868+ doCheck = false;

1869+ homepage = "https://github.com/nikita-volkov/base-prelude";

1870+ description = "The most complete prelude formed from only the \"base\" package";

1871+ license = stdenv.lib.licenses.mit;

1872+ }) {};

1873+ "base-unicode-symbols" = callPackage

1874+ ({ mkDerivation, base }:

1875+ mkDerivation {

1876+ pname = "base-unicode-symbols";

1877+ version = "0.2.2.4";

1878+ sha256 = "1afc5pchd3vw33bmjbjygkd0l5zh7glbsx4bfyxfscpc1x1l3y52";

1879+ configureFlags = [

1880+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1881+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1882+ "-fsplitbase" "-f-test-hlint"

1883+ ];

1884+ libraryHaskellDepends = [ base ];

1885+ homepage = "http://haskell.org/haskellwiki/Unicode-symbols";

1886+ description = "Unicode alternatives for common functions and operators";

1887+ license = stdenv.lib.licenses.bsd3;

1888+ }) {};

1889+ "base16-bytestring" = callPackage

1890+ ({ mkDerivation, base, bytestring, ghc-prim }:

1891+ mkDerivation {

1892+ pname = "base16-bytestring";

1893+ version = "0.1.1.6";

1894+ sha256 = "0jf40m3yijqw6wd1rwwvviww46fasphaay9m9rgqyhf5aahnbzjs";

1895+ configureFlags = [

1896+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1897+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1898+ "-fsplitbase" "-f-test-hlint"

1899+ ];

1900+ libraryHaskellDepends = [ base bytestring ghc-prim ];

1901+ homepage = "http://github.com/bos/base16-bytestring";

1902+ description = "Fast base16 (hex) encoding and decoding for ByteStrings";

1903+ license = stdenv.lib.licenses.bsd3;

1904+ }) {};

1905+ "base64-bytestring" = callPackage

1906+ ({ mkDerivation, base, bytestring, containers, HUnit, QuickCheck

1907+ , test-framework, test-framework-hunit, test-framework-quickcheck2

1908+ }:

1909+ mkDerivation {

1910+ pname = "base64-bytestring";

1911+ version = "1.0.0.1";

1912+ sha256 = "0l1v4ddjdsgi9nqzyzcxxj76rwar3lzx8gmwf2r54bqan3san9db";

1913+ configureFlags = [

1914+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1915+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1916+ "-fsplitbase" "-f-test-hlint"

1917+ ];

1918+ libraryHaskellDepends = [ base bytestring ];

1919+ testHaskellDepends = [

1920+ base bytestring containers HUnit QuickCheck test-framework

1921+ test-framework-hunit test-framework-quickcheck2

1922+ ];

1923+ homepage = "https://github.com/bos/base64-bytestring";

1924+ description = "Fast base64 encoding and decoding for ByteStrings";

1925+ license = stdenv.lib.licenses.bsd3;

1926+ }) {};

1927+ "basic-prelude" = callPackage

1928+ ({ mkDerivation, base, bytestring, containers, hashable

1929+ , lifted-base, ReadArgs, safe, system-filepath, text, transformers

1930+ , unordered-containers, vector

1931+ }:

1932+ mkDerivation {

1933+ pname = "basic-prelude";

1934+ version = "0.3.10";

1935+ sha256 = "10013ni7kpqlc6s3ryfvmklw3ic5h48rm4wsrb31pcp5xja0qk59";

1936+ configureFlags = [

1937+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1938+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1939+ "-fsplitbase" "-f-test-hlint"

1940+ ];

1941+ libraryHaskellDepends = [

1942+ base bytestring containers hashable lifted-base ReadArgs safe

1943+ system-filepath text transformers unordered-containers vector

1944+ ];

1945+ homepage = "https://github.com/snoyberg/basic-prelude";

1946+ description = "An enhanced core prelude; a common foundation for alternate preludes";

1947+ license = stdenv.lib.licenses.mit;

1948+ }) {};

1949+ "bifunctors" = callPackage

1950+ ({ mkDerivation, base, semigroupoids, semigroups, tagged }:

1951+ mkDerivation {

1952+ pname = "bifunctors";

1953+ version = "4.2";

1954+ sha256 = "0gxj22qv0avg2rhmfbbjrx35yr83r311vm8asc4q71lzkbyg8qf6";

1955+ revision = "2";

1956+ editedCabalFile = "01h09dn1k409srd25n832qkv85a82px6dx6fl1v48j8n7vs365np";

1957+ configureFlags = [

1958+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1959+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1960+ "-fsplitbase" "-f-test-hlint"

1961+ ];

1962+ libraryHaskellDepends = [ base semigroupoids semigroups tagged ];

1963+ homepage = "http://github.com/ekmett/bifunctors/";

1964+ description = "Bifunctors";

1965+ license = stdenv.lib.licenses.bsd3;

1966+ }) {};

1967+ "binary-list" = callPackage

1968+ ({ mkDerivation, base, binary, bytestring, criterion, deepseq

1969+ , phantom-state, transformers

1970+ }:

1971+ mkDerivation {

1972+ pname = "binary-list";

1973+ version = "1.0.1.0";

1974+ sha256 = "1d83ka79nnq5pw4djs6x3ccgygkq89q9wakgykx4wvyf7l0xj7d9";

1975+ configureFlags = [

1976+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1977+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1978+ "-fsplitbase" "-f-test-hlint"

1979+ ];

1980+ libraryHaskellDepends = [

1981+ base binary bytestring deepseq phantom-state transformers

1982+ ];

1983+ benchmarkHaskellDepends = [ base criterion ];

1984+ description = "Lists of length a power of two";

1985+ license = stdenv.lib.licenses.bsd3;

1986+ }) {};

1987+ "bindings-DSL" = callPackage

1988+ ({ mkDerivation, base }:

1989+ mkDerivation {

1990+ pname = "bindings-DSL";

1991+ version = "1.0.21";

1992+ sha256 = "0fbrl9jfkwlv66v3cv6cj51kk7jjdry0jz8k83bf4mav26123mk9";

1993+ configureFlags = [

1994+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1995+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1996+ "-fsplitbase" "-f-test-hlint"

1997+ ];

1998+ libraryHaskellDepends = [ base ];

1999+ homepage = "https://github.com/jwiegley/bindings-dsl/wiki";

2000+ description = "FFI domain specific language, on top of hsc2hs";

2001+ license = stdenv.lib.licenses.bsd3;

2002+ }) {};

2003+ "bioace" = callPackage

2004+ ({ mkDerivation, base, bioalign, biocore, bytestring, parsec }:

2005+ mkDerivation {

2006+ pname = "bioace";

2007+ version = "0.0.1";

2008+ sha256 = "08k2w66gpysjk038pi50lc21gbn2dyp5z8ls0qhcmjqc59dn8hvg";

2009+ configureFlags = [

2010+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2011+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2012+ "-fsplitbase" "-f-test-hlint"

2013+ ];

2014+ libraryHaskellDepends = [

2015+ base bioalign biocore bytestring parsec

2016+ ];

2017+ homepage = "https://patch-tag.com/r/dfornika/bioace/home";

2018+ description = "Library for reading ace assembly files";

2019+ license = "GPL";

2020+ }) {};

2021+ "bioalign" = callPackage

2022+ ({ mkDerivation, base, biocore, bytestring }:

2023+ mkDerivation {

2024+ pname = "bioalign";

2025+ version = "0.0.5";

2026+ sha256 = "006gg8ds6klrl9rc1csi247rf8gzlgn9mdi0jl4pjz5xmf0jw5dr";

2027+ configureFlags = [

2028+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2029+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2030+ "-fsplitbase" "-f-test-hlint"

2031+ ];

2032+ libraryHaskellDepends = [ base biocore bytestring ];

2033+ homepage = "https://patch-tag.com/r/dfornika/biophd/home";

2034+ description = "Data structures and helper functions for calculating alignments";

2035+ license = "GPL";

2036+ }) {};

2037+ "biocore" = callPackage

2038+ ({ mkDerivation, base, bytestring, stringable }:

2039+ mkDerivation {

2040+ pname = "biocore";

2041+ version = "0.3.1";

2042+ sha256 = "06ml9p144bv0c9hv6pkcvhdgc0vw0jxzbqb834ilr38kjmrpsar1";

2043+ configureFlags = [

2044+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2045+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2046+ "-fsplitbase" "-f-test-hlint"

2047+ ];

2048+ libraryHaskellDepends = [ base bytestring stringable ];

2049+ description = "A bioinformatics library";

2050+ license = "LGPL";

2051+ }) {};

2052+ "biofasta" = callPackage

2053+ ({ mkDerivation, base, biocore, bytestring }:

2054+ mkDerivation {

2055+ pname = "biofasta";

2056+ version = "0.0.3";

2057+ sha256 = "1l770sg2gcg7wl5yfrrk9nr7hgd5m0q158ad5nd8z7i5vsfah8b2";

2058+ configureFlags = [

2059+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2060+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2061+ "-fsplitbase" "-f-test-hlint"

2062+ ];

2063+ libraryHaskellDepends = [ base biocore bytestring ];

2064+ homepage = "https://patch-tag.com/r/dfornika/biofasta/home";

2065+ description = "Library for reading fasta sequence files";

2066+ license = "GPL";

2067+ }) {};

2068+ "biofastq" = callPackage

2069+ ({ mkDerivation, base, biocore, bytestring }:

2070+ mkDerivation {

2071+ pname = "biofastq";

2072+ version = "0.1";

2073+ sha256 = "0453cb2sw6x9hx3z7w3fvymwi0l0s86wlvi6vvsh0jcwas3iirbl";

2074+ configureFlags = [

2075+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2076+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2077+ "-fsplitbase" "-f-test-hlint"

2078+ ];

2079+ libraryHaskellDepends = [ base biocore bytestring ];

2080+ homepage = "http://biohaskell.org/";

2081+ description = "A library for reading FASTQ files";

2082+ license = "LGPL";

2083+ }) {};

2084+ "biophd" = callPackage

2085+ ({ mkDerivation, base, binary, biocore, bytestring, parsec, text }:

2086+ mkDerivation {

2087+ pname = "biophd";

2088+ version = "0.0.5";

2089+ sha256 = "15bsrhwhgmdhl6l6xad1di4p1hslnlydawhqkf3z8y3pih1sasy7";

2090+ configureFlags = [

2091+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2092+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2093+ "-fsplitbase" "-f-test-hlint"

2094+ ];

2095+ libraryHaskellDepends = [

2096+ base binary biocore bytestring parsec text

2097+ ];

2098+ homepage = "https://patch-tag.com/r/dfornika/biophd/home";

2099+ description = "Library for reading phd sequence files";

2100+ license = "GPL";

2101+ }) {};

2102+ "biopsl" = callPackage

2103+ ({ mkDerivation, base, biocore, bytestring, cmdargs

2104+ , unordered-containers

2105+ }:

2106+ mkDerivation {

2107+ pname = "biopsl";

2108+ version = "0.4";

2109+ sha256 = "1v9vg9gnrf606raqlzcd15irg60v3cf5m0yy5qsdyxm24102bgmj";

2110+ configureFlags = [

2111+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2112+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2113+ "-fsplitbase" "-f-test-hlint"

2114+ ];

2115+ isLibrary = true;

2116+ isExecutable = true;

2117+ libraryHaskellDepends = [ base biocore bytestring ];

2118+ executableHaskellDepends = [ cmdargs unordered-containers ];

2119+ homepage = "http://biohaskell.org/";

2120+ description = "Library and executables for working with PSL files";

2121+ license = "LGPL";

2122+ }) {};

2123+ "biosff" = callPackage

2124+ ({ mkDerivation, array, base, binary, biocore, bytestring, cmdargs

2125+ , mtl

2126+ }:

2127+ mkDerivation {

2128+ pname = "biosff";

2129+ version = "0.3.7.1";

2130+ sha256 = "1mxsqxcf5sh37gpfqil499i9n8wi3sk5sl2cx6x6agbc0n726bwq";

2131+ configureFlags = [

2132+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2133+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2134+ "-fsplitbase" "-f-test-hlint"

2135+ ];

2136+ isLibrary = true;

2137+ isExecutable = true;

2138+ libraryHaskellDepends = [ array base binary biocore bytestring ];

2139+ executableHaskellDepends = [ array base cmdargs mtl ];

2140+ homepage = "http://biohaskell.org/";

2141+ description = "Library and executables for working with SFF files";

2142+ license = stdenv.lib.licenses.lgpl21;

2143+ }) {};

2144+ "bits" = callPackage

2145+ ({ mkDerivation, base, bytes, directory, doctest, filepath, mtl

2146+ , transformers

2147+ }:

2148+ mkDerivation {

2149+ pname = "bits";

2150+ version = "0.4";

2151+ sha256 = "12s5yk47y0zqzqiyaw9jchyl3crf1id9dk67m638b070d46k29p6";

2152+ configureFlags = [

2153+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2154+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2155+ "-fsplitbase" "-f-test-hlint"

2156+ ];

2157+ libraryHaskellDepends = [ base bytes mtl transformers ];

2158+ testHaskellDepends = [ base directory doctest filepath ];

2159+ doHaddock = false;

2160+ doCheck = false;

2161+ homepage = "http://github.com/analytics/bits";

2162+ description = "Various bit twiddling and bitwise serialization primitives";

2163+ license = stdenv.lib.licenses.bsd3;

2164+ }) {};

2165+ "blastxml" = callPackage

2166+ ({ mkDerivation, base, biocore, bytestring, parallel, tagsoup }:

2167+ mkDerivation {

2168+ pname = "blastxml";

2169+ version = "0.3.2";

2170+ sha256 = "0slqvv8729vlniwswwipw3yss9id6xvmd416kad1ij064g28j00c";

2171+ configureFlags = [

2172+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2173+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2174+ "-fsplitbase" "-f-test-hlint"

2175+ ];

2176+ libraryHaskellDepends = [

2177+ base biocore bytestring parallel tagsoup

2178+ ];

2179+ homepage = "http://biohaskell.org/";

2180+ description = "Library for reading Blast XML output";

2181+ license = "LGPL";

2182+ }) {};

2183+ "blaze-builder" = callPackage

2184+ ({ mkDerivation, base, bytestring, text }:

2185+ mkDerivation {

2186+ pname = "blaze-builder";

2187+ version = "0.3.3.4";

2188+ sha256 = "12xgmi8bc3h3cfk31rrfaklmwvyxgdwzwmxzw22yxd0dd8g11hg5";

2189+ configureFlags = [

2190+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2191+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2192+ "-fsplitbase" "-f-test-hlint"

2193+ ];

2194+ libraryHaskellDepends = [ base bytestring text ];

2195+ homepage = "http://github.com/meiersi/blaze-builder";

2196+ description = "Efficient buffered output";

2197+ license = stdenv.lib.licenses.bsd3;

2198+ }) {};

2199+ "blaze-builder-enumerator" = callPackage

2200+ ({ mkDerivation, base, blaze-builder, bytestring, enumerator

2201+ , transformers

2202+ }:

2203+ mkDerivation {

2204+ pname = "blaze-builder-enumerator";

2205+ version = "0.2.0.6";

2206+ sha256 = "0pdw18drvikb465qh43b8wjyvpqj3wcilyczc21fri5ma4mxdkyp";

2207+ configureFlags = [

2208+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2209+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2210+ "-fsplitbase" "-f-test-hlint"

2211+ ];

2212+ libraryHaskellDepends = [

2213+ base blaze-builder bytestring enumerator transformers

2214+ ];

2215+ homepage = "https://github.com/meiersi/blaze-builder-enumerator";

2216+ description = "Enumeratees for the incremental conversion of builders to bytestrings";

2217+ license = stdenv.lib.licenses.bsd3;

2218+ }) {};

2219+ "blaze-html" = callPackage

2220+ ({ mkDerivation, base, blaze-builder, blaze-markup, bytestring

2221+ , containers, HUnit, QuickCheck, test-framework

2222+ , test-framework-hunit, test-framework-quickcheck2, text

2223+ }:

2224+ mkDerivation {

2225+ pname = "blaze-html";

2226+ version = "0.7.0.3";

2227+ sha256 = "1jn3vvrxb3ifxb5yzs76pjlk8c366xg1sab7qlw9a4kwmigvl6vx";

2228+ configureFlags = [

2229+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2230+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2231+ "-fsplitbase" "-f-test-hlint"

2232+ ];

2233+ libraryHaskellDepends = [

2234+ base blaze-builder blaze-markup bytestring text

2235+ ];

2236+ testHaskellDepends = [

2237+ base blaze-builder blaze-markup bytestring containers HUnit

2238+ QuickCheck test-framework test-framework-hunit

2239+ test-framework-quickcheck2 text

2240+ ];

2241+ homepage = "http://jaspervdj.be/blaze";

2242+ description = "A blazingly fast HTML combinator library for Haskell";

2243+ license = stdenv.lib.licenses.bsd3;

2244+ }) {};

2245+ "blaze-markup" = callPackage

2246+ ({ mkDerivation, base, blaze-builder, bytestring, containers, HUnit

2247+ , QuickCheck, test-framework, test-framework-hunit

2248+ , test-framework-quickcheck2, text

2249+ }:

2250+ mkDerivation {

2251+ pname = "blaze-markup";

2252+ version = "0.6.1.1";

2253+ sha256 = "1ah6fgfqsmarq8g4gw81yhckz4pclb2ifxv237cqz5zhy9il4j5d";

2254+ revision = "1";

2255+ editedCabalFile = "1w4r4acdcmb11myrzaghqxifjk47kkv98jqkzb1yvk2v6gp0v9xw";

2256+ configureFlags = [

2257+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2258+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2259+ "-fsplitbase" "-f-test-hlint"

2260+ ];

2261+ libraryHaskellDepends = [ base blaze-builder bytestring text ];

2262+ testHaskellDepends = [

2263+ base blaze-builder bytestring containers HUnit QuickCheck

2264+ test-framework test-framework-hunit test-framework-quickcheck2 text

2265+ ];

2266+ homepage = "http://jaspervdj.be/blaze";

2267+ description = "A blazingly fast markup combinator library for Haskell";

2268+ license = stdenv.lib.licenses.bsd3;

2269+ }) {};

2270+ "blaze-svg" = callPackage

2271+ ({ mkDerivation, base, blaze-markup, mtl }:

2272+ mkDerivation {

2273+ pname = "blaze-svg";

2274+ version = "0.3.4";

2275+ sha256 = "061011qrpqiyag9549hn0hfikvkrin5wb3cf0zfm9n80cgvzmqd3";

2276+ configureFlags = [

2277+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2278+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2279+ "-fsplitbase" "-f-test-hlint"

2280+ ];

2281+ libraryHaskellDepends = [ base blaze-markup mtl ];

2282+ homepage = "https://github.com/deepakjois/blaze-svg";

2283+ description = "SVG combinator library";

2284+ license = stdenv.lib.licenses.bsd3;

2285+ }) {};

2286+ "blaze-textual" = callPackage

2287+ ({ mkDerivation, base, blaze-builder, bytestring, double-conversion

2288+ , ghc-prim, integer-gmp, old-locale, QuickCheck, test-framework

2289+ , test-framework-quickcheck2, text, time, vector

2290+ }:

2291+ mkDerivation {

2292+ pname = "blaze-textual";

2293+ version = "0.2.0.9";

2294+ sha256 = "1gwy1pjnc2ikxfxn9c751rnydry1hmlfk13k29xnns9vwglf81f0";

2295+ configureFlags = [

2296+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2297+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2298+ "-fsplitbase" "-f-test-hlint"

2299+ ];

2300+ libraryHaskellDepends = [

2301+ base blaze-builder bytestring ghc-prim integer-gmp old-locale text

2302+ time vector

2303+ ];

2304+ testHaskellDepends = [

2305+ base blaze-builder bytestring double-conversion QuickCheck

2306+ test-framework test-framework-quickcheck2

2307+ ];

2308+ homepage = "http://github.com/bos/blaze-textual";

2309+ description = "Fast rendering of common datatypes";

2310+ license = stdenv.lib.licenses.bsd3;

2311+ }) {};

2312+ "bloodhound" = callPackage

2313+ ({ mkDerivation, aeson, base, bytestring, conduit, containers

2314+ , http-client, http-types, semigroups, text, time, vector

2315+ }:

2316+ mkDerivation {

2317+ pname = "bloodhound";

2318+ version = "0.4.0.2";

2319+ sha256 = "02glp7zi44syv17cg9a8jcn9x5lkh3h163g0lr3qynvskc5ww6sk";

2320+ configureFlags = [

2321+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2322+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2323+ "-fsplitbase" "-f-test-hlint"

2324+ ];

2325+ libraryHaskellDepends = [

2326+ aeson base bytestring conduit containers http-client http-types

2327+ semigroups text time vector

2328+ ];

2329+ doHaddock = false;

2330+ doCheck = false;

2331+ homepage = "https://github.com/bitemyapp/bloodhound";

2332+ description = "ElasticSearch client library for Haskell";

2333+ license = stdenv.lib.licenses.bsd3;

2334+ }) {};

2335+ "bmp" = callPackage

2336+ ({ mkDerivation, base, binary, bytestring }:

2337+ mkDerivation {

2338+ pname = "bmp";

2339+ version = "1.2.5.2";

2340+ sha256 = "0f88f2ynm1fpzbjijy5fa8blfrdv42h5h28hfjlpd4fp0h96in5x";

2341+ configureFlags = [

2342+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2343+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2344+ "-fsplitbase" "-f-test-hlint"

2345+ ];

2346+ libraryHaskellDepends = [ base binary bytestring ];

2347+ homepage = "http://code.ouroborus.net/bmp";

2348+ description = "Read and write uncompressed BMP image files";

2349+ license = stdenv.lib.licenses.mit;

2350+ }) {};

2351+ "bool-extras" = callPackage

2352+ ({ mkDerivation, base }:

2353+ mkDerivation {

2354+ pname = "bool-extras";

2355+ version = "0.4.0";

2356+ sha256 = "008m43f04ncx2c24c241gzwjyyglw8rwpq2gsakqkw0nwz3czs61";

2357+ configureFlags = [

2358+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2359+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2360+ "-fsplitbase" "-f-test-hlint"

2361+ ];

2362+ libraryHaskellDepends = [ base ];

2363+ homepage = "http://tom.lokhorst.eu/bool-extras";

2364+ description = "A fold function for Bool";

2365+ license = stdenv.lib.licenses.bsd3;

2366+ }) {};

2367+ "bound" = callPackage

2368+ ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad

2369+ , directory, doctest, filepath, hashable, hashable-extras

2370+ , prelude-extras, profunctors, transformers, vector

2371+ }:

2372+ mkDerivation {

2373+ pname = "bound";

2374+ version = "1.0.4";

2375+ sha256 = "17qnrjmqhx07cpzwd1z4lp2d42jx1lfxl6b86d65g4fd79miipky";

2376+ configureFlags = [

2377+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2378+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2379+ "-fsplitbase" "-f-test-hlint"

2380+ ];

2381+ libraryHaskellDepends = [

2382+ base bifunctors binary bytes cereal comonad hashable

2383+ hashable-extras prelude-extras profunctors transformers

2384+ ];

2385+ testHaskellDepends = [

2386+ base directory doctest filepath prelude-extras transformers vector

2387+ ];

2388+ homepage = "http://github.com/ekmett/bound/";

2389+ description = "Making de Bruijn Succ Less";

2390+ license = stdenv.lib.licenses.bsd3;

2391+ }) {};

2392+ "bson" = callPackage

2393+ ({ mkDerivation, base, binary, bytestring, cryptohash

2394+ , data-binary-ieee754, mtl, network, QuickCheck, test-framework

2395+ , test-framework-quickcheck2, text, time

2396+ }:

2397+ mkDerivation {

2398+ pname = "bson";

2399+ version = "0.3.1";

2400+ sha256 = "1kihsjws8sqb44gvilh1zxrqn2bml8gxq2bbanxqb7nr4ymwfkiv";

2401+ configureFlags = [

2402+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2403+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2404+ "-fsplitbase" "-f-test-hlint"

2405+ ];

2406+ libraryHaskellDepends = [

2407+ base binary bytestring cryptohash data-binary-ieee754 mtl network

2408+ text time

2409+ ];

2410+ testHaskellDepends = [

2411+ base binary bytestring cryptohash data-binary-ieee754 mtl network

2412+ QuickCheck test-framework test-framework-quickcheck2 text time

2413+ ];

2414+ doHaddock = false;

2415+ doCheck = false;

2416+ homepage = "http://github.com/mongodb-haskell/bson";

2417+ description = "BSON documents are JSON-like objects with a standard binary encoding";

2418+ license = "unknown";

2419+ }) {};

2420+ "bumper" = callPackage

2421+ ({ mkDerivation, base, Cabal, containers, fclabels, process

2422+ , regex-compat, split, strict

2423+ }:

2424+ mkDerivation {

2425+ pname = "bumper";

2426+ version = "0.6.0.2";

2427+ sha256 = "0j8g0dnk3flplkzhaqwbq8qccd89lm8n27qjr3yjz5sl5l6ncqns";

2428+ configureFlags = [

2429+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2430+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2431+ "-fsplitbase" "-f-test-hlint"

2432+ ];

2433+ isLibrary = false;

2434+ isExecutable = true;

2435+ executableHaskellDepends = [

2436+ base Cabal containers fclabels process regex-compat split strict

2437+ ];

2438+ doHaddock = false;

2439+ homepage = "http://github.com/silkapp/bumper";

2440+ description = "Automatically bump package versions, also transitively";

2441+ license = stdenv.lib.licenses.bsd3;

2442+ }) {};

2443+ "byteable" = callPackage

2444+ ({ mkDerivation, base, bytestring }:

2445+ mkDerivation {

2446+ pname = "byteable";

2447+ version = "0.1.1";

2448+ sha256 = "1qizg0kxxjqnd3cbrjhhidk5pbbciz0pb3z5kzikjjxnnnhk8fr4";

2449+ configureFlags = [

2450+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2451+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2452+ "-fsplitbase" "-f-test-hlint"

2453+ ];

2454+ enableSeparateDataOutput = true;

2455+ libraryHaskellDepends = [ base bytestring ];

2456+ homepage = "http://github.com/vincenthz/hs-byteable";

2457+ description = "Type class for sequence of bytes";

2458+ license = stdenv.lib.licenses.bsd3;

2459+ }) {};

2460+ "bytedump" = callPackage

2461+ ({ mkDerivation, base, bytestring }:

2462+ mkDerivation {

2463+ pname = "bytedump";

2464+ version = "1.0";

2465+ sha256 = "1pf01mna3isx3i7m50yz3pw5ygz5sg8i8pshjb3yw8q41w2ba5xf";

2466+ configureFlags = [

2467+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2468+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2469+ "-fsplitbase" "-f-test-hlint"

2470+ ];

2471+ isLibrary = true;

2472+ isExecutable = true;

2473+ enableSeparateDataOutput = true;

2474+ libraryHaskellDepends = [ base bytestring ];

2475+ homepage = "http://github.com/vincenthz/hs-bytedump";

2476+ description = "Flexible byte dump helpers for human readers";

2477+ license = stdenv.lib.licenses.bsd3;

2478+ }) {};

2479+ "byteorder" = callPackage

2480+ ({ mkDerivation, base }:

2481+ mkDerivation {

2482+ pname = "byteorder";

2483+ version = "1.0.4";

2484+ sha256 = "06995paxbxk8lldvarqpb3ygcjbg4v8dk4scib1rjzwlhssvn85x";

2485+ configureFlags = [

2486+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2487+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2488+ "-fsplitbase" "-f-test-hlint"

2489+ ];

2490+ libraryHaskellDepends = [ base ];

2491+ homepage = "http://community.haskell.org/~aslatter/code/byteorder";

2492+ description = "Exposes the native endianness or byte ordering of the system";

2493+ license = stdenv.lib.licenses.bsd3;

2494+ }) {};

2495+ "bytes" = callPackage

2496+ ({ mkDerivation, base, binary, bytestring, cereal, containers

2497+ , directory, doctest, filepath, mtl, text, time, transformers

2498+ , transformers-compat, void

2499+ }:

2500+ mkDerivation {

2501+ pname = "bytes";

2502+ version = "0.14.1.2";

2503+ sha256 = "1v1nnp1m5i4bfr0fshbps163v6yn6var53p0vcvav6g4w5wffd7d";

2504+ revision = "1";

2505+ editedCabalFile = "03336d2vf6ik76vxbd17caiz80l0cshpjr86x319qbkfk0vw413d";

2506+ configureFlags = [

2507+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2508+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2509+ "-fsplitbase" "-f-test-hlint"

2510+ ];

2511+ libraryHaskellDepends = [

2512+ base binary bytestring cereal containers mtl text time transformers

2513+ transformers-compat void

2514+ ];

2515+ testHaskellDepends = [ base directory doctest filepath ];

2516+ homepage = "http://github.com/analytics/bytes";

2517+ description = "Sharing code for serialization between binary and cereal";

2518+ license = stdenv.lib.licenses.bsd3;

2519+ }) {};

2520+ "bytestring-builder" = callPackage

2521+ ({ mkDerivation, base, bytestring, deepseq }:

2522+ mkDerivation {

2523+ pname = "bytestring-builder";

2524+ version = "0.10.4.0.1";

2525+ sha256 = "0iqh6k6dvl75z1m0i1grkr4w5ynxrd6qd7ynjl0bkd39nbwfay90";

2526+ revision = "1";

2527+ editedCabalFile = "16wfq8c3djd50rx8fjc141l55vn03q21viz44h9ni7q5ld2vi111";

2528+ configureFlags = [

2529+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2530+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2531+ "-fsplitbase" "-f-test-hlint"

2532+ ];

2533+ libraryHaskellDepends = [ base bytestring deepseq ];

2534+ doHaddock = false;

2535+ description = "The new bytestring builder, packaged outside of GHC";

2536+ license = stdenv.lib.licenses.bsd3;

2537+ }) {};

2538+ "bytestring-lexing" = callPackage

2539+ ({ mkDerivation, alex, array, base, bytestring }:

2540+ mkDerivation {

2541+ pname = "bytestring-lexing";

2542+ version = "0.4.3.2";

2543+ sha256 = "09ymg1n21668wn4harxg0cqlz98fz990bangpy99w2z7d6cwbc05";

2544+ revision = "1";

2545+ editedCabalFile = "0w9ybkvafgxiiq9sazppxb4pjyqpyv3abzy8isyp3vhxpmc4jzfc";

2546+ configureFlags = [

2547+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2548+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2549+ "-fsplitbase" "-f-test-hlint"

2550+ ];

2551+ libraryHaskellDepends = [ array base bytestring ];

2552+ libraryToolDepends = [ alex ];

2553+ homepage = "http://code.haskell.org/~wren/";

2554+ description = "Parse and produce literals efficiently from strict or lazy bytestrings";

2555+ license = stdenv.lib.licenses.bsd3;

2556+ }) {};

2557+ "bytestring-mmap" = callPackage

2558+ ({ mkDerivation, base, bytestring, unix }:

2559+ mkDerivation {

2560+ pname = "bytestring-mmap";

2561+ version = "0.2.2";

2562+ sha256 = "1bv9xf4cpph1cbdwv6rbmq8ppi5wjpgd97lwln5l9ky5rvnaxg3v";

2563+ configureFlags = [

2564+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2565+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2566+ "-fsplitbase" "-f-test-hlint"

2567+ ];

2568+ libraryHaskellDepends = [ base bytestring unix ];

2569+ homepage = "http://code.haskell.org/~dons/code/bytestring-mmap/";

2570+ description = "mmap support for strict ByteStrings";

2571+ license = stdenv.lib.licenses.bsd3;

2572+ }) {};

2573+ "bytestring-progress" = callPackage

2574+ ({ mkDerivation, base, bytestring, terminal-progress-bar, time }:

2575+ mkDerivation {

2576+ pname = "bytestring-progress";

2577+ version = "1.0.3";

2578+ sha256 = "1v9cl7d4fcchbdrpbgjj4ilg79cj241vzijiifdsgkq30ikv2yxs";

2579+ configureFlags = [

2580+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2581+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2582+ "-fsplitbase" "-f-test-hlint"

2583+ ];

2584+ enableSeparateDataOutput = true;

2585+ libraryHaskellDepends = [

2586+ base bytestring terminal-progress-bar time

2587+ ];

2588+ doHaddock = false;

2589+ doCheck = false;

2590+ homepage = "http://github.com/acw/bytestring-progress";

2591+ description = "A library for tracking the consumption of a lazy ByteString";

2592+ license = stdenv.lib.licenses.bsd3;

2593+ }) {};

2594+ "bytestring-trie" = callPackage

2595+ ({ mkDerivation, base, binary, bytestring }:

2596+ mkDerivation {

2597+ pname = "bytestring-trie";

2598+ version = "0.2.4";

2599+ sha256 = "1fv3xh52hqhzdbq78c3lrgx5vd49cabwp9ww5ki1888zlq29pyck";

2600+ configureFlags = [

2601+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2602+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2603+ "-fsplitbase" "-f-test-hlint"

2604+ ];

2605+ libraryHaskellDepends = [ base binary bytestring ];

2606+ homepage = "http://code.haskell.org/~wren/";

2607+ description = "An efficient finite map from (byte)strings to values";

2608+ license = stdenv.lib.licenses.bsd3;

2609+ }) {};

2610+ "bzlib" = callPackage

2611+ ({ mkDerivation, base, bytestring, bzip2 }:

2612+ mkDerivation {

2613+ pname = "bzlib";

2614+ version = "0.5.0.4";

2615+ sha256 = "1vf37y7wknrihf7hipd6lihkmn7sszbgfb325my52yzbjs3baccd";

2616+ revision = "1";

2617+ editedCabalFile = "1qhw3agyi44dai8b425n279f1fm33kxdg5gys3wvs4vadbxadqln";

2618+ configureFlags = [

2619+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2620+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2621+ "-fsplitbase" "-f-test-hlint"

2622+ ];

2623+ libraryHaskellDepends = [ base bytestring ];

2624+ librarySystemDepends = [ bzip2 ];

2625+ description = "Compression and decompression in the bzip2 format";

2626+ license = stdenv.lib.licenses.bsd3;

2627+ }) {inherit (pkgs) bzip2;};

2628+ "bzlib-conduit" = callPackage

2629+ ({ mkDerivation, base, bindings-DSL, bytestring, bzip2, conduit

2630+ , conduit-extra, data-default, hspec, mtl, QuickCheck, random

2631+ , resourcet

2632+ }:

2633+ mkDerivation {

2634+ pname = "bzlib-conduit";

2635+ version = "0.2.1.3";

2636+ sha256 = "0jqg38zvxc0fpp74az0vm8klb88zwy076ncwzgq2zr0nrmr5cghm";

2637+ configureFlags = [

2638+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2639+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2640+ "-fsplitbase" "-f-test-hlint"

2641+ ];

2642+ enableSeparateDataOutput = true;

2643+ libraryHaskellDepends = [

2644+ base bindings-DSL bytestring conduit conduit-extra data-default mtl

2645+ resourcet

2646+ ];

2647+ librarySystemDepends = [ bzip2 ];

2648+ testHaskellDepends = [

2649+ base bytestring conduit conduit-extra hspec QuickCheck random

2650+ resourcet

2651+ ];

2652+ benchmarkHaskellDepends = [ base conduit conduit-extra ];

2653+ homepage = "https://github.com/snoyberg/bzlib-conduit";

2654+ description = "Streaming compression/decompression via conduits";

2655+ license = stdenv.lib.licenses.bsd3;

2656+ }) {inherit (pkgs) bzip2;};

2657+ "c2hs" = callPackage

2658+ ({ mkDerivation, array, base, containers, directory, dlist

2659+ , filepath, HUnit, language-c, pretty, process, shelly

2660+ , test-framework, test-framework-hunit, text, transformers

2661+ }:

2662+ mkDerivation {

2663+ pname = "c2hs";

2664+ version = "0.20.1";

2665+ sha256 = "1w2w9zxirzjd5lniwqakq59glgsh4mw3565x2l9qrin0bfjxkn3h";

2666+ configureFlags = [

2667+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2668+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2669+ "-fsplitbase" "-f-test-hlint"

2670+ ];

2671+ isLibrary = false;

2672+ isExecutable = true;

2673+ enableSeparateDataOutput = true;

2674+ executableHaskellDepends = [

2675+ array base containers directory dlist filepath language-c pretty

2676+ process

2677+ ];

2678+ testHaskellDepends = [

2679+ base filepath HUnit shelly test-framework test-framework-hunit text

2680+ transformers

2681+ ];

2682+ doHaddock = false;

2683+ doCheck = false;

2684+ homepage = "https://github.com/haskell/c2hs";

2685+ description = "C->Haskell FFI tool that gives some cross-language type safety";

2686+ license = stdenv.lib.licenses.gpl2;

2687+ }) {};

2688+ "cabal-install" = callPackage

2689+ ({ mkDerivation, array, base, bytestring, Cabal, containers

2690+ , directory, filepath, HTTP, HUnit, mtl, network, pretty, process

2691+ , QuickCheck, random, stm, test-framework, test-framework-hunit

2692+ , test-framework-quickcheck2, time, unix, zlib

2693+ }:

2694+ mkDerivation {

2695+ pname = "cabal-install";

2696+ version = "1.18.0.5";

2697+ sha256 = "10hpa85kp24ccrbs02987qd16f89f2hq0wkj7k18nvlifgpzhza7";

2698+ revision = "1";

2699+ editedCabalFile = "15qacj7zzn8d6jnlqhvslgns6q7aq6q50jadlpdj7mhn36mqb7m5";

2700+ configureFlags = [

2701+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2702+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2703+ "-fsplitbase" "-f-test-hlint"

2704+ ];

2705+ isLibrary = false;

2706+ isExecutable = true;

2707+ executableHaskellDepends = [

2708+ array base bytestring Cabal containers directory filepath HTTP mtl

2709+ network pretty process random stm time unix zlib

2710+ ];

2711+ testHaskellDepends = [

2712+ array base bytestring Cabal containers directory filepath HTTP

2713+ HUnit mtl network pretty process QuickCheck stm test-framework

2714+ test-framework-hunit test-framework-quickcheck2 time unix zlib

2715+ ];

2716+ doHaddock = false;

2717+ postInstall = ''

2718+ mkdir $out/etc

2719+ mv bash-completion $out/etc/bash_completion.d

2720+ '';

2721+ homepage = "http://www.haskell.org/cabal/";

2722+ description = "The command-line interface for Cabal and Hackage";

2723+ license = stdenv.lib.licenses.bsd3;

2724+ }) {};

2725+ "cabal-src" = callPackage

2726+ ({ mkDerivation, base, bytestring, conduit, conduit-extra

2727+ , containers, directory, filepath, http-conduit, http-types

2728+ , network, process, resourcet, shelly, system-fileio

2729+ , system-filepath, tar, text, transformers

2730+ }:

2731+ mkDerivation {

2732+ pname = "cabal-src";

2733+ version = "0.2.3";

2734+ sha256 = "0qah1jw5nki9w2vrdgvsv4acl7ny0qawzwy1rav4gmckkwmw7sa0";

2735+ configureFlags = [

2736+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2737+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2738+ "-fsplitbase" "-f-test-hlint"

2739+ ];

2740+ isLibrary = false;

2741+ isExecutable = true;

2742+ executableHaskellDepends = [

2743+ base bytestring conduit conduit-extra containers directory filepath

2744+ http-conduit http-types network process resourcet shelly

2745+ system-fileio system-filepath tar text transformers

2746+ ];

2747+ doHaddock = false;

2748+ homepage = "https://github.com/yesodweb/cabal-src";

2749+ description = "Alternative install procedure to avoid the diamond dependency issue";

2750+ license = stdenv.lib.licenses.bsd3;

2751+ }) {};

2752+ "cairo" = callPackage

2753+ ({ mkDerivation, array, base, bytestring, cairo, gtk2hs-buildtools

2754+ , mtl, text, utf8-string

2755+ }:

2756+ mkDerivation {

2757+ pname = "cairo";

2758+ version = "0.13.0.5";

2759+ sha256 = "0ak6hzfrcyxajx7qybsmd5g26blqb6zxvv8r2a8bnylvm5sdj70r";

2760+ configureFlags = [

2761+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2762+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2763+ "-fsplitbase" "-f-test-hlint"

2764+ ];

2765+ enableSeparateDataOutput = true;

2766+ libraryHaskellDepends = [

2767+ array base bytestring mtl text utf8-string

2768+ ];

2769+ libraryPkgconfigDepends = [ cairo ];

2770+ libraryToolDepends = [ gtk2hs-buildtools ];

2771+ homepage = "http://projects.haskell.org/gtk2hs/";

2772+ description = "Binding to the Cairo library";

2773+ license = stdenv.lib.licenses.bsd3;

2774+ }) {inherit (pkgs) cairo;};

2775+ "case-insensitive" = callPackage

2776+ ({ mkDerivation, base, bytestring, criterion, deepseq, hashable

2777+ , HUnit, test-framework, test-framework-hunit, text

2778+ }:

2779+ mkDerivation {

2780+ pname = "case-insensitive";

2781+ version = "1.2.0.1";

2782+ sha256 = "1hnckzi6yq3332fx4b140lwa9p6x69rlpaw6y1pmldj2h9nsxl6m";

2783+ revision = "1";

2784+ editedCabalFile = "1lzz68kj3yfpn1iq9gif7dvc527y9mx770j90icnxg8a3n8gqnp0";

2785+ configureFlags = [

2786+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2787+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2788+ "-fsplitbase" "-f-test-hlint"

2789+ ];

2790+ libraryHaskellDepends = [ base bytestring deepseq hashable text ];

2791+ testHaskellDepends = [

2792+ base bytestring HUnit test-framework test-framework-hunit text

2793+ ];

2794+ benchmarkHaskellDepends = [ base bytestring criterion deepseq ];

2795+ homepage = "https://github.com/basvandijk/case-insensitive";

2796+ description = "Case insensitive string comparison";

2797+ license = stdenv.lib.licenses.bsd3;

2798+ }) {};

2799+ "cases" = callPackage

2800+ ({ mkDerivation, attoparsec, base, base-prelude, HTF, HUnit

2801+ , loch-th, placeholders, QuickCheck, text

2802+ }:

2803+ mkDerivation {

2804+ pname = "cases";

2805+ version = "0.1.2";

2806+ sha256 = "02m4dlp0l4jd53j1ziq9hkxsj61m74b886ch7vx74n6caz90qnph";

2807+ configureFlags = [

2808+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2809+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2810+ "-fsplitbase" "-f-test-hlint"

2811+ ];

2812+ libraryHaskellDepends = [ attoparsec base-prelude loch-th text ];

2813+ testHaskellDepends = [

2814+ base HTF HUnit loch-th placeholders QuickCheck text

2815+ ];

2816+ doHaddock = false;

2817+ doCheck = false;

2818+ homepage = "https://github.com/nikita-volkov/cases";

2819+ description = "A converter for spinal, snake and camel cases";

2820+ license = stdenv.lib.licenses.mit;

2821+ }) {};

2822+ "cassava" = callPackage

2823+ ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring

2824+ , containers, criterion, deepseq, ghc-prim, HUnit, lazy-csv

2825+ , QuickCheck, test-framework, test-framework-hunit

2826+ , test-framework-quickcheck2, text, unordered-containers, vector

2827+ }:

2828+ mkDerivation {

2829+ pname = "cassava";

2830+ version = "0.4.2.0";

2831+ sha256 = "1v1izdjd4maqrlpm4cf2xpackpjp1i4vg1s7mzq90dwa6r9572x3";

2832+ configureFlags = [

2833+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2834+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2835+ "-fsplitbase" "-f-test-hlint"

2836+ ];

2837+ libraryHaskellDepends = [

2838+ array attoparsec base blaze-builder bytestring containers deepseq

2839+ ghc-prim text unordered-containers vector

2840+ ];

2841+ testHaskellDepends = [

2842+ attoparsec base bytestring HUnit QuickCheck test-framework

2843+ test-framework-hunit test-framework-quickcheck2 text

2844+ unordered-containers vector

2845+ ];

2846+ benchmarkHaskellDepends = [

2847+ base bytestring criterion deepseq lazy-csv text

2848+ unordered-containers vector

2849+ ];

2850+ homepage = "https://github.com/tibbe/cassava";

2851+ description = "A CSV parsing and encoding library";

2852+ license = stdenv.lib.licenses.bsd3;

2853+ }) {};

2854+ "cautious-file" = callPackage

2855+ ({ mkDerivation, base, bytestring, directory, filepath, unix }:

2856+ mkDerivation {

2857+ pname = "cautious-file";

2858+ version = "1.0.2";

2859+ sha256 = "1sw5ngwrarq1lsd4c6v2wdmgbhkkq6kpybb62r8ccm11ddgn3yiq";

2860+ revision = "1";

2861+ editedCabalFile = "14yqf1wljrham5k4i4189h2pdlwgj3v59ff4p346fivdzh234666";

2862+ configureFlags = [

2863+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2864+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2865+ "-fsplitbase" "-f-test-hlint"

2866+ ];

2867+ libraryHaskellDepends = [

2868+ base bytestring directory filepath unix

2869+ ];

2870+ doHaddock = false;

2871+ doCheck = false;

2872+ description = "Ways to write a file cautiously, to reduce the chances of problems such as data loss due to crashes or power failures";

2873+ license = stdenv.lib.licenses.bsd3;

2874+ }) {};

2875+ "cereal" = callPackage

2876+ ({ mkDerivation, array, base, bytestring, containers, ghc-prim }:

2877+ mkDerivation {

2878+ pname = "cereal";

2879+ version = "0.4.1.0";

2880+ sha256 = "0m0iwjf9bds4nwk1rgr19rvjri4kncn37k51l1n9y869r104b8lb";

2881+ configureFlags = [

2882+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2883+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2884+ "-fsplitbase" "-f-test-hlint"

2885+ ];

2886+ libraryHaskellDepends = [

2887+ array base bytestring containers ghc-prim

2888+ ];

2889+ description = "A binary serialization library";

2890+ license = stdenv.lib.licenses.bsd3;

2891+ }) {};

2892+ "cereal-conduit" = callPackage

2893+ ({ mkDerivation, base, bytestring, cereal, conduit, HUnit, mtl

2894+ , resourcet, transformers

2895+ }:

2896+ mkDerivation {

2897+ pname = "cereal-conduit";

2898+ version = "0.7.2.3";

2899+ sha256 = "0s1s8jm25wxj44x44vjz4kz5qblkyjaz7f8rw5i81bzam32afj9s";

2900+ configureFlags = [

2901+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2902+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2903+ "-fsplitbase" "-f-test-hlint"

2904+ ];

2905+ libraryHaskellDepends = [

2906+ base bytestring cereal conduit resourcet transformers

2907+ ];

2908+ testHaskellDepends = [

2909+ base bytestring cereal conduit HUnit mtl resourcet transformers

2910+ ];

2911+ homepage = "https://github.com/snoyberg/conduit";

2912+ description = "Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits";

2913+ license = stdenv.lib.licenses.bsd3;

2914+ }) {};

2915+ "certificate" = callPackage

2916+ ({ mkDerivation, asn1-data, base, bytestring, containers

2917+ , crypto-pubkey-types, cryptohash, directory, filepath, mtl, pem

2918+ , process, time

2919+ }:

2920+ mkDerivation {

2921+ pname = "certificate";

2922+ version = "1.3.9";

2923+ sha256 = "18g5rq7lpxmvmlnz610537w6mix6z6kxjrfj2ylbhkc81r5pn9g6";

2924+ revision = "1";

2925+ editedCabalFile = "1fipx0vmc8kq8k9imnjiffdpng0qjqkzzwr308zgma9l3hx70jvb";

2926+ configureFlags = [

2927+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2928+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2929+ "-fsplitbase" "-f-test-hlint"

2930+ ];

2931+ isLibrary = true;

2932+ isExecutable = true;

2933+ libraryHaskellDepends = [

2934+ asn1-data base bytestring containers crypto-pubkey-types cryptohash

2935+ directory filepath mtl pem process time

2936+ ];

2937+ homepage = "http://github.com/vincenthz/hs-certificate";

2938+ description = "Certificates and Key Reader/Writer";

2939+ license = stdenv.lib.licenses.bsd3;

2940+ }) {};

2941+ "charset" = callPackage

2942+ ({ mkDerivation, array, base, bytestring, containers, semigroups

2943+ , unordered-containers

2944+ }:

2945+ mkDerivation {

2946+ pname = "charset";

2947+ version = "0.3.7";

2948+ sha256 = "1x912dx5650x8ql3ivhpiwmxd6kv7zghark3s8ljvl1g3qr1pxd6";

2949+ configureFlags = [

2950+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2951+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2952+ "-fsplitbase" "-f-test-hlint"

2953+ ];

2954+ libraryHaskellDepends = [

2955+ array base bytestring containers semigroups unordered-containers

2956+ ];

2957+ homepage = "http://github.com/ekmett/charset";

2958+ description = "Fast unicode character sets based on complemented PATRICIA tries";

2959+ license = stdenv.lib.licenses.bsd3;

2960+ }) {};

2961+ "check-email" = callPackage

2962+ ({ mkDerivation, base, bytestring, email-validate, resolv }:

2963+ mkDerivation {

2964+ pname = "check-email";

2965+ version = "1.0";

2966+ sha256 = "1drw8rspdc4a7jw2ql3fi1dcmw56ah5csf2bil6ii8ccq5vsbfyz";

2967+ revision = "1";

2968+ editedCabalFile = "0x8dq8ja9di728b2fcqji655xrp9ckw58ryd02286rg7xrp63y1r";

2969+ configureFlags = [

2970+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2971+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2972+ "-fsplitbase" "-f-test-hlint"

2973+ ];

2974+ libraryHaskellDepends = [ base bytestring email-validate ];

2975+ librarySystemDepends = [ resolv ];

2976+ description = "Confirm whether an email is valid and probably existant";

2977+ license = stdenv.lib.licenses.bsd3;

2978+ }) {resolv = null;};

2979+ "checkers" = callPackage

2980+ ({ mkDerivation, array, base, QuickCheck, random }:

2981+ mkDerivation {

2982+ pname = "checkers";

2983+ version = "0.4.1";

2984+ sha256 = "19ndgbivd07vchsqs6z9iqjl2jldbq7h4skqc9acracd9xyq1vdr";

2985+ configureFlags = [

2986+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2987+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2988+ "-fsplitbase" "-f-test-hlint"

2989+ ];

2990+ libraryHaskellDepends = [ array base QuickCheck random ];

2991+ description = "Check properties on standard classes and data structures";

2992+ license = stdenv.lib.licenses.bsd3;

2993+ }) {};

2994+ "chell" = callPackage

2995+ ({ mkDerivation, ansi-terminal, base, bytestring, options, patience

2996+ , random, template-haskell, text, transformers

2997+ }:

2998+ mkDerivation {

2999+ pname = "chell";

3000+ version = "0.4";

3001+ sha256 = "1hynr7n7wxgc3z6zrc3xrfpiqlh4zfb3kagwwfhqmcamv9d4x0ng";

3002+ revision = "1";

3003+ editedCabalFile = "1gm3mmaqibdd6xzi61pfxb4azx9v97hw96qaqpppbarz5mwkz18l";

3004+ configureFlags = [

3005+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3006+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3007+ "-fsplitbase" "-f-test-hlint"

3008+ ];

3009+ libraryHaskellDepends = [

3010+ ansi-terminal base bytestring options patience random

3011+ template-haskell text transformers

3012+ ];

3013+ homepage = "https://john-millikin.com/software/chell/";

3014+ description = "A simple and intuitive library for automated testing";

3015+ license = stdenv.lib.licenses.mit;

3016+ }) {};

3017+ "chell-quickcheck" = callPackage

3018+ ({ mkDerivation, base, chell, QuickCheck, random }:

3019+ mkDerivation {

3020+ pname = "chell-quickcheck";

3021+ version = "0.2.4";

3022+ sha256 = "0ys6aks97y5h0n8n8dmwx8jrai4bjlnr7n69s259664y694054wd";

3023+ configureFlags = [

3024+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3025+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3026+ "-fsplitbase" "-f-test-hlint"

3027+ ];

3028+ libraryHaskellDepends = [ base chell QuickCheck random ];

3029+ homepage = "https://john-millikin.com/software/chell/";

3030+ description = "QuickCheck support for the Chell testing library";

3031+ license = stdenv.lib.licenses.mit;

3032+ }) {};

3033+ "chunked-data" = callPackage

3034+ ({ mkDerivation, base, blaze-builder, bytestring, containers

3035+ , mono-traversable, semigroups, system-filepath, text, transformers

3036+ , vector

3037+ }:

3038+ mkDerivation {

3039+ pname = "chunked-data";

3040+ version = "0.1.0.1";

3041+ sha256 = "0kdq79mxi9nhy3dqw283f5ffx4rxwfrdq9cfw46ql5wmqrg2qw7r";

3042+ revision = "1";

3043+ editedCabalFile = "179m2da2b8q08cqnryrsviawc7d5ml67rah0pa9wmnbpwdpq0ynj";

3044+ configureFlags = [

3045+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3046+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3047+ "-fsplitbase" "-f-test-hlint"

3048+ ];

3049+ libraryHaskellDepends = [

3050+ base blaze-builder bytestring containers mono-traversable

3051+ semigroups system-filepath text transformers vector

3052+ ];

3053+ homepage = "https://github.com/fpco/chunked-data";

3054+ description = "Typeclasses for dealing with various chunked data representations";

3055+ license = stdenv.lib.licenses.mit;

3056+ }) {};

3057+ "cipher-aes" = callPackage

3058+ ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests

3059+ , crypto-cipher-types, QuickCheck, securemem, test-framework

3060+ , test-framework-quickcheck2

3061+ }:

3062+ mkDerivation {

3063+ pname = "cipher-aes";

3064+ version = "0.2.9";

3065+ sha256 = "1nkrh8mrrh14zfhjz0lfidw0hw9c70hap9w24rvb14zgfnnasnlq";

3066+ configureFlags = [

3067+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3068+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3069+ "-fsplitbase" "-f-test-hlint"

3070+ ];

3071+ libraryHaskellDepends = [

3072+ base byteable bytestring crypto-cipher-types securemem

3073+ ];

3074+ testHaskellDepends = [

3075+ base byteable bytestring crypto-cipher-tests crypto-cipher-types

3076+ QuickCheck test-framework test-framework-quickcheck2

3077+ ];

3078+ homepage = "http://github.com/vincenthz/hs-cipher-aes";

3079+ description = "Fast AES cipher implementation with advanced mode of operations";

3080+ license = stdenv.lib.licenses.bsd3;

3081+ }) {};

3082+ "cipher-blowfish" = callPackage

3083+ ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests

3084+ , crypto-cipher-types, QuickCheck, securemem, test-framework

3085+ , test-framework-quickcheck2, vector

3086+ }:

3087+ mkDerivation {

3088+ pname = "cipher-blowfish";

3089+ version = "0.0.3";

3090+ sha256 = "0hb67gmiyqrknynz5am8nada1b1v47rqla87dw5nvfhxhl51fhcg";

3091+ configureFlags = [

3092+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3093+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3094+ "-fsplitbase" "-f-test-hlint"

3095+ ];

3096+ libraryHaskellDepends = [

3097+ base byteable bytestring crypto-cipher-types securemem vector

3098+ ];

3099+ testHaskellDepends = [

3100+ base byteable bytestring crypto-cipher-tests crypto-cipher-types

3101+ QuickCheck test-framework test-framework-quickcheck2

3102+ ];

3103+ homepage = "http://github.com/vincenthz/hs-crypto-cipher";

3104+ description = "Blowfish cipher";

3105+ license = stdenv.lib.licenses.bsd3;

3106+ }) {};

3107+ "cipher-camellia" = callPackage

3108+ ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests

3109+ , crypto-cipher-types, QuickCheck, securemem, test-framework

3110+ , test-framework-quickcheck2, vector

3111+ }:

3112+ mkDerivation {

3113+ pname = "cipher-camellia";

3114+ version = "0.0.2";

3115+ sha256 = "19z2mi1rvp8fsqjdbmrm1hdlxmx61yr55fyknmmn945qrlvx234d";

3116+ configureFlags = [

3117+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3118+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3119+ "-fsplitbase" "-f-test-hlint"

3120+ ];

3121+ libraryHaskellDepends = [

3122+ base byteable bytestring crypto-cipher-types securemem vector

3123+ ];

3124+ testHaskellDepends = [

3125+ base byteable bytestring crypto-cipher-tests crypto-cipher-types

3126+ QuickCheck test-framework test-framework-quickcheck2

3127+ ];

3128+ homepage = "http://github.com/vincenthz/hs-crypto-cipher";

3129+ description = "Camellia block cipher primitives";

3130+ license = stdenv.lib.licenses.bsd3;

3131+ }) {};

3132+ "cipher-des" = callPackage

3133+ ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests

3134+ , crypto-cipher-types, QuickCheck, securemem, test-framework

3135+ , test-framework-quickcheck2

3136+ }:

3137+ mkDerivation {

3138+ pname = "cipher-des";

3139+ version = "0.0.6";

3140+ sha256 = "1isazxa2nr1y13y0danfk7wghy34rfpn3f43rw714nk2xk6vrwc5";

3141+ configureFlags = [

3142+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3143+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3144+ "-fsplitbase" "-f-test-hlint"

3145+ ];

3146+ libraryHaskellDepends = [

3147+ base byteable bytestring crypto-cipher-types securemem

3148+ ];

3149+ testHaskellDepends = [

3150+ base byteable bytestring crypto-cipher-tests crypto-cipher-types

3151+ QuickCheck test-framework test-framework-quickcheck2

3152+ ];

3153+ homepage = "http://github.com/vincenthz/hs-crypto-cipher";

3154+ description = "DES and 3DES primitives";

3155+ license = stdenv.lib.licenses.bsd3;

3156+ }) {};

3157+ "cipher-rc4" = callPackage

3158+ ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests

3159+ , crypto-cipher-types, QuickCheck, test-framework

3160+ , test-framework-quickcheck2

3161+ }:

3162+ mkDerivation {

3163+ pname = "cipher-rc4";

3164+ version = "0.1.4";

3165+ sha256 = "0k9qf0cn5yxc4qlqikcm5yyrnkkvr6g3v7306cp8iwz7r4dp6zn6";

3166+ configureFlags = [

3167+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3168+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3169+ "-fsplitbase" "-f-test-hlint"

3170+ ];

3171+ libraryHaskellDepends = [

3172+ base byteable bytestring crypto-cipher-types

3173+ ];

3174+ testHaskellDepends = [

3175+ base bytestring crypto-cipher-tests crypto-cipher-types QuickCheck

3176+ test-framework test-framework-quickcheck2

3177+ ];

3178+ homepage = "http://github.com/vincenthz/hs-cipher-rc4";

3179+ description = "Fast RC4 cipher implementation";

3180+ license = stdenv.lib.licenses.bsd3;

3181+ }) {};

3182+ "circle-packing" = callPackage

3183+ ({ mkDerivation, base }:

3184+ mkDerivation {

3185+ pname = "circle-packing";

3186+ version = "0.1.0.3";

3187+ sha256 = "1df284n181ny3i7ajx0j6x5grxw404zzz6y8iybmh5qgba1537g2";

3188+ configureFlags = [

3189+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3190+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3191+ "-fsplitbase" "-f-test-hlint"

3192+ ];

3193+ libraryHaskellDepends = [ base ];

3194+ description = "Simple heuristic for packing discs of varying radii in a circle";

3195+ license = stdenv.lib.licenses.bsd3;

3196+ }) {};

3197+ "classy-prelude" = callPackage

3198+ ({ mkDerivation, base, basic-prelude, bifunctors, bytestring

3199+ , chunked-data, containers, enclosed-exceptions, exceptions

3200+ , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl

3201+ , old-locale, primitive, QuickCheck, semigroups, stm

3202+ , system-filepath, text, time, transformers, unordered-containers

3203+ , vector, vector-instances

3204+ }:

3205+ mkDerivation {

3206+ pname = "classy-prelude";

3207+ version = "0.10.2";

3208+ sha256 = "0pq16rgksbv2ml4wg7jdxlb9y80h8la78hnrcci637s6kbdisd7k";

3209+ revision = "1";

3210+ editedCabalFile = "0af2qnr4kn1bfmshyxwd4ib53mz5phvqgb5zhv54hrkr2z6sn1c2";

3211+ configureFlags = [

3212+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3213+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3214+ "-fsplitbase" "-f-test-hlint"

3215+ ];

3216+ libraryHaskellDepends = [

3217+ base basic-prelude bifunctors bytestring chunked-data containers

3218+ enclosed-exceptions exceptions ghc-prim hashable lifted-base

3219+ mono-traversable mtl old-locale primitive semigroups stm

3220+ system-filepath text time transformers unordered-containers vector

3221+ vector-instances

3222+ ];

3223+ testHaskellDepends = [

3224+ base containers hspec QuickCheck transformers unordered-containers

3225+ ];

3226+ homepage = "https://github.com/snoyberg/classy-prelude";

3227+ description = "A typeclass-based Prelude";

3228+ license = stdenv.lib.licenses.mit;

3229+ }) {};

3230+ "classy-prelude-conduit" = callPackage

3231+ ({ mkDerivation, base, bytestring, classy-prelude, conduit

3232+ , conduit-combinators, hspec, monad-control, QuickCheck, resourcet

3233+ , system-fileio, transformers, void

3234+ }:

3235+ mkDerivation {

3236+ pname = "classy-prelude-conduit";

3237+ version = "0.10.2";

3238+ sha256 = "0bgic61p05hpnsami199wzs2q4cbdm00nyp03vsxz2ddsz8dwc8l";

3239+ configureFlags = [

3240+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3241+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3242+ "-fsplitbase" "-f-test-hlint"

3243+ ];

3244+ libraryHaskellDepends = [

3245+ base bytestring classy-prelude conduit conduit-combinators

3246+ monad-control resourcet system-fileio transformers void

3247+ ];

3248+ testHaskellDepends = [

3249+ base bytestring conduit hspec QuickCheck transformers

3250+ ];

3251+ homepage = "https://github.com/snoyberg/classy-prelude";

3252+ description = "conduit instances for classy-prelude";

3253+ license = stdenv.lib.licenses.mit;

3254+ }) {};

3255+ "classy-prelude-yesod" = callPackage

3256+ ({ mkDerivation, aeson, base, classy-prelude

3257+ , classy-prelude-conduit, data-default, http-conduit, http-types

3258+ , persistent, yesod, yesod-newsfeed, yesod-static

3259+ }:

3260+ mkDerivation {

3261+ pname = "classy-prelude-yesod";

3262+ version = "0.10.2";

3263+ sha256 = "1jzf26rj9m8mdhhag66h5zbh91c7ff3jn1q1ghmah12dj9y06137";

3264+ configureFlags = [

3265+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3266+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3267+ "-fsplitbase" "-f-test-hlint"

3268+ ];

3269+ libraryHaskellDepends = [

3270+ aeson base classy-prelude classy-prelude-conduit data-default

3271+ http-conduit http-types persistent yesod yesod-newsfeed

3272+ yesod-static

3273+ ];

3274+ homepage = "https://github.com/snoyberg/classy-prelude";

3275+ description = "Provide a classy prelude including common Yesod functionality";

3276+ license = stdenv.lib.licenses.mit;

3277+ }) {};

3278+ "clientsession" = callPackage

3279+ ({ mkDerivation, base, base64-bytestring, bytestring, cereal

3280+ , cipher-aes, containers, cprng-aes, crypto-api, crypto-random

3281+ , directory, entropy, hspec, HUnit, QuickCheck, setenv, skein

3282+ , tagged, transformers

3283+ }:

3284+ mkDerivation {

3285+ pname = "clientsession";

3286+ version = "0.9.1.1";

3287+ sha256 = "08h0461ydhfymw2pya472n81kx5rqp7awfgxlbz2r851rl5kqmn9";

3288+ configureFlags = [

3289+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3290+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3291+ "-fsplitbase" "-f-test-hlint"

3292+ ];

3293+ isLibrary = true;

3294+ isExecutable = true;

3295+ libraryHaskellDepends = [

3296+ base base64-bytestring bytestring cereal cipher-aes cprng-aes

3297+ crypto-api crypto-random directory entropy setenv skein tagged

3298+ ];

3299+ executableHaskellDepends = [ base ];

3300+ testHaskellDepends = [

3301+ base bytestring cereal containers hspec HUnit QuickCheck

3302+ transformers

3303+ ];

3304+ homepage = "http://github.com/yesodweb/clientsession/tree/master";

3305+ description = "Securely store session data in a client-side cookie";

3306+ license = stdenv.lib.licenses.bsd3;

3307+ }) {};

3308+ "clock" = callPackage

3309+ ({ mkDerivation, base }:

3310+ mkDerivation {

3311+ pname = "clock";

3312+ version = "0.4.1.3";

3313+ sha256 = "0wqhg8gb10lby01f0v4fl4yp23l4ilizywp5xnsbja03svnb4f0d";

3314+ revision = "1";

3315+ editedCabalFile = "0h04y3qyqz6fc6zw7myyyy9ib4l6ys1lyq216awkzwl4rfgxcgv5";

3316+ configureFlags = [

3317+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3318+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3319+ "-fsplitbase" "-f-test-hlint"

3320+ ];

3321+ libraryHaskellDepends = [ base ];

3322+ homepage = "http://corsis.github.com/clock/";

3323+ description = "High-resolution clock functions: monotonic, realtime, cputime";

3324+ license = stdenv.lib.licenses.bsd3;

3325+ }) {};

3326+ "cmdargs" = callPackage

3327+ ({ mkDerivation, base, filepath, process, template-haskell

3328+ , transformers

3329+ }:

3330+ mkDerivation {

3331+ pname = "cmdargs";

3332+ version = "0.10.12";

3333+ sha256 = "0axn3ycw4rijh1ka5f73gz9w330s851cpxbv39ia4xnb0l95hrjy";

3334+ revision = "1";

3335+ editedCabalFile = "1p74npr3qy8hcslj1jai3bdjrxar0hfqm4vpbzcsrjvw6gk94z73";

3336+ configureFlags = [

3337+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3338+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3339+ "-fsplitbase" "-f-test-hlint"

3340+ ];

3341+ isLibrary = true;

3342+ isExecutable = true;

3343+ libraryHaskellDepends = [

3344+ base filepath process template-haskell transformers

3345+ ];

3346+ homepage = "http://community.haskell.org/~ndm/cmdargs/";

3347+ description = "Command line argument processing";

3348+ license = stdenv.lib.licenses.bsd3;

3349+ }) {};

3350+ "code-builder" = callPackage

3351+ ({ mkDerivation, base, containers }:

3352+ mkDerivation {

3353+ pname = "code-builder";

3354+ version = "0.1.3";

3355+ sha256 = "1ax4c19xkszahcxvwc1wa1hrgk6ajck5sbprbplsi1gc9jj4g7jm";

3356+ configureFlags = [

3357+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3358+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3359+ "-fsplitbase" "-f-test-hlint"

3360+ ];

3361+ libraryHaskellDepends = [ base containers ];

3362+ description = "Simple system for generating code";

3363+ license = stdenv.lib.licenses.bsd3;

3364+ }) {};

3365+ "colour" = callPackage

3366+ ({ mkDerivation, base }:

3367+ mkDerivation {

3368+ pname = "colour";

3369+ version = "2.3.3";

3370+ sha256 = "1qmn1778xzg07jg9nx4k1spdz2llivpblf6wwrps1qpqjhsac5cd";

3371+ configureFlags = [

3372+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3373+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3374+ "-fsplitbase" "-f-test-hlint"

3375+ ];

3376+ enableSeparateDataOutput = true;

3377+ libraryHaskellDepends = [ base ];

3378+ homepage = "http://www.haskell.org/haskellwiki/Colour";

3379+ description = "A model for human colour/color perception";

3380+ license = stdenv.lib.licenses.mit;

3381+ }) {};

3382+ "comonad" = callPackage

3383+ ({ mkDerivation, base, containers, contravariant, directory

3384+ , distributive, doctest, filepath, semigroups, tagged, transformers

3385+ , transformers-compat

3386+ }:

3387+ mkDerivation {

3388+ pname = "comonad";

3389+ version = "4.2.2";

3390+ sha256 = "022fcy0ijwsdnjb1b1jrwy2ypzzbzvfgj9ns0c74hrsj08gjh8j8";

3391+ configureFlags = [

3392+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3393+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3394+ "-fsplitbase" "-f-test-hlint"

3395+ ];

3396+ libraryHaskellDepends = [

3397+ base containers contravariant distributive semigroups tagged

3398+ transformers transformers-compat

3399+ ];

3400+ testHaskellDepends = [ base directory doctest filepath ];

3401+ homepage = "http://github.com/ekmett/comonad/";

3402+ description = "Comonads";

3403+ license = stdenv.lib.licenses.bsd3;

3404+ }) {};

3405+ "comonad-transformers" = callPackage

3406+ ({ mkDerivation, base, comonad }:

3407+ mkDerivation {

3408+ pname = "comonad-transformers";

3409+ version = "4.0";

3410+ sha256 = "13zzp6r6s6c80skniphwvzxhpazbyal5854m53139kgcw560rv6z";

3411+ configureFlags = [

3412+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3413+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3414+ "-fsplitbase" "-f-test-hlint"

3415+ ];

3416+ libraryHaskellDepends = [ base comonad ];

3417+ doHaddock = false;

3418+ doCheck = false;

3419+ homepage = "http://github.com/ekmett/comonad-transformers/";

3420+ description = "This package has been merged into comonad 4.0";

3421+ license = stdenv.lib.licenses.bsd3;

3422+ }) {};

3423+ "comonads-fd" = callPackage

3424+ ({ mkDerivation, base, comonad }:

3425+ mkDerivation {

3426+ pname = "comonads-fd";

3427+ version = "4.0";

3428+ sha256 = "19xpv0dsz7w3a1sq1gdxwzglfal45vj2s22zb12g9mpk5rp3hw1s";

3429+ configureFlags = [

3430+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3431+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3432+ "-fsplitbase" "-f-test-hlint"

3433+ ];

3434+ libraryHaskellDepends = [ base comonad ];

3435+ doHaddock = false;

3436+ doCheck = false;

3437+ homepage = "http://github.com/ekmett/comonads-fd/";

3438+ description = "This package has been merged into comonad 4.0";

3439+ license = stdenv.lib.licenses.bsd3;

3440+ }) {};

3441+ "compdata" = callPackage

3442+ ({ mkDerivation, base, containers, criterion, deepseq, derive, mtl

3443+ , QuickCheck, random, template-haskell, th-expand-syns

3444+ , transformers, tree-view, uniplate

3445+ }:

3446+ mkDerivation {

3447+ pname = "compdata";

3448+ version = "0.9";

3449+ sha256 = "1wk9vj834l3fc64fcsrgc9hz5f2z7461hs8lv1ldkfsixx4mxyqc";

3450+ configureFlags = [

3451+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3452+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3453+ "-fsplitbase" "-f-test-hlint"

3454+ ];

3455+ libraryHaskellDepends = [

3456+ base containers deepseq derive mtl QuickCheck template-haskell

3457+ th-expand-syns transformers tree-view

3458+ ];

3459+ benchmarkHaskellDepends = [

3460+ base containers criterion deepseq derive mtl QuickCheck random

3461+ template-haskell th-expand-syns transformers uniplate

3462+ ];

3463+ doCheck = false;

3464+ description = "Compositional Data Types";

3465+ license = stdenv.lib.licenses.bsd3;

3466+ }) {};

3467+ "compensated" = callPackage

3468+ ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad

3469+ , deepseq, directory, distributive, doctest, filepath

3470+ , generic-deriving, hashable, lens, log-domain, safecopy

3471+ , semigroupoids, semigroups, simple-reflect, vector

3472+ }:

3473+ mkDerivation {

3474+ pname = "compensated";

3475+ version = "0.6.1";

3476+ sha256 = "026gq3ppk3id4bvkn3pdg6ljbl14gd8p4hg6i0rc13138b0mlxnh";

3477+ configureFlags = [

3478+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3479+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3480+ "-fsplitbase" "-f-test-hlint"

3481+ ];

3482+ libraryHaskellDepends = [

3483+ base bifunctors binary bytes cereal comonad deepseq distributive

3484+ generic-deriving hashable lens log-domain safecopy semigroupoids

3485+ semigroups vector

3486+ ];

3487+ testHaskellDepends = [

3488+ base directory doctest filepath generic-deriving semigroups

3489+ simple-reflect

3490+ ];

3491+ homepage = "http://github.com/analytics/compensated/";

3492+ description = "Compensated floating-point arithmetic";

3493+ license = stdenv.lib.licenses.bsd3;

3494+ }) {};

3495+ "composition" = callPackage

3496+ ({ mkDerivation }:

3497+ mkDerivation {

3498+ pname = "composition";

3499+ version = "1.0.1.0";

3500+ sha256 = "1gx27vz2djiiwygcjaygjmiwjnls084b5v9km3jpimlz312qh5hc";

3501+ configureFlags = [

3502+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3503+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3504+ "-fsplitbase" "-f-test-hlint"

3505+ ];

3506+ homepage = "http://patch-tag.com/r/DanBurton/composition/home";

3507+ description = "Combinators for unorthodox function composition";

3508+ license = stdenv.lib.licenses.bsd3;

3509+ }) {};

3510+ "compressed" = callPackage

3511+ ({ mkDerivation, base, comonad, containers, fingertree, hashable

3512+ , keys, pointed, reducers, semigroupoids, semigroups

3513+ , unordered-containers

3514+ }:

3515+ mkDerivation {

3516+ pname = "compressed";

3517+ version = "3.10";

3518+ sha256 = "1y290n421knfh8k8zbcabhw24hb13xj9pkxx4h4v15yji97p5mcw";

3519+ revision = "1";

3520+ editedCabalFile = "1fv1ix8bsqbsrzp44i7nz0wp1dwi3l2wdvqvp46a8vbakp5nif8a";

3521+ configureFlags = [

3522+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3523+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3524+ "-fsplitbase" "-f-test-hlint"

3525+ ];

3526+ libraryHaskellDepends = [

3527+ base comonad containers fingertree hashable keys pointed reducers

3528+ semigroupoids semigroups unordered-containers

3529+ ];

3530+ homepage = "http://github.com/ekmett/compressed/";

3531+ description = "Compressed containers and reducers";

3532+ license = stdenv.lib.licenses.bsd3;

3533+ }) {};

3534+ "concatenative" = callPackage

3535+ ({ mkDerivation, base, template-haskell }:

3536+ mkDerivation {

3537+ pname = "concatenative";

3538+ version = "1.0.1";

3539+ sha256 = "05xwqvcdnk8bsyj698ab9jxpa1nk23pf3m7wi9mwmw0q8n99fngd";

3540+ configureFlags = [

3541+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3542+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3543+ "-fsplitbase" "-f-test-hlint"

3544+ ];

3545+ libraryHaskellDepends = [ base template-haskell ];

3546+ homepage = "https://patch-tag.com/r/salazar/concatenative/snapshot/current/content/pretty";

3547+ description = "A library for postfix control flow";

3548+ license = stdenv.lib.licenses.bsd3;

3549+ }) {};

3550+ "concurrent-extra" = callPackage

3551+ ({ mkDerivation, async, base, base-unicode-symbols, HUnit, random

3552+ , stm, test-framework, test-framework-hunit, unbounded-delays

3553+ }:

3554+ mkDerivation {

3555+ pname = "concurrent-extra";

3556+ version = "0.7.0.8";

3557+ sha256 = "0q6n7wlakvnvfrjr3zmxbn9i0dxq96071j565vffp0r5abxkn83q";

3558+ configureFlags = [

3559+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3560+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3561+ "-fsplitbase" "-f-test-hlint"

3562+ ];

3563+ libraryHaskellDepends = [

3564+ base base-unicode-symbols stm unbounded-delays

3565+ ];

3566+ testHaskellDepends = [

3567+ async base base-unicode-symbols HUnit random stm test-framework

3568+ test-framework-hunit unbounded-delays

3569+ ];

3570+ doHaddock = false;

3571+ doCheck = false;

3572+ homepage = "https://github.com/basvandijk/concurrent-extra";

3573+ description = "Extra concurrency primitives";

3574+ license = stdenv.lib.licenses.bsd3;

3575+ }) {};

3576+ "concurrent-supply" = callPackage

3577+ ({ mkDerivation, base, containers, ghc-prim, hashable }:

3578+ mkDerivation {

3579+ pname = "concurrent-supply";

3580+ version = "0.1.7";

3581+ sha256 = "0crg4rm5wibw9h6lmsi43d280xg1xr9xbgqr9s4inxq7x0yyn68c";

3582+ configureFlags = [

3583+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3584+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3585+ "-fsplitbase" "-f-test-hlint"

3586+ ];

3587+ libraryHaskellDepends = [ base ghc-prim hashable ];

3588+ testHaskellDepends = [ base containers ];

3589+ homepage = "http://github.com/ekmett/concurrent-supply/";

3590+ description = "A fast concurrent unique identifier supply with a pure API";

3591+ license = stdenv.lib.licenses.bsd3;

3592+ }) {};

3593+ "cond" = callPackage

3594+ ({ mkDerivation, base }:

3595+ mkDerivation {

3596+ pname = "cond";

3597+ version = "0.4.1.1";

3598+ sha256 = "12xcjxli1scd4asr4zc77i5q9qka2100gx97hv3vv12l7gj7d703";

3599+ configureFlags = [

3600+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3601+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3602+ "-fsplitbase" "-f-test-hlint"

3603+ ];

3604+ libraryHaskellDepends = [ base ];

3605+ homepage = "https://github.com/kallisti-dev/cond";

3606+ description = "Basic conditional and boolean operators with monadic variants";

3607+ license = stdenv.lib.licenses.bsd3;

3608+ }) {};

3609+ "conduit" = callPackage

3610+ ({ mkDerivation, base, containers, criterion, deepseq, exceptions

3611+ , hspec, kan-extensions, lifted-base, mmorph, monad-control, mtl

3612+ , mwc-random, QuickCheck, resourcet, safe, transformers

3613+ , transformers-base, vector, void

3614+ }:

3615+ mkDerivation {

3616+ pname = "conduit";

3617+ version = "1.2.3";

3618+ sha256 = "1n4cc5mij9q5wrnm394a2dka7vbnnr9c2kg5d3f4sl1fh156lf6n";

3619+ configureFlags = [

3620+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3621+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3622+ "-fsplitbase" "-f-test-hlint"

3623+ ];

3624+ libraryHaskellDepends = [

3625+ base containers exceptions lifted-base mmorph monad-control mtl

3626+ resourcet transformers transformers-base void

3627+ ];

3628+ testHaskellDepends = [

3629+ base containers exceptions hspec mtl QuickCheck resourcet safe

3630+ transformers void

3631+ ];

3632+ benchmarkHaskellDepends = [

3633+ base containers criterion deepseq hspec kan-extensions mwc-random

3634+ transformers vector

3635+ ];

3636+ homepage = "http://github.com/snoyberg/conduit";

3637+ description = "Streaming data processing library";

3638+ license = stdenv.lib.licenses.mit;

3639+ }) {};

3640+ "conduit-combinators" = callPackage

3641+ ({ mkDerivation, base, base16-bytestring, base64-bytestring

3642+ , bytestring, chunked-data, conduit, conduit-extra, containers

3643+ , directory, hspec, monad-control, mono-traversable, mtl

3644+ , mwc-random, primitive, QuickCheck, resourcet, safe, silently

3645+ , system-fileio, system-filepath, text, transformers

3646+ , transformers-base, unix, unix-compat, vector, void

3647+ }:

3648+ mkDerivation {

3649+ pname = "conduit-combinators";

3650+ version = "0.3.0.4";

3651+ sha256 = "1aphk79r3ibpb9gykdnz55isp7kf48jhz4h4vgplb0ndbmz8f8zm";

3652+ configureFlags = [

3653+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3654+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3655+ "-fsplitbase" "-f-test-hlint"

3656+ ];

3657+ libraryHaskellDepends = [

3658+ base base16-bytestring base64-bytestring bytestring chunked-data

3659+ conduit conduit-extra monad-control mono-traversable mwc-random

3660+ primitive resourcet system-fileio system-filepath text transformers

3661+ transformers-base unix unix-compat vector void

3662+ ];

3663+ testHaskellDepends = [

3664+ base base16-bytestring base64-bytestring bytestring chunked-data

3665+ conduit containers directory hspec mono-traversable mtl mwc-random

3666+ QuickCheck safe silently system-filepath text transformers vector

3667+ ];

3668+ homepage = "https://github.com/fpco/conduit-combinators";

3669+ description = "Commonly used conduit functions, for both chunked and unchunked data";

3670+ license = stdenv.lib.licenses.mit;

3671+ }) {};

3672+ "conduit-extra" = callPackage

3673+ ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring

3674+ , bytestring-builder, conduit, criterion, directory, exceptions

3675+ , filepath, hspec, monad-control, network, primitive, process

3676+ , resourcet, stm, streaming-commons, text, transformers

3677+ , transformers-base

3678+ }:

3679+ mkDerivation {

3680+ pname = "conduit-extra";

3681+ version = "1.1.5";

3682+ sha256 = "1i38n3pdibjpi9kg37wvv4m6krfbsdd4baik804ss2ml1ry7gm4p";

3683+ revision = "1";

3684+ editedCabalFile = "1jqj8w47y6dx5ky8rb9am4d1c161pmazf2kmas5iv0mldxd865ha";

3685+ configureFlags = [

3686+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3687+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3688+ "-fsplitbase" "-f-test-hlint"

3689+ ];

3690+ libraryHaskellDepends = [

3691+ attoparsec base blaze-builder bytestring conduit directory filepath

3692+ monad-control network primitive process resourcet stm

3693+ streaming-commons text transformers transformers-base

3694+ ];

3695+ testHaskellDepends = [

3696+ async attoparsec base blaze-builder bytestring conduit exceptions

3697+ hspec process resourcet stm text transformers transformers-base

3698+ ];

3699+ benchmarkHaskellDepends = [

3700+ base blaze-builder bytestring bytestring-builder conduit criterion

3701+ transformers

3702+ ];

3703+ homepage = "http://github.com/snoyberg/conduit";

3704+ description = "Batteries included conduit: adapters for common libraries";

3705+ license = stdenv.lib.licenses.mit;

3706+ }) {};

3707+ "configurator" = callPackage

3708+ ({ mkDerivation, attoparsec, base, bytestring, directory, filepath

3709+ , hashable, HUnit, test-framework, test-framework-hunit, text

3710+ , unix-compat, unordered-containers

3711+ }:

3712+ mkDerivation {

3713+ pname = "configurator";

3714+ version = "0.3.0.0";

3715+ sha256 = "1d1iq1knwiq6ia5g64rw5hqm6dakz912qj13r89737rfcxmrkfbf";

3716+ configureFlags = [

3717+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3718+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3719+ "-fsplitbase" "-f-test-hlint"

3720+ ];

3721+ enableSeparateDataOutput = true;

3722+ libraryHaskellDepends = [

3723+ attoparsec base bytestring directory hashable text unix-compat

3724+ unordered-containers

3725+ ];

3726+ testHaskellDepends = [

3727+ base bytestring directory filepath HUnit test-framework

3728+ test-framework-hunit text

3729+ ];

3730+ homepage = "http://github.com/bos/configurator";

3731+ description = "Configuration management";

3732+ license = stdenv.lib.licenses.bsd3;

3733+ }) {};

3734+ "connection" = callPackage

3735+ ({ mkDerivation, base, bytestring, containers, cprng-aes

3736+ , data-default-class, network, socks, tls, x509, x509-store

3737+ , x509-system, x509-validation

3738+ }:

3739+ mkDerivation {

3740+ pname = "connection";

3741+ version = "0.2.3";

3742+ sha256 = "02mqn19pssdak82jw38p3cbwjyfvmjc6fawgx5981hzbdgb64vsb";

3743+ revision = "1";

3744+ editedCabalFile = "0qhkqzw59009m0mdgwr8yx9np63dk7p0n62yviyj3snhbj9plp2g";

3745+ configureFlags = [

3746+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3747+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3748+ "-fsplitbase" "-f-test-hlint"

3749+ ];

3750+ libraryHaskellDepends = [

3751+ base bytestring containers cprng-aes data-default-class network

3752+ socks tls x509 x509-store x509-system x509-validation

3753+ ];

3754+ homepage = "http://github.com/vincenthz/hs-connection";

3755+ description = "Simple and easy network connections API";

3756+ license = stdenv.lib.licenses.bsd3;

3757+ }) {};

3758+ "constraints" = callPackage

3759+ ({ mkDerivation, base, ghc-prim, newtype }:

3760+ mkDerivation {

3761+ pname = "constraints";

3762+ version = "0.4";

3763+ sha256 = "0nnplylzbcw884jgsd4i46z75dkiyx4166j5fym5zdnwhyj75sp5";

3764+ revision = "2";

3765+ editedCabalFile = "0gq7gh0yl2bvh5jda30rjpy30aqy9n17mq9g1nlhh6is57i846i7";

3766+ configureFlags = [

3767+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3768+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3769+ "-fsplitbase" "-f-test-hlint"

3770+ ];

3771+ libraryHaskellDepends = [ base ghc-prim newtype ];

3772+ homepage = "http://github.com/ekmett/constraints/";

3773+ description = "Constraint manipulation";

3774+ license = stdenv.lib.licenses.bsd3;

3775+ }) {};

3776+ "containers-unicode-symbols" = callPackage

3777+ ({ mkDerivation, base, base-unicode-symbols, containers }:

3778+ mkDerivation {

3779+ pname = "containers-unicode-symbols";

3780+ version = "0.3.1.1";

3781+ sha256 = "0ccv7rqkykfk5wmr73mc0kwrnwyzakgp5x495dgwn5nila3g4ma6";

3782+ configureFlags = [

3783+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3784+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3785+ "-fsplitbase" "-f-test-hlint"

3786+ ];

3787+ libraryHaskellDepends = [ base base-unicode-symbols containers ];

3788+ homepage = "http://haskell.org/haskellwiki/Unicode-symbols";

3789+ description = "Unicode alternatives for common functions and operators";

3790+ license = stdenv.lib.licenses.bsd3;

3791+ }) {};

3792+ "contravariant" = callPackage

3793+ ({ mkDerivation, base, semigroups, transformers

3794+ , transformers-compat, void

3795+ }:

3796+ mkDerivation {

3797+ pname = "contravariant";

3798+ version = "1.2";

3799+ sha256 = "0gzk9b3xig48jvqz9983a7kziyb2n9z329kn6cqw1k0p8w2h3l8f";

3800+ revision = "1";

3801+ editedCabalFile = "1rgalxzj2d59wxlgha2c6jw7l2zsfiswhrraixk7l31xijgzpgv8";

3802+ configureFlags = [

3803+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3804+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3805+ "-fsplitbase" "-f-test-hlint"

3806+ ];

3807+ libraryHaskellDepends = [

3808+ base semigroups transformers transformers-compat void

3809+ ];

3810+ homepage = "http://github.com/ekmett/contravariant/";

3811+ description = "Contravariant functors";

3812+ license = stdenv.lib.licenses.bsd3;

3813+ }) {};

3814+ "control-monad-free" = callPackage

3815+ ({ mkDerivation, base, deepseq, transformers }:

3816+ mkDerivation {

3817+ pname = "control-monad-free";

3818+ version = "0.5.3";

3819+ sha256 = "1igwawcdpg8irayjax1xdrlpa9587k1v4y28ib3xfb7yk0xv7vk1";

3820+ configureFlags = [

3821+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3822+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3823+ "-fsplitbase" "-f-test-hlint"

3824+ ];

3825+ libraryHaskellDepends = [ base deepseq transformers ];

3826+ homepage = "http://github.com/pepeiborra/control-monad-free";

3827+ description = "Free monads and monad transformers";

3828+ license = stdenv.lib.licenses.publicDomain;

3829+ }) {};

3830+ "control-monad-loop" = callPackage

3831+ ({ mkDerivation, base, transformers, transformers-base }:

3832+ mkDerivation {

3833+ pname = "control-monad-loop";

3834+ version = "0.1";

3835+ sha256 = "003k4pp6wgn30m9ksbh8680f0klzsvd90wsl9jpqs9lpg14hi6zj";

3836+ configureFlags = [

3837+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3838+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3839+ "-fsplitbase" "-f-test-hlint"

3840+ ];

3841+ libraryHaskellDepends = [ base transformers transformers-base ];

3842+ homepage = "https://github.com/joeyadams/haskell-control-monad-loop";

3843+ description = "Simple monad transformer for imperative-style loops";

3844+ license = stdenv.lib.licenses.bsd3;

3845+ }) {};

3846+ "convertible" = callPackage

3847+ ({ mkDerivation, base, bytestring, containers, mtl, old-locale

3848+ , old-time, text, time

3849+ }:

3850+ mkDerivation {

3851+ pname = "convertible";

3852+ version = "1.1.0.0";

3853+ sha256 = "0pc3z4jfjna1rz5wlfimw9fyhpasmdnwvava883s401760y99i0k";

3854+ revision = "3";

3855+ editedCabalFile = "1yh1fik10pkfr1dn4b95i1az676f2fz9lqm1qg16bqzwg4gbqn4r";

3856+ configureFlags = [

3857+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3858+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3859+ "-fsplitbase" "-f-test-hlint"

3860+ ];

3861+ isLibrary = true;

3862+ isExecutable = true;

3863+ libraryHaskellDepends = [

3864+ base bytestring containers mtl old-locale old-time text time

3865+ ];

3866+ homepage = "http://hackage.haskell.org/cgi-bin/hackage-scripts/package/convertible";

3867+ description = "Typeclasses and instances for converting between types";

3868+ license = stdenv.lib.licenses.bsd3;

3869+ }) {};

3870+ "cookie" = callPackage

3871+ ({ mkDerivation, base, blaze-builder, bytestring, data-default

3872+ , deepseq, HUnit, old-locale, QuickCheck, tasty, tasty-hunit

3873+ , tasty-quickcheck, text, time

3874+ }:

3875+ mkDerivation {

3876+ pname = "cookie";

3877+ version = "0.4.1.4";

3878+ sha256 = "0axvljw34cjw47fxwxqql8rvjsyp9gxfbaijmysy5j10kx8s931d";

3879+ revision = "2";

3880+ editedCabalFile = "0rfph7jfqlvkckf7xz71cf6idziwv5i664gb9cq62l9qx7qwmpc5";

3881+ configureFlags = [

3882+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3883+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3884+ "-fsplitbase" "-f-test-hlint"

3885+ ];

3886+ libraryHaskellDepends = [

3887+ base blaze-builder bytestring data-default deepseq old-locale text

3888+ time

3889+ ];

3890+ testHaskellDepends = [

3891+ base blaze-builder bytestring HUnit QuickCheck tasty tasty-hunit

3892+ tasty-quickcheck text time

3893+ ];

3894+ homepage = "http://github.com/snoyberg/cookie";

3895+ description = "HTTP cookie parsing and rendering";

3896+ license = stdenv.lib.licenses.bsd3;

3897+ }) {};

3898+ "courier" = callPackage

3899+ ({ mkDerivation, async, base, bytestring, cereal, containers

3900+ , directory, hslogger, HUnit, network, stm, test-framework

3901+ , test-framework-hunit, text, uuid

3902+ }:

3903+ mkDerivation {

3904+ pname = "courier";

3905+ version = "0.1.0.15";

3906+ sha256 = "1aj9anrw7jfqx8s2xkdznqs212f54g6i2lcf79bgnkmxsbax252v";

3907+ configureFlags = [

3908+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3909+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3910+ "-fsplitbase" "-f-test-hlint"

3911+ ];

3912+ libraryHaskellDepends = [

3913+ async base bytestring cereal containers hslogger network stm text

3914+ uuid

3915+ ];

3916+ testHaskellDepends = [

3917+ async base cereal containers directory hslogger HUnit network stm

3918+ test-framework test-framework-hunit

3919+ ];

3920+ homepage = "http://github.com/hargettp/courier";

3921+ description = "A message-passing library for simplifying network applications";

3922+ license = stdenv.lib.licenses.mit;

3923+ }) {};

3924+ "cpphs" = callPackage

3925+ ({ mkDerivation, base, directory, old-locale, old-time, polyparse

3926+ }:

3927+ mkDerivation {

3928+ pname = "cpphs";

3929+ version = "1.18.6";

3930+ sha256 = "0ds712zabigswf3cljzh7f2ys4rl1fj2cf76lbw856adm8514gxc";

3931+ revision = "3";

3932+ editedCabalFile = "0463gpnmxfnhcashyixclx950b2vd6razjfggrqxqkd1fpl4mqsa";

3933+ configureFlags = [

3934+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3935+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3936+ "-fsplitbase" "-f-test-hlint"

3937+ ];

3938+ isLibrary = true;

3939+ isExecutable = true;

3940+ libraryHaskellDepends = [

3941+ base directory old-locale old-time polyparse

3942+ ];

3943+ executableHaskellDepends = [

3944+ base directory old-locale old-time polyparse

3945+ ];

3946+ homepage = "http://projects.haskell.org/cpphs/";

3947+ description = "A liberalised re-implementation of cpp, the C pre-processor";

3948+ license = "LGPL";

3949+ }) {};

3950+ "cprng-aes" = callPackage

3951+ ({ mkDerivation, base, byteable, bytestring, cipher-aes, criterion

3952+ , crypto-random, mtl

3953+ }:

3954+ mkDerivation {

3955+ pname = "cprng-aes";

3956+ version = "0.6.1";

3957+ sha256 = "1wr15kbmk1g3l8a75n0iwbzqg24ixv78slwzwb2q6rlcvq0jlnb4";

3958+ configureFlags = [

3959+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3960+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3961+ "-fsplitbase" "-f-test-hlint"

3962+ ];

3963+ enableSeparateDataOutput = true;

3964+ libraryHaskellDepends = [

3965+ base byteable bytestring cipher-aes crypto-random

3966+ ];

3967+ benchmarkHaskellDepends = [

3968+ base bytestring criterion crypto-random mtl

3969+ ];

3970+ homepage = "http://github.com/vincenthz/hs-cprng-aes";

3971+ description = "Crypto Pseudo Random Number Generator using AES in counter mode";

3972+ license = stdenv.lib.licenses.bsd3;

3973+ }) {};

3974+ "cpu" = callPackage

3975+ ({ mkDerivation, base }:

3976+ mkDerivation {

3977+ pname = "cpu";

3978+ version = "0.1.2";

3979+ sha256 = "0x19mlanmkg96h6h1i04w2i631z84y4rbk22ki4zhgsajysgw9sn";

3980+ configureFlags = [

3981+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3982+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3983+ "-fsplitbase" "-f-test-hlint"

3984+ ];

3985+ isLibrary = true;

3986+ isExecutable = true;

3987+ enableSeparateDataOutput = true;

3988+ libraryHaskellDepends = [ base ];

3989+ homepage = "http://github.com/vincenthz/hs-cpu";

3990+ description = "Cpu information and properties helpers";

3991+ license = stdenv.lib.licenses.bsd3;

3992+ }) {};

3993+ "criterion" = callPackage

3994+ ({ mkDerivation, aeson, ansi-wl-pprint, base, binary, bytestring

3995+ , cassava, containers, deepseq, directory, either, filepath, Glob

3996+ , hastache, HUnit, mtl, mwc-random, optparse-applicative, parsec

3997+ , QuickCheck, statistics, test-framework, test-framework-hunit

3998+ , test-framework-quickcheck2, text, time, transformers, vector

3999+ , vector-algorithms

4000+ }:

4001+ mkDerivation {

4002+ pname = "criterion";

4003+ version = "1.0.2.0";

4004+ sha256 = "02mcb49hiv0gijj5343gffdd3r8hjf4d52llv2gradaijz4zdqhx";

4005+ revision = "2";

4006+ editedCabalFile = "1g4vp91vm06bnyiv65qqzizgnvz8c3980675jr7l7747cwv2k6hb";

4007+ configureFlags = [

4008+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4009+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4010+ "-fsplitbase" "-f-test-hlint"

4011+ ];

4012+ isLibrary = true;

4013+ isExecutable = true;

4014+ enableSeparateDataOutput = true;

4015+ libraryHaskellDepends = [

4016+ aeson ansi-wl-pprint base binary bytestring cassava containers

4017+ deepseq directory either filepath Glob hastache mtl mwc-random

4018+ optparse-applicative parsec statistics text time transformers

4019+ vector vector-algorithms

4020+ ];

4021+ executableHaskellDepends = [ base ];

4022+ testHaskellDepends = [

4023+ base bytestring HUnit QuickCheck statistics test-framework

4024+ test-framework-hunit test-framework-quickcheck2 vector

4025+ ];

4026+ homepage = "http://www.serpentine.com/criterion";

4027+ description = "Robust, reliable performance measurement and analysis";

4028+ license = stdenv.lib.licenses.bsd3;

4029+ }) {};

4030+ "crypto-api" = callPackage

4031+ ({ mkDerivation, base, bytestring, cereal, entropy, tagged

4032+ , transformers

4033+ }:

4034+ mkDerivation {

4035+ pname = "crypto-api";

4036+ version = "0.13.2";

4037+ sha256 = "1vc27qcgbg7hf50rkqhlrs58zn1888ilh4b6wrrm07bnm48xacak";

4038+ configureFlags = [

4039+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4040+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4041+ "-fsplitbase" "-f-test-hlint"

4042+ ];

4043+ libraryHaskellDepends = [

4044+ base bytestring cereal entropy tagged transformers

4045+ ];

4046+ homepage = "https://github.com/TomMD/crypto-api";

4047+ description = "A generic interface for cryptographic operations";

4048+ license = stdenv.lib.licenses.bsd3;

4049+ }) {};

4050+ "crypto-cipher-tests" = callPackage

4051+ ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types

4052+ , HUnit, mtl, QuickCheck, securemem, test-framework

4053+ , test-framework-hunit, test-framework-quickcheck2

4054+ }:

4055+ mkDerivation {

4056+ pname = "crypto-cipher-tests";

4057+ version = "0.0.11";

4058+ sha256 = "19wqignlq90qwpam01hnmmrxaxh5lkax9l1l6rlbi4a07nvp1dnz";

4059+ configureFlags = [

4060+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4061+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4062+ "-fsplitbase" "-f-test-hlint"

4063+ ];

4064+ libraryHaskellDepends = [

4065+ base byteable bytestring crypto-cipher-types HUnit mtl QuickCheck

4066+ securemem test-framework test-framework-hunit

4067+ test-framework-quickcheck2

4068+ ];

4069+ testHaskellDepends = [

4070+ base byteable bytestring crypto-cipher-types HUnit mtl QuickCheck

4071+ test-framework test-framework-hunit test-framework-quickcheck2

4072+ ];

4073+ homepage = "http://github.com/vincenthz/hs-crypto-cipher";

4074+ description = "Generic cryptography cipher tests";

4075+ license = stdenv.lib.licenses.bsd3;

4076+ }) {};

4077+ "crypto-cipher-types" = callPackage

4078+ ({ mkDerivation, base, byteable, bytestring, securemem }:

4079+ mkDerivation {

4080+ pname = "crypto-cipher-types";

4081+ version = "0.0.9";

4082+ sha256 = "03qa1i1kj07pfrxsi7fiaqnnd0vi94jd4jfswbmnm4gp1nvzcwr0";

4083+ configureFlags = [

4084+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4085+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4086+ "-fsplitbase" "-f-test-hlint"

4087+ ];

4088+ enableSeparateDataOutput = true;

4089+ libraryHaskellDepends = [ base byteable bytestring securemem ];

4090+ homepage = "http://github.com/vincenthz/hs-crypto-cipher";

4091+ description = "Generic cryptography cipher types";

4092+ license = stdenv.lib.licenses.bsd3;

4093+ }) {};

4094+ "crypto-numbers" = callPackage

4095+ ({ mkDerivation, base, byteable, bytestring, criterion

4096+ , crypto-random, ghc-prim, HUnit, integer-gmp, mtl, QuickCheck

4097+ , test-framework, test-framework-hunit, test-framework-quickcheck2

4098+ , vector

4099+ }:

4100+ mkDerivation {

4101+ pname = "crypto-numbers";

4102+ version = "0.2.3";

4103+ sha256 = "0nx2mlf40127j7vas7liqy2yzfg4alfaxcjilcxk99kavpaanzgp";

4104+ revision = "4";

4105+ editedCabalFile = "1lpnyyv1ahkb312xs7r987l7kzlkjkl5an4hbfjf142ms3pvfsk9";

4106+ configureFlags = [

4107+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4108+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4109+ "-fsplitbase" "-f-test-hlint"

4110+ ];

4111+ libraryHaskellDepends = [

4112+ base bytestring crypto-random ghc-prim integer-gmp vector

4113+ ];

4114+ testHaskellDepends = [

4115+ base byteable bytestring crypto-random HUnit QuickCheck

4116+ test-framework test-framework-hunit test-framework-quickcheck2

4117+ vector

4118+ ];

4119+ benchmarkHaskellDepends = [ base bytestring criterion mtl ];

4120+ doHaddock = false;

4121+ doCheck = false;

4122+ homepage = "http://github.com/vincenthz/hs-crypto-numbers";

4123+ description = "Cryptographic numbers: functions and algorithms";

4124+ license = stdenv.lib.licenses.bsd3;

4125+ }) {};

4126+ "crypto-pubkey" = callPackage

4127+ ({ mkDerivation, base, byteable, bytestring, criterion

4128+ , crypto-numbers, crypto-pubkey-types, crypto-random, cryptohash

4129+ , deepseq, HUnit, mtl, QuickCheck, test-framework

4130+ , test-framework-hunit, test-framework-quickcheck2

4131+ }:

4132+ mkDerivation {

4133+ pname = "crypto-pubkey";

4134+ version = "0.2.5";

4135+ sha256 = "18rxm6mgxp8x4ns2725pw6ja2g6n6k64dj9cbwdlsb13pkdh3lxq";

4136+ configureFlags = [

4137+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4138+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4139+ "-fsplitbase" "-f-test-hlint"

4140+ ];

4141+ libraryHaskellDepends = [

4142+ base byteable bytestring crypto-numbers crypto-pubkey-types

4143+ crypto-random cryptohash

4144+ ];

4145+ testHaskellDepends = [

4146+ base byteable bytestring crypto-numbers crypto-pubkey-types

4147+ crypto-random cryptohash HUnit QuickCheck test-framework

4148+ test-framework-hunit test-framework-quickcheck2

4149+ ];

4150+ benchmarkHaskellDepends = [

4151+ base bytestring criterion crypto-pubkey-types crypto-random

4152+ cryptohash deepseq mtl

4153+ ];

4154+ homepage = "http://github.com/vincenthz/hs-crypto-pubkey";

4155+ description = "Public Key cryptography";

4156+ license = stdenv.lib.licenses.bsd3;

4157+ }) {};

4158+ "crypto-pubkey-types" = callPackage

4159+ ({ mkDerivation, asn1-types, base }:

4160+ mkDerivation {

4161+ pname = "crypto-pubkey-types";

4162+ version = "0.4.2.3";

4163+ sha256 = "1isfyr1ly9hv8idslpjbyc9hhgb1zqd9gfc1s4kvwy4gcdsvrx52";

4164+ configureFlags = [

4165+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4166+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4167+ "-fsplitbase" "-f-test-hlint"

4168+ ];

4169+ libraryHaskellDepends = [ asn1-types base ];

4170+ homepage = "http://github.com/vincenthz/hs-crypto-pubkey-types";

4171+ description = "Generic cryptography Public keys algorithm types";

4172+ license = stdenv.lib.licenses.bsd3;

4173+ }) {};

4174+ "crypto-random" = callPackage

4175+ ({ mkDerivation, base, bytestring, securemem, unix, vector }:

4176+ mkDerivation {

4177+ pname = "crypto-random";

4178+ version = "0.0.8";

4179+ sha256 = "058ilm05ni5ribggx25cfrhsv1z0abvgxzf3wd3d6qqq58p5wbkv";

4180+ configureFlags = [

4181+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4182+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4183+ "-fsplitbase" "-f-test-hlint"

4184+ ];

4185+ libraryHaskellDepends = [ base bytestring securemem unix vector ];

4186+ homepage = "http://github.com/vincenthz/hs-crypto-random";

4187+ description = "Simple cryptographic random related types";

4188+ license = stdenv.lib.licenses.bsd3;

4189+ }) {};

4190+ "crypto-random-api" = callPackage

4191+ ({ mkDerivation, base, bytestring, entropy }:

4192+ mkDerivation {

4193+ pname = "crypto-random-api";

4194+ version = "0.2.0";

4195+ sha256 = "0z49kwgjj7rz235642q64hbkgp0zl6ipn29xd19yb75xc5q7gsan";

4196+ configureFlags = [

4197+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4198+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4199+ "-fsplitbase" "-f-test-hlint"

4200+ ];

4201+ libraryHaskellDepends = [ base bytestring entropy ];

4202+ homepage = "http://github.com/vincenthz/hs-crypto-random-api";

4203+ description = "Simple random generators API for cryptography related code";

4204+ license = stdenv.lib.licenses.bsd3;

4205+ }) {};

4206+ "cryptocipher" = callPackage

4207+ ({ mkDerivation, base, cipher-aes, cipher-blowfish, cipher-camellia

4208+ , cipher-des, cipher-rc4, crypto-cipher-types

4209+ }:

4210+ mkDerivation {

4211+ pname = "cryptocipher";

4212+ version = "0.6.2";

4213+ sha256 = "0ip3a2as0df6drl29sryayxx22sx55v6bs60s2fh3i1nxqnydf9l";

4214+ configureFlags = [

4215+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4216+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4217+ "-fsplitbase" "-f-test-hlint"

4218+ ];

4219+ libraryHaskellDepends = [

4220+ base cipher-aes cipher-blowfish cipher-camellia cipher-des

4221+ cipher-rc4 crypto-cipher-types

4222+ ];

4223+ homepage = "http://github.com/vincenthz/hs-crypto-cipher";

4224+ description = "Symmetrical block and stream ciphers";

4225+ license = stdenv.lib.licenses.bsd3;

4226+ }) {};

4227+ "cryptohash" = callPackage

4228+ ({ mkDerivation, base, byteable, bytestring, criterion, ghc-prim

4229+ , HUnit, QuickCheck, tasty, tasty-hunit, tasty-quickcheck

4230+ }:

4231+ mkDerivation {

4232+ pname = "cryptohash";

4233+ version = "0.11.6";

4234+ sha256 = "0dyzcaxr8vhzqq9hj4240rxpi87h4ps87yz09klz723shls26f6s";

4235+ configureFlags = [

4236+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4237+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4238+ "-fsplitbase" "-f-test-hlint"

4239+ ];

4240+ libraryHaskellDepends = [ base byteable bytestring ghc-prim ];

4241+ testHaskellDepends = [

4242+ base byteable bytestring HUnit QuickCheck tasty tasty-hunit

4243+ tasty-quickcheck

4244+ ];

4245+ benchmarkHaskellDepends = [ base byteable bytestring criterion ];

4246+ homepage = "http://github.com/vincenthz/hs-cryptohash";

4247+ description = "collection of crypto hashes, fast, pure and practical";

4248+ license = stdenv.lib.licenses.bsd3;

4249+ }) {};

4250+ "cryptohash-conduit" = callPackage

4251+ ({ mkDerivation, base, bytestring, conduit, conduit-extra

4252+ , cryptohash, resourcet, transformers

4253+ }:

4254+ mkDerivation {

4255+ pname = "cryptohash-conduit";

4256+ version = "0.1.1";

4257+ sha256 = "1kmlskgb0jx8hkzdncr24aqir9k1kyfcb2rypvkdld1yin4nslga";

4258+ configureFlags = [

4259+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4260+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4261+ "-fsplitbase" "-f-test-hlint"

4262+ ];

4263+ libraryHaskellDepends = [

4264+ base bytestring conduit conduit-extra cryptohash resourcet

4265+ transformers

4266+ ];

4267+ homepage = "http://github.com/vincenthz/hs-cryptohash-conduit";

4268+ description = "cryptohash conduit";

4269+ license = stdenv.lib.licenses.bsd3;

4270+ }) {};

4271+ "cryptohash-cryptoapi" = callPackage

4272+ ({ mkDerivation, base, bytestring, cereal, crypto-api, cryptohash

4273+ , tagged

4274+ }:

4275+ mkDerivation {

4276+ pname = "cryptohash-cryptoapi";

4277+ version = "0.1.3";

4278+ sha256 = "0wj53p32js8lfg0i8akrljpash0jdiyv2vcqpmjbd4dq2fx81w2n";

4279+ configureFlags = [

4280+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4281+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4282+ "-fsplitbase" "-f-test-hlint"

4283+ ];

4284+ enableSeparateDataOutput = true;

4285+ libraryHaskellDepends = [

4286+ base bytestring cereal crypto-api cryptohash tagged

4287+ ];

4288+ homepage = "http://github.com/vincenthz/hs-cryptohash-cryptoapi";

4289+ description = "Crypto-api interfaces for cryptohash";

4290+ license = stdenv.lib.licenses.bsd3;

4291+ }) {};

4292+ "css-text" = callPackage

4293+ ({ mkDerivation, attoparsec, base, hspec, QuickCheck, text }:

4294+ mkDerivation {

4295+ pname = "css-text";

4296+ version = "0.1.2.1";

4297+ sha256 = "1xi1n2f0g8y43p95lynhcg50wxbq7hqfzbfzm7fy8mn7gvd920nw";

4298+ configureFlags = [

4299+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4300+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4301+ "-fsplitbase" "-f-test-hlint"

4302+ ];

4303+ libraryHaskellDepends = [ attoparsec base text ];

4304+ testHaskellDepends = [ attoparsec base hspec QuickCheck text ];

4305+ homepage = "http://www.yesodweb.com/";

4306+ description = "CSS parser and renderer";

4307+ license = stdenv.lib.licenses.bsd3;

4308+ }) {};

4309+ "csv" = callPackage

4310+ ({ mkDerivation, base, filepath, parsec }:

4311+ mkDerivation {

4312+ pname = "csv";

4313+ version = "0.1.2";

4314+ sha256 = "00767ai09wm7f0yzmpqck3cpgxncpr9djnmmz5l17ajz69139x4c";

4315+ configureFlags = [

4316+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4317+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4318+ "-fsplitbase" "-f-test-hlint"

4319+ ];

4320+ libraryHaskellDepends = [ base filepath parsec ];

4321+ description = "CSV loader and dumper";

4322+ license = stdenv.lib.licenses.mit;

4323+ }) {};

4324+ "csv-conduit" = callPackage

4325+ ({ mkDerivation, array, attoparsec, attoparsec-conduit, base

4326+ , blaze-builder, bytestring, conduit, conduit-extra, containers

4327+ , data-default, directory, ghc-prim, HUnit, mmorph, monad-control

4328+ , mtl, primitive, resourcet, test-framework, test-framework-hunit

4329+ , text, transformers, unordered-containers, vector

4330+ }:

4331+ mkDerivation {

4332+ pname = "csv-conduit";

4333+ version = "0.6.3";

4334+ sha256 = "1db1wlpl0ryyf8cmkrg1hgz4ggsvzy6z9ayzcc6n6rdywpfi29z4";

4335+ configureFlags = [

4336+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4337+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4338+ "-fsplitbase" "-f-test-hlint"

4339+ ];

4340+ isLibrary = true;

4341+ isExecutable = true;

4342+ libraryHaskellDepends = [

4343+ array attoparsec attoparsec-conduit base blaze-builder bytestring

4344+ conduit conduit-extra containers data-default ghc-prim mmorph

4345+ monad-control mtl primitive resourcet text transformers

4346+ unordered-containers vector

4347+ ];

4348+ executableHaskellDepends = [

4349+ base bytestring containers directory mtl primitive text

4350+ transformers vector

4351+ ];

4352+ testHaskellDepends = [

4353+ base bytestring containers directory HUnit mtl primitive

4354+ test-framework test-framework-hunit text transformers vector

4355+ ];

4356+ homepage = "http://github.com/ozataman/csv-conduit";

4357+ description = "A flexible, fast, conduit-based CSV parser library for Haskell";

4358+ license = stdenv.lib.licenses.bsd3;

4359+ }) {};

4360+ "curl" = callPackage

4361+ ({ mkDerivation, base, bytestring, containers, curl }:

4362+ mkDerivation {

4363+ pname = "curl";

4364+ version = "1.3.8";

4365+ sha256 = "0vj4hpaa30jz7c702xpsfvqaqdxz28zslsqnsfx6bf6dpwvck1wh";

4366+ configureFlags = [

4367+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4368+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4369+ "-fsplitbase" "-f-test-hlint"

4370+ ];

4371+ libraryHaskellDepends = [ base bytestring containers ];

4372+ librarySystemDepends = [ curl ];

4373+ description = "Haskell binding to libcurl";

4374+ license = stdenv.lib.licenses.bsd3;

4375+ }) {inherit (pkgs) curl;};

4376+ "data-accessor" = callPackage

4377+ ({ mkDerivation, array, base, containers, transformers }:

4378+ mkDerivation {

4379+ pname = "data-accessor";

4380+ version = "0.2.2.6";

4381+ sha256 = "0668qgllmp2911ppsb0g9z95nq2x0h2cvzyyjlb6iwhnjzyyg7gf";

4382+ configureFlags = [

4383+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4384+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4385+ "-fsplitbase" "-f-test-hlint"

4386+ ];

4387+ libraryHaskellDepends = [ array base containers transformers ];

4388+ homepage = "http://www.haskell.org/haskellwiki/Record_access";

4389+ description = "Utilities for accessing and manipulating fields of records";

4390+ license = stdenv.lib.licenses.bsd3;

4391+ }) {};

4392+ "data-accessor-mtl" = callPackage

4393+ ({ mkDerivation, base, data-accessor, mtl }:

4394+ mkDerivation {

4395+ pname = "data-accessor-mtl";

4396+ version = "0.2.0.4";

4397+ sha256 = "1i8lk0vy04giixng5addgj740cbvwlc7g62qgrmhfip0w9k93kqh";

4398+ configureFlags = [

4399+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4400+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4401+ "-fsplitbase" "-f-test-hlint"

4402+ ];

4403+ libraryHaskellDepends = [ base data-accessor mtl ];

4404+ homepage = "http://www.haskell.org/haskellwiki/Record_access";

4405+ description = "Use Accessor to access state in mtl State monad class";

4406+ license = stdenv.lib.licenses.bsd3;

4407+ }) {};

4408+ "data-binary-ieee754" = callPackage

4409+ ({ mkDerivation, base, binary }:

4410+ mkDerivation {

4411+ pname = "data-binary-ieee754";

4412+ version = "0.4.4";

4413+ sha256 = "02nzg1barhqhpf4x26mpzvk7jd29nali033qy01adjplv2z5m5sr";

4414+ configureFlags = [

4415+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4416+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4417+ "-fsplitbase" "-f-test-hlint"

4418+ ];

4419+ libraryHaskellDepends = [ base binary ];

4420+ homepage = "https://john-millikin.com/software/data-binary-ieee754/";

4421+ description = "Parser/Serialiser for IEEE-754 floating-point values";

4422+ license = stdenv.lib.licenses.mit;

4423+ }) {};

4424+ "data-default" = callPackage

4425+ ({ mkDerivation, base, data-default-class

4426+ , data-default-instances-base, data-default-instances-containers

4427+ , data-default-instances-dlist, data-default-instances-old-locale

4428+ }:

4429+ mkDerivation {

4430+ pname = "data-default";

4431+ version = "0.5.3";

4432+ sha256 = "0d1hm0l9kim3kszshr4msmgzizrzha48gz2kb7b61p7n3gs70m7c";

4433+ configureFlags = [

4434+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4435+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4436+ "-fsplitbase" "-f-test-hlint"

4437+ ];

4438+ libraryHaskellDepends = [

4439+ base data-default-class data-default-instances-base

4440+ data-default-instances-containers data-default-instances-dlist

4441+ data-default-instances-old-locale

4442+ ];

4443+ description = "A class for types with a default value";

4444+ license = stdenv.lib.licenses.bsd3;

4445+ }) {};

4446+ "data-default-class" = callPackage

4447+ ({ mkDerivation, base }:

4448+ mkDerivation {

4449+ pname = "data-default-class";

4450+ version = "0.0.1";

4451+ sha256 = "0ccgr3jllinchqhw3lsn73ic6axk4196if5274rr1rghls0fxj5d";

4452+ configureFlags = [

4453+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4454+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4455+ "-fsplitbase" "-f-test-hlint"

4456+ ];

4457+ libraryHaskellDepends = [ base ];

4458+ description = "A class for types with a default value";

4459+ license = stdenv.lib.licenses.bsd3;

4460+ }) {};

4461+ "data-default-instances-base" = callPackage

4462+ ({ mkDerivation, base, data-default-class }:

4463+ mkDerivation {

4464+ pname = "data-default-instances-base";

4465+ version = "0.0.1";

4466+ sha256 = "1832nq6by91f1iw73ycvkbgn8kpra83pvf2q61hy47xffh0zy4pb";

4467+ configureFlags = [

4468+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4469+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4470+ "-fsplitbase" "-f-test-hlint"

4471+ ];

4472+ libraryHaskellDepends = [ base data-default-class ];

4473+ description = "Default instances for types in base";

4474+ license = stdenv.lib.licenses.bsd3;

4475+ }) {};

4476+ "data-default-instances-containers" = callPackage

4477+ ({ mkDerivation, base, containers, data-default-class }:

4478+ mkDerivation {

4479+ pname = "data-default-instances-containers";

4480+ version = "0.0.1";

4481+ sha256 = "06h8xka031w752a7cjlzghvr8adqbl95xj9z5zc1b62w02phfpm5";

4482+ configureFlags = [

4483+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4484+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4485+ "-fsplitbase" "-f-test-hlint"

4486+ ];

4487+ libraryHaskellDepends = [ base containers data-default-class ];

4488+ description = "Default instances for types in containers";

4489+ license = stdenv.lib.licenses.bsd3;

4490+ }) {};

4491+ "data-default-instances-dlist" = callPackage

4492+ ({ mkDerivation, base, data-default-class, dlist }:

4493+ mkDerivation {

4494+ pname = "data-default-instances-dlist";

4495+ version = "0.0.1";

4496+ sha256 = "0narkdqiprhgayjiawrr4390h4rq4pl2pb6mvixbv2phrc8kfs3x";

4497+ configureFlags = [

4498+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4499+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4500+ "-fsplitbase" "-f-test-hlint"

4501+ ];

4502+ libraryHaskellDepends = [ base data-default-class dlist ];

4503+ description = "Default instances for types in dlist";

4504+ license = stdenv.lib.licenses.bsd3;

4505+ }) {};

4506+ "data-default-instances-old-locale" = callPackage

4507+ ({ mkDerivation, base, data-default-class, old-locale }:

4508+ mkDerivation {

4509+ pname = "data-default-instances-old-locale";

4510+ version = "0.0.1";

4511+ sha256 = "00h81i5phib741yj517p8mbnc48myvfj8axzsw44k34m48lv1lv0";

4512+ configureFlags = [

4513+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4514+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4515+ "-fsplitbase" "-f-test-hlint"

4516+ ];

4517+ libraryHaskellDepends = [ base data-default-class old-locale ];

4518+ description = "Default instances for types in old-locale";

4519+ license = stdenv.lib.licenses.bsd3;

4520+ }) {};

4521+ "data-inttrie" = callPackage

4522+ ({ mkDerivation, base }:

4523+ mkDerivation {

4524+ pname = "data-inttrie";

4525+ version = "0.1.0";

4526+ sha256 = "00kzf3cw0y0848cprmx3i7g70rmr92hhfzn60a2x98vb8f7y3814";

4527+ configureFlags = [

4528+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4529+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4530+ "-fsplitbase" "-f-test-hlint"

4531+ ];

4532+ libraryHaskellDepends = [ base ];

4533+ homepage = "http://github.com/luqui/data-inttrie";

4534+ description = "A lazy, infinite trie of integers";

4535+ license = stdenv.lib.licenses.bsd3;

4536+ }) {};

4537+ "data-lens-light" = callPackage

4538+ ({ mkDerivation, base, mtl, template-haskell }:

4539+ mkDerivation {

4540+ pname = "data-lens-light";

4541+ version = "0.1.2.1";

4542+ sha256 = "038vfzb4vxk1qb0246l2kgv9br37wg59wnlhzyjpn97lypwlf68w";

4543+ configureFlags = [

4544+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4545+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4546+ "-fsplitbase" "-f-test-hlint"

4547+ ];

4548+ libraryHaskellDepends = [ base mtl template-haskell ];

4549+ homepage = "https://github.com/feuerbach/data-lens-light";

4550+ description = "Simple lenses, minimum dependencies";

4551+ license = stdenv.lib.licenses.mit;

4552+ }) {};

4553+ "data-memocombinators" = callPackage

4554+ ({ mkDerivation, array, base, data-inttrie }:

4555+ mkDerivation {

4556+ pname = "data-memocombinators";

4557+ version = "0.5.1";

4558+ sha256 = "1mvfc1xri3kgkx5q7za01bqg1x3bfvbgcffw5vwl6jmq4hh1sd5l";

4559+ configureFlags = [

4560+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4561+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4562+ "-fsplitbase" "-f-test-hlint"

4563+ ];

4564+ libraryHaskellDepends = [ array base data-inttrie ];

4565+ homepage = "http://github.com/luqui/data-memocombinators";

4566+ description = "Combinators for building memo tables";

4567+ license = stdenv.lib.licenses.bsd3;

4568+ }) {};

4569+ "data-reify" = callPackage

4570+ ({ mkDerivation, base, containers }:

4571+ mkDerivation {

4572+ pname = "data-reify";

4573+ version = "0.6";

4574+ sha256 = "0mif89mpj5zvw8czc51mfj27jw2ipxd2awnm9q13s46k6s5pv6a7";

4575+ revision = "1";

4576+ editedCabalFile = "1h9kr0d9xmxf5y5hlygfnv8r7kvwibap6i7bjzr65zl7vczms630";

4577+ configureFlags = [

4578+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4579+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4580+ "-fsplitbase" "-f-test-hlint"

4581+ ];

4582+ isLibrary = true;

4583+ isExecutable = true;

4584+ libraryHaskellDepends = [ base containers ];

4585+ executableHaskellDepends = [ base ];

4586+ homepage = "http://www.ittc.ku.edu/csdl/fpg/Tools/IOReification";

4587+ description = "Reify a recursive data structure into an explicit graph";

4588+ license = stdenv.lib.licenses.bsd3;

4589+ }) {};

4590+ "deepseq-generics" = callPackage

4591+ ({ mkDerivation, base, deepseq, ghc-prim, HUnit, test-framework

4592+ , test-framework-hunit

4593+ }:

4594+ mkDerivation {

4595+ pname = "deepseq-generics";

4596+ version = "0.1.1.1";

4597+ sha256 = "1icc2gxsbnjjl150msnyysvr9r14kb6s2gm3izrj5a3mwf6l7s08";

4598+ configureFlags = [

4599+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4600+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4601+ "-fsplitbase" "-f-test-hlint"

4602+ ];

4603+ libraryHaskellDepends = [ base deepseq ghc-prim ];

4604+ testHaskellDepends = [

4605+ base deepseq ghc-prim HUnit test-framework test-framework-hunit

4606+ ];

4607+ homepage = "https://github.com/hvr/deepseq-generics";

4608+ description = "GHC.Generics-based Control.DeepSeq.rnf implementation";

4609+ license = stdenv.lib.licenses.bsd3;

4610+ }) {};

4611+ "derive" = callPackage

4612+ ({ mkDerivation, base, bytestring, containers, directory, filepath

4613+ , haskell-src-exts, pretty, process, syb, template-haskell

4614+ , transformers, uniplate

4615+ }:

4616+ mkDerivation {

4617+ pname = "derive";

4618+ version = "2.5.18";

4619+ sha256 = "1jqng8v1d4rac8xmrpm7h1pkyr9pfwsbb0ap6pnwzpwz9fns9c3k";

4620+ configureFlags = [

4621+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4622+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4623+ "-fsplitbase" "-f-test-hlint"

4624+ ];

4625+ isLibrary = true;

4626+ isExecutable = true;

4627+ libraryHaskellDepends = [

4628+ base bytestring containers directory filepath haskell-src-exts

4629+ pretty process syb template-haskell transformers uniplate

4630+ ];

4631+ homepage = "http://community.haskell.org/~ndm/derive/";

4632+ description = "A program and library to derive instances for data types";

4633+ license = stdenv.lib.licenses.bsd3;

4634+ }) {};

4635+ "diagrams" = callPackage

4636+ ({ mkDerivation, diagrams-contrib, diagrams-core, diagrams-lib

4637+ , diagrams-svg

4638+ }:

4639+ mkDerivation {

4640+ pname = "diagrams";

4641+ version = "1.2";

4642+ sha256 = "17j7hyd86h9msc8ni19agb0yhixga76q9kh4i109iyiyqizdnfhg";

4643+ configureFlags = [

4644+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4645+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4646+ "-fsplitbase" "-f-test-hlint"

4647+ ];

4648+ libraryHaskellDepends = [

4649+ diagrams-contrib diagrams-core diagrams-lib diagrams-svg

4650+ ];

4651+ doHaddock = false;

4652+ doCheck = false;

4653+ homepage = "http://projects.haskell.org/diagrams";

4654+ description = "Embedded domain-specific language for declarative vector graphics";

4655+ license = stdenv.lib.licenses.bsd3;

4656+ }) {};

4657+ "diagrams-builder" = callPackage

4658+ ({ mkDerivation, base, cmdargs, diagrams-lib, directory, exceptions

4659+ , filepath, hashable, haskell-src-exts, hint, lens, mtl, split

4660+ , transformers

4661+ }:

4662+ mkDerivation {

4663+ pname = "diagrams-builder";

4664+ version = "0.6.0.2";

4665+ sha256 = "18avlhwywhrxlf1cyp9fdiy0i3gy12k4i28cymllmmyx78fv59q5";

4666+ configureFlags = [

4667+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4668+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4669+ "-fsplitbase" "-f-test-hlint"

4670+ ];

4671+ isLibrary = true;

4672+ isExecutable = true;

4673+ libraryHaskellDepends = [

4674+ base cmdargs diagrams-lib directory exceptions filepath hashable

4675+ haskell-src-exts hint lens mtl split transformers

4676+ ];

4677+ homepage = "http://projects.haskell.org/diagrams";

4678+ description = "hint-based build service for the diagrams graphics EDSL";

4679+ license = stdenv.lib.licenses.bsd3;

4680+ }) {};

4681+ "diagrams-cairo" = callPackage

4682+ ({ mkDerivation, base, bytestring, cairo, colour, containers

4683+ , data-default-class, diagrams-core, diagrams-lib, directory

4684+ , filepath, hashable, JuicyPixels, lens, mtl, old-time

4685+ , optparse-applicative, pango, process, split, statestack, time

4686+ , transformers, unix, vector

4687+ }:

4688+ mkDerivation {

4689+ pname = "diagrams-cairo";

4690+ version = "1.2.0.4";

4691+ sha256 = "1yg6ja5jha499b6j5fsgdl4f3l2ff1gp6cl7ixzj9y26m7a10bqq";

4692+ configureFlags = [

4693+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4694+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4695+ "-fsplitbase" "-f-test-hlint"

4696+ ];

4697+ libraryHaskellDepends = [

4698+ base bytestring cairo colour containers data-default-class

4699+ diagrams-core diagrams-lib directory filepath hashable JuicyPixels

4700+ lens mtl old-time optparse-applicative pango process split

4701+ statestack time transformers unix vector

4702+ ];

4703+ homepage = "http://projects.haskell.org/diagrams";

4704+ description = "Cairo backend for diagrams drawing EDSL";

4705+ license = stdenv.lib.licenses.bsd3;

4706+ }) {};

4707+ "diagrams-contrib" = callPackage

4708+ ({ mkDerivation, arithmoi, base, circle-packing, colour, containers

4709+ , data-default, data-default-class, diagrams-core, diagrams-lib

4710+ , force-layout, HUnit, lens, MonadRandom, mtl, parsec, QuickCheck

4711+ , semigroups, split, test-framework, test-framework-hunit

4712+ , test-framework-quickcheck2, text, vector-space

4713+ , vector-space-points

4714+ }:

4715+ mkDerivation {

4716+ pname = "diagrams-contrib";

4717+ version = "1.1.2.4";

4718+ sha256 = "0iq5psy5wjm664hqsaprynba0b7x3ijxngh7mbk6hkh004vsna1w";

4719+ configureFlags = [

4720+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4721+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4722+ "-fsplitbase" "-f-test-hlint"

4723+ ];

4724+ libraryHaskellDepends = [

4725+ arithmoi base circle-packing colour containers data-default

4726+ data-default-class diagrams-core diagrams-lib force-layout lens

4727+ MonadRandom mtl parsec semigroups split text vector-space

4728+ vector-space-points

4729+ ];

4730+ testHaskellDepends = [

4731+ base containers diagrams-lib HUnit QuickCheck test-framework

4732+ test-framework-hunit test-framework-quickcheck2

4733+ ];

4734+ homepage = "http://projects.haskell.org/diagrams/";

4735+ description = "Collection of user contributions to diagrams EDSL";

4736+ license = stdenv.lib.licenses.bsd3;

4737+ }) {};

4738+ "diagrams-core" = callPackage

4739+ ({ mkDerivation, base, containers, dual-tree, lens, MemoTrie

4740+ , monoid-extras, newtype, semigroups, vector-space

4741+ , vector-space-points

4742+ }:

4743+ mkDerivation {

4744+ pname = "diagrams-core";

4745+ version = "1.2.0.4";

4746+ sha256 = "1axkgprqs4jvzh5vfr118nzr1h0m48axr5jfiqqrqvy5xyjcagkq";

4747+ configureFlags = [

4748+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4749+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4750+ "-fsplitbase" "-f-test-hlint"

4751+ ];

4752+ libraryHaskellDepends = [

4753+ base containers dual-tree lens MemoTrie monoid-extras newtype

4754+ semigroups vector-space vector-space-points

4755+ ];

4756+ homepage = "http://projects.haskell.org/diagrams";

4757+ description = "Core libraries for diagrams EDSL";

4758+ license = stdenv.lib.licenses.bsd3;

4759+ }) {};

4760+ "diagrams-haddock" = callPackage

4761+ ({ mkDerivation, ansi-terminal, base, base64-bytestring, blaze-svg

4762+ , bytestring, Cabal, cautious-file, cmdargs, containers, cpphs

4763+ , diagrams-builder, diagrams-lib, diagrams-svg, directory, filepath

4764+ , haskell-src-exts, lens, mtl, parsec, split, strict, text

4765+ , uniplate, vector-space

4766+ }:

4767+ mkDerivation {

4768+ pname = "diagrams-haddock";

4769+ version = "0.2.2.12";

4770+ sha256 = "1yrbrq54ihxh7pnn3cax3r880mawpxmp044bdb581ah1ch3l8ch6";

4771+ configureFlags = [

4772+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4773+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4774+ "-fsplitbase" "-f-test-hlint"

4775+ ];

4776+ isLibrary = true;

4777+ isExecutable = true;

4778+ libraryHaskellDepends = [

4779+ ansi-terminal base base64-bytestring blaze-svg bytestring

4780+ cautious-file containers cpphs diagrams-builder diagrams-lib

4781+ diagrams-svg directory filepath haskell-src-exts lens mtl parsec

4782+ split strict text uniplate vector-space

4783+ ];

4784+ executableHaskellDepends = [

4785+ base Cabal cmdargs cpphs directory filepath

4786+ ];

4787+ doHaddock = false;

4788+ doCheck = false;

4789+ homepage = "http://projects.haskell.org/diagrams/";

4790+ description = "Preprocessor for embedding diagrams in Haddock documentation";

4791+ license = stdenv.lib.licenses.bsd3;

4792+ }) {};

4793+ "diagrams-lib" = callPackage

4794+ ({ mkDerivation, active, array, base, colour, containers

4795+ , data-default-class, diagrams-core, dual-tree, filepath

4796+ , fingertree, hashable, intervals, JuicyPixels, lens, MemoTrie

4797+ , monoid-extras, optparse-applicative, semigroups, tagged

4798+ , vector-space, vector-space-points

4799+ }:

4800+ mkDerivation {

4801+ pname = "diagrams-lib";

4802+ version = "1.2.0.7";

4803+ sha256 = "12ddlipp47j2mifwhi0ilb2fjdh2whk24s4d5h6ais2znj3hh99a";

4804+ configureFlags = [

4805+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4806+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4807+ "-fsplitbase" "-f-test-hlint"

4808+ ];

4809+ libraryHaskellDepends = [

4810+ active array base colour containers data-default-class

4811+ diagrams-core dual-tree filepath fingertree hashable intervals

4812+ JuicyPixels lens MemoTrie monoid-extras optparse-applicative

4813+ semigroups tagged vector-space vector-space-points

4814+ ];

4815+ homepage = "http://projects.haskell.org/diagrams";

4816+ description = "Embedded domain-specific language for declarative graphics";

4817+ license = stdenv.lib.licenses.bsd3;

4818+ }) {};

4819+ "diagrams-postscript" = callPackage

4820+ ({ mkDerivation, base, containers, data-default-class

4821+ , diagrams-core, diagrams-lib, dlist, filepath, hashable, lens

4822+ , monoid-extras, mtl, semigroups, split, vector-space

4823+ }:

4824+ mkDerivation {

4825+ pname = "diagrams-postscript";

4826+ version = "1.1.0.3";

4827+ sha256 = "172r7q9jzhy2kv5bsbakakwv6gpvy308gvp8xpirbch9mrvnjxhz";

4828+ configureFlags = [

4829+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4830+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4831+ "-fsplitbase" "-f-test-hlint"

4832+ ];

4833+ libraryHaskellDepends = [

4834+ base containers data-default-class diagrams-core diagrams-lib dlist

4835+ filepath hashable lens monoid-extras mtl semigroups split

4836+ vector-space

4837+ ];

4838+ homepage = "http://projects.haskell.org/diagrams/";

4839+ description = "Postscript backend for diagrams drawing EDSL";

4840+ license = stdenv.lib.licenses.bsd3;

4841+ }) {};

4842+ "diagrams-svg" = callPackage

4843+ ({ mkDerivation, base, base64-bytestring, blaze-markup, blaze-svg

4844+ , bytestring, colour, containers, diagrams-core, diagrams-lib

4845+ , directory, filepath, hashable, JuicyPixels, lens, monoid-extras

4846+ , mtl, old-time, process, split, time, unix, vector-space

4847+ }:

4848+ mkDerivation {

4849+ pname = "diagrams-svg";

4850+ version = "1.1.0.3";

4851+ sha256 = "0byqxwz9h1hi2yrq2vz32gv0az9q3l94qa2q3nl3j8sa64qmpdwq";

4852+ configureFlags = [

4853+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4854+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4855+ "-fsplitbase" "-f-test-hlint"

4856+ ];

4857+ libraryHaskellDepends = [

4858+ base base64-bytestring blaze-markup blaze-svg bytestring colour

4859+ containers diagrams-core diagrams-lib directory filepath hashable

4860+ JuicyPixels lens monoid-extras mtl old-time process split time unix

4861+ vector-space

4862+ ];

4863+ homepage = "http://projects.haskell.org/diagrams/";

4864+ description = "SVG backend for diagrams drawing EDSL";

4865+ license = stdenv.lib.licenses.bsd3;

4866+ }) {};

4867+ "digest" = callPackage

4868+ ({ mkDerivation, base, bytestring, zlib }:

4869+ mkDerivation {

4870+ pname = "digest";

4871+ version = "0.0.1.2";

4872+ sha256 = "04gy2zp8yzvv7j9bdfvmfzcz3sqyqa6rwslqcn4vyair2vmif5v4";

4873+ configureFlags = [

4874+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4875+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4876+ "-fsplitbase" "-f-test-hlint"

4877+ ];

4878+ libraryHaskellDepends = [ base bytestring ];

4879+ librarySystemDepends = [ zlib ];

4880+ description = "Various cryptographic hashes for bytestrings; CRC32 and Adler32 for now";

4881+ license = stdenv.lib.licenses.bsd3;

4882+ }) {inherit (pkgs) zlib;};

4883+ "digestive-functors" = callPackage

4884+ ({ mkDerivation, base, bytestring, containers, HUnit, mtl

4885+ , old-locale, QuickCheck, test-framework, test-framework-hunit

4886+ , test-framework-quickcheck2, text, time

4887+ }:

4888+ mkDerivation {

4889+ pname = "digestive-functors";

4890+ version = "0.7.1.1";

4891+ sha256 = "161461y8gil2922gx6kdc59g50ywk9nk74gkxl0yrwvz80a118c9";

4892+ configureFlags = [

4893+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4894+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4895+ "-fsplitbase" "-f-test-hlint"

4896+ ];

4897+ libraryHaskellDepends = [

4898+ base bytestring containers mtl old-locale text time

4899+ ];

4900+ testHaskellDepends = [

4901+ base bytestring containers HUnit mtl old-locale QuickCheck

4902+ test-framework test-framework-hunit test-framework-quickcheck2 text

4903+ time

4904+ ];

4905+ homepage = "http://github.com/jaspervdj/digestive-functors";

4906+ description = "A practical formlet library";

4907+ license = stdenv.lib.licenses.bsd3;

4908+ }) {};

4909+ "dimensional" = callPackage

4910+ ({ mkDerivation, base, numtype, time }:

4911+ mkDerivation {

4912+ pname = "dimensional";

4913+ version = "0.13.0.1";

4914+ sha256 = "1cn7gyskp0ax5lm5k05p6qp461hirjyhj0k1qyd64fgdmmp81vi6";

4915+ configureFlags = [

4916+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4917+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4918+ "-fsplitbase" "-f-test-hlint"

4919+ ];

4920+ libraryHaskellDepends = [ base numtype time ];

4921+ homepage = "http://dimensional.googlecode.com/";

4922+ description = "Statically checked physical dimensions";

4923+ license = stdenv.lib.licenses.bsd3;

4924+ }) {};

4925+ "direct-sqlite" = callPackage

4926+ ({ mkDerivation, base, base16-bytestring, bytestring, directory

4927+ , HUnit, text

4928+ }:

4929+ mkDerivation {

4930+ pname = "direct-sqlite";

4931+ version = "2.3.14";

4932+ sha256 = "0xxvr2wln54snkvs2r46fkkn7yhm6i2afgww40vnfqamg8g81x5w";

4933+ configureFlags = [

4934+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4935+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4936+ "-fsplitbase" "-f-test-hlint"

4937+ ];

4938+ libraryHaskellDepends = [ base bytestring text ];

4939+ testHaskellDepends = [

4940+ base base16-bytestring bytestring directory HUnit text

4941+ ];

4942+ homepage = "https://github.com/IreneKnapp/direct-sqlite";

4943+ description = "Low-level binding to SQLite3. Includes UTF8 and BLOB support.";

4944+ license = stdenv.lib.licenses.bsd3;

4945+ }) {};

4946+ "directory-tree" = callPackage

4947+ ({ mkDerivation, base, directory, filepath, process }:

4948+ mkDerivation {

4949+ pname = "directory-tree";

4950+ version = "0.12.0";

4951+ sha256 = "1idknm7fwci91fkwvzl35g0qd0jk1vb00ds2x82zjf2hdbkcc2gz";

4952+ configureFlags = [

4953+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4954+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4955+ "-fsplitbase" "-f-test-hlint"

4956+ ];

4957+ libraryHaskellDepends = [ base directory filepath ];

4958+ testHaskellDepends = [ base directory filepath process ];

4959+ homepage = "http://brandon.si/code/directory-tree-module-released/";

4960+ description = "A simple directory-like tree datatype, with useful IO functions";

4961+ license = stdenv.lib.licenses.bsd3;

4962+ }) {};

4963+ "distributed-process" = callPackage

4964+ ({ mkDerivation, base, binary, bytestring, containers

4965+ , data-accessor, deepseq, distributed-static, ghc-prim, hashable

4966+ , mtl, network-transport, network-transport-tcp, old-locale, random

4967+ , rank1dynamic, stm, syb, template-haskell, time, transformers

4968+ }:

4969+ mkDerivation {

4970+ pname = "distributed-process";

4971+ version = "0.5.2";

4972+ sha256 = "04llhz9z28365idgj13hhwkp98zwqv6mhhy9i7416wk5d3r70g7l";

4973+ configureFlags = [

4974+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4975+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4976+ "-fsplitbase" "-f-test-hlint"

4977+ ];

4978+ libraryHaskellDepends = [

4979+ base binary bytestring containers data-accessor deepseq

4980+ distributed-static ghc-prim hashable mtl network-transport

4981+ old-locale random rank1dynamic stm syb template-haskell time

4982+ transformers

4983+ ];

4984+ benchmarkHaskellDepends = [

4985+ base binary bytestring network-transport-tcp

4986+ ];

4987+ doHaddock = false;

4988+ doCheck = false;

4989+ homepage = "http://haskell-distributed.github.com/";

4990+ description = "Cloud Haskell: Erlang-style concurrency in Haskell";

4991+ license = stdenv.lib.licenses.bsd3;

4992+ }) {};

4993+ "distributed-process-simplelocalnet" = callPackage

4994+ ({ mkDerivation, base, binary, bytestring, containers

4995+ , data-accessor, distributed-process, network, network-multicast

4996+ , network-transport, network-transport-tcp, transformers

4997+ }:

4998+ mkDerivation {

4999+ pname = "distributed-process-simplelocalnet";

5000+ version = "0.2.2.0";

5001+ sha256 = "024m5jycz257i34m2x97x3qyg76j1128ww61pql3fqy4mhvp3791";

5002+ configureFlags = [

5003+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5004+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5005+ "-fsplitbase" "-f-test-hlint"

5006+ ];

5007+ isLibrary = true;

5008+ isExecutable = true;

5009+ libraryHaskellDepends = [

5010+ base binary bytestring containers data-accessor distributed-process

5011+ network network-multicast network-transport network-transport-tcp

5012+ transformers

5013+ ];

5014+ homepage = "http://haskell-distributed.github.com";

5015+ description = "Simple zero-configuration backend for Cloud Haskell";

5016+ license = stdenv.lib.licenses.bsd3;

5017+ }) {};

5018+ "distributed-static" = callPackage

5019+ ({ mkDerivation, base, binary, bytestring, containers, rank1dynamic

5020+ }:

5021+ mkDerivation {

5022+ pname = "distributed-static";

5023+ version = "0.3.1.0";

5024+ sha256 = "190b6vjcipgrvnfl72c0ssw8crza02gfw9kwyvwg043jcznihj08";

5025+ configureFlags = [

5026+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5027+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5028+ "-fsplitbase" "-f-test-hlint"

5029+ ];

5030+ libraryHaskellDepends = [

5031+ base binary bytestring containers rank1dynamic

5032+ ];

5033+ homepage = "http://haskell-distributed.github.com";

5034+ description = "Compositional, type-safe, polymorphic static values and closures";

5035+ license = stdenv.lib.licenses.bsd3;

5036+ }) {};

5037+ "distributive" = callPackage

5038+ ({ mkDerivation, base, directory, doctest, filepath, ghc-prim

5039+ , tagged, transformers, transformers-compat

5040+ }:

5041+ mkDerivation {

5042+ pname = "distributive";

5043+ version = "0.4.4";

5044+ sha256 = "0s2ln9jv7bh4ri2y31178pvjl8x6nik5d0klx7j2b77yjlsgblc2";

5045+ configureFlags = [

5046+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5047+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5048+ "-fsplitbase" "-f-test-hlint"

5049+ ];

5050+ libraryHaskellDepends = [

5051+ base ghc-prim tagged transformers transformers-compat

5052+ ];

5053+ testHaskellDepends = [ base directory doctest filepath ];

5054+ homepage = "http://github.com/ekmett/distributive/";

5055+ description = "Distributive functors -- Dual to Traversable";

5056+ license = stdenv.lib.licenses.bsd3;

5057+ }) {};

5058+ "djinn-ghc" = callPackage

5059+ ({ mkDerivation, async, base, containers, djinn-lib, ghc, mtl

5060+ , transformers

5061+ }:

5062+ mkDerivation {

5063+ pname = "djinn-ghc";

5064+ version = "0.0.2.2";

5065+ sha256 = "0dz5jg58si9fsc12212rxmzky09zric7b2sdj1ydmvnrjxkh9l70";

5066+ configureFlags = [

5067+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5068+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5069+ "-fsplitbase" "-f-test-hlint"

5070+ ];

5071+ libraryHaskellDepends = [

5072+ async base containers djinn-lib ghc mtl transformers

5073+ ];

5074+ description = "Generate Haskell code from a type. Bridge from Djinn to GHC API.";

5075+ license = stdenv.lib.licenses.bsd3;

5076+ }) {};

5077+ "djinn-lib" = callPackage

5078+ ({ mkDerivation, base, containers, mtl, pretty }:

5079+ mkDerivation {

5080+ pname = "djinn-lib";

5081+ version = "0.0.1.2";

5082+ sha256 = "048hs27awl4j9lg04qbnpf8c51mzbgy2afckis19zcswmavi1zn0";

5083+ configureFlags = [

5084+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5085+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5086+ "-fsplitbase" "-f-test-hlint"

5087+ ];

5088+ libraryHaskellDepends = [ base containers mtl pretty ];

5089+ homepage = "http://www.augustsson.net/Darcs/Djinn/";

5090+ description = "Generate Haskell code from a type. Library extracted from djinn package.";

5091+ license = stdenv.lib.licenses.bsd3;

5092+ }) {};

5093+ "dlist" = callPackage

5094+ ({ mkDerivation, base, Cabal, deepseq, QuickCheck }:

5095+ mkDerivation {

5096+ pname = "dlist";

5097+ version = "0.7.1";

5098+ sha256 = "13ka30bn742ldacfgj2lhxvhwf769d0ziy2358vmd5xaq6fn1xfr";

5099+ configureFlags = [

5100+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5101+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5102+ "-fsplitbase" "-f-test-hlint"

5103+ ];

5104+ libraryHaskellDepends = [ base deepseq ];

5105+ testHaskellDepends = [ base Cabal QuickCheck ];

5106+ homepage = "https://github.com/spl/dlist";

5107+ description = "Difference lists";

5108+ license = stdenv.lib.licenses.bsd3;

5109+ }) {};

5110+ "dlist-instances" = callPackage

5111+ ({ mkDerivation, base, dlist, semigroups }:

5112+ mkDerivation {

5113+ pname = "dlist-instances";

5114+ version = "0.1";

5115+ sha256 = "0r1j7djywqd7c224wc9ixkplj3m2mbf9k3ra7n92ja2kfpksm615";

5116+ revision = "1";

5117+ editedCabalFile = "0b3gxbs4ny2hhwmcqgvayiwflanwwidcmwv15s4mhii43s34pfi1";

5118+ configureFlags = [

5119+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5120+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5121+ "-fsplitbase" "-f-test-hlint"

5122+ ];

5123+ libraryHaskellDepends = [ base dlist semigroups ];

5124+ homepage = "https://github.com/gregwebs/dlist-instances";

5125+ description = "Difference lists instances";

5126+ license = stdenv.lib.licenses.bsd3;

5127+ }) {};

5128+ "doctest" = callPackage

5129+ ({ mkDerivation, base, base-compat, deepseq, directory, filepath

5130+ , ghc, ghc-paths, hspec, HUnit, process, QuickCheck, setenv

5131+ , silently, stringbuilder, syb, transformers

5132+ }:

5133+ mkDerivation {

5134+ pname = "doctest";

5135+ version = "0.9.11.1";

5136+ sha256 = "1gzzzwr7f7281mlbfbk74nxr28l70lwfaws4xjfx2v06xazl99db";

5137+ configureFlags = [

5138+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5139+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5140+ "-fsplitbase" "-f-test-hlint"

5141+ ];

5142+ isLibrary = true;

5143+ isExecutable = true;

5144+ libraryHaskellDepends = [

5145+ base deepseq directory filepath ghc ghc-paths process syb

5146+ transformers

5147+ ];

5148+ executableHaskellDepends = [ base ];

5149+ testHaskellDepends = [

5150+ base base-compat deepseq directory filepath ghc ghc-paths hspec

5151+ HUnit process QuickCheck setenv silently stringbuilder syb

5152+ transformers

5153+ ];

5154+ homepage = "https://github.com/sol/doctest#readme";

5155+ description = "Test interactive Haskell examples";

5156+ license = stdenv.lib.licenses.mit;

5157+ }) {};

5158+ "double-conversion" = callPackage

5159+ ({ mkDerivation, base, bytestring, ghc-prim, integer-gmp

5160+ , test-framework, test-framework-quickcheck2, text

5161+ }:

5162+ mkDerivation {

5163+ pname = "double-conversion";

5164+ version = "2.0.1.0";

5165+ sha256 = "034ji9jgf3jl0n5pp1nki3lsg173c3b9vniwnwp1q21iasqbawh0";

5166+ configureFlags = [

5167+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5168+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5169+ "-fsplitbase" "-f-test-hlint"

5170+ ];

5171+ libraryHaskellDepends = [

5172+ base bytestring ghc-prim integer-gmp text

5173+ ];

5174+ testHaskellDepends = [

5175+ base bytestring test-framework test-framework-quickcheck2 text

5176+ ];

5177+ homepage = "https://github.com/bos/double-conversion";

5178+ description = "Fast conversion between double precision floating point and text";

5179+ license = stdenv.lib.licenses.bsd3;

5180+ }) {};

5181+ "dual-tree" = callPackage

5182+ ({ mkDerivation, base, monoid-extras, newtype, semigroups }:

5183+ mkDerivation {

5184+ pname = "dual-tree";

5185+ version = "0.2.0.5";

5186+ sha256 = "077njr9m6x9n2id0419rn6v4xwb9nvxshrmas9pkknp52va4ljg5";

5187+ configureFlags = [

5188+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5189+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5190+ "-fsplitbase" "-f-test-hlint"

5191+ ];

5192+ libraryHaskellDepends = [ base monoid-extras newtype semigroups ];

5193+ description = "Rose trees with cached and accumulating monoidal annotations";

5194+ license = stdenv.lib.licenses.bsd3;

5195+ }) {};

5196+ "easy-file" = callPackage

5197+ ({ mkDerivation, base, directory, filepath, time, unix }:

5198+ mkDerivation {

5199+ pname = "easy-file";

5200+ version = "0.2.0";

5201+ sha256 = "0v8skixq15rvyiyky1dcrfl9jrzkbi75vai8np11xy2kg7a8ym2a";

5202+ configureFlags = [

5203+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5204+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5205+ "-fsplitbase" "-f-test-hlint"

5206+ ];

5207+ libraryHaskellDepends = [ base directory filepath time unix ];

5208+ homepage = "http://github.com/kazu-yamamoto/easy-file";

5209+ description = "Cross-platform File handling";

5210+ license = stdenv.lib.licenses.bsd3;

5211+ }) {};

5212+ "either" = callPackage

5213+ ({ mkDerivation, base, bifunctors, exceptions, free, monad-control

5214+ , MonadRandom, mtl, profunctors, semigroupoids, semigroups

5215+ , transformers, transformers-base

5216+ }:

5217+ mkDerivation {

5218+ pname = "either";

5219+ version = "4.3.2";

5220+ sha256 = "0bmw4qc263fs5ivf94qfzrq26v8kflb13gims7c474d4jhg8g0w1";

5221+ configureFlags = [

5222+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5223+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5224+ "-fsplitbase" "-f-test-hlint"

5225+ ];

5226+ libraryHaskellDepends = [

5227+ base bifunctors exceptions free monad-control MonadRandom mtl

5228+ profunctors semigroupoids semigroups transformers transformers-base

5229+ ];

5230+ homepage = "http://github.com/ekmett/either/";

5231+ description = "An either monad transformer";

5232+ license = stdenv.lib.licenses.bsd3;

5233+ }) {};

5234+ "email-validate" = callPackage

5235+ ({ mkDerivation, attoparsec, base, bytestring, ghc-prim, HUnit

5236+ , QuickCheck, test-framework, test-framework-hunit

5237+ , test-framework-quickcheck2

5238+ }:

5239+ mkDerivation {

5240+ pname = "email-validate";

5241+ version = "2.0.1";

5242+ sha256 = "1qxvcm8xiyz50ganzic8cm8nxswq361i80yi939y3n89dk067lzj";

5243+ revision = "1";

5244+ editedCabalFile = "1rr452gk6wq6p5kmcihr89g2xbgfz3f9758c2wn64js39lr1wymp";

5245+ configureFlags = [

5246+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5247+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5248+ "-fsplitbase" "-f-test-hlint"

5249+ ];

5250+ libraryHaskellDepends = [ attoparsec base bytestring ghc-prim ];

5251+ testHaskellDepends = [

5252+ base bytestring HUnit QuickCheck test-framework

5253+ test-framework-hunit test-framework-quickcheck2

5254+ ];

5255+ homepage = "http://porg.es/blog/email-address-validation-simpler-faster-more-correct";

5256+ description = "Validating an email address string against RFC 5322";

5257+ license = stdenv.lib.licenses.bsd3;

5258+ }) {};

5259+ "enclosed-exceptions" = callPackage

5260+ ({ mkDerivation, async, base, deepseq, hspec, lifted-base

5261+ , monad-control, QuickCheck, transformers, transformers-base

5262+ }:

5263+ mkDerivation {

5264+ pname = "enclosed-exceptions";

5265+ version = "1.0.1";

5266+ sha256 = "1kid1hi392h88a1am0jkm7dhwl3v78lw5wfcyhmh0x454yr3b6zz";

5267+ configureFlags = [

5268+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5269+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5270+ "-fsplitbase" "-f-test-hlint"

5271+ ];

5272+ libraryHaskellDepends = [

5273+ async base deepseq lifted-base monad-control transformers

5274+ transformers-base

5275+ ];

5276+ testHaskellDepends = [

5277+ async base deepseq hspec lifted-base monad-control QuickCheck

5278+ transformers transformers-base

5279+ ];

5280+ homepage = "https://github.com/jcristovao/enclosed-exceptions";

5281+ description = "Catching all exceptions from within an enclosed computation";

5282+ license = stdenv.lib.licenses.mit;

5283+ }) {};

5284+ "entropy" = callPackage

5285+ ({ mkDerivation, base, bytestring, unix }:

5286+ mkDerivation {

5287+ pname = "entropy";

5288+ version = "0.3.4.1";

5289+ sha256 = "10myxs2a7838sywnlfggpsd7lmvzphl10zdh1vbbi18n3x79gyk0";

5290+ revision = "1";

5291+ editedCabalFile = "1g4hnl4r2a81p787a8llrb1gyxnjfpnrx7ji5fl4hpbxqa30lxx7";

5292+ configureFlags = [

5293+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5294+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5295+ "-fsplitbase" "-f-test-hlint"

5296+ ];

5297+ libraryHaskellDepends = [ base bytestring unix ];

5298+ homepage = "https://github.com/TomMD/entropy";

5299+ description = "A platform independent entropy source";

5300+ license = stdenv.lib.licenses.bsd3;

5301+ }) {};

5302+ "enumerator" = callPackage

5303+ ({ mkDerivation, base, bytestring, containers, text, transformers

5304+ }:

5305+ mkDerivation {

5306+ pname = "enumerator";

5307+ version = "0.4.20";

5308+ sha256 = "02a75dggj295zkhgjry5cb43s6y6ydpjb5w6vgl7kd9b6ma11qik";

5309+ configureFlags = [

5310+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5311+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5312+ "-fsplitbase" "-f-test-hlint"

5313+ ];

5314+ libraryHaskellDepends = [

5315+ base bytestring containers text transformers

5316+ ];

5317+ homepage = "https://john-millikin.com/software/enumerator/";

5318+ description = "Reliable, high-performance processing with left-fold enumerators";

5319+ license = stdenv.lib.licenses.mit;

5320+ }) {};

5321+ "eq" = callPackage

5322+ ({ mkDerivation, base, semigroupoids }:

5323+ mkDerivation {

5324+ pname = "eq";

5325+ version = "4.0.3";

5326+ sha256 = "1n2f20dh1rghv8c43dgdlpgamq61dy8dzh86v4p62a125pgawfn3";

5327+ configureFlags = [

5328+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5329+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5330+ "-fsplitbase" "-f-test-hlint"

5331+ ];

5332+ libraryHaskellDepends = [ base semigroupoids ];

5333+ homepage = "http://github.com/ekmett/eq/";

5334+ description = "Leibnizian equality";

5335+ license = stdenv.lib.licenses.bsd3;

5336+ }) {};

5337+ "erf" = callPackage

5338+ ({ mkDerivation, base }:

5339+ mkDerivation {

5340+ pname = "erf";

5341+ version = "2.0.0.0";

5342+ sha256 = "0dxk2r32ajmmc05vaxcp0yw6vgv4lkbmh8jcshncn98xgsfbgw14";

5343+ configureFlags = [

5344+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5345+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5346+ "-fsplitbase" "-f-test-hlint"

5347+ ];

5348+ libraryHaskellDepends = [ base ];

5349+ description = "The error function, erf, and related functions";

5350+ license = stdenv.lib.licenses.bsd3;

5351+ }) {};

5352+ "errorcall-eq-instance" = callPackage

5353+ ({ mkDerivation, base, hspec, QuickCheck }:

5354+ mkDerivation {

5355+ pname = "errorcall-eq-instance";

5356+ version = "0.1.0";

5357+ sha256 = "1sr2wxbdqzpdawcivvd01nwpki0xbcxylz5qv95b96sq6b296gkk";

5358+ configureFlags = [

5359+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5360+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5361+ "-fsplitbase" "-f-test-hlint"

5362+ ];

5363+ libraryHaskellDepends = [ base ];

5364+ testHaskellDepends = [ base hspec QuickCheck ];

5365+ description = "An orphan Eq instance for ErrorCall";

5366+ license = stdenv.lib.licenses.mit;

5367+ }) {};

5368+ "errors" = callPackage

5369+ ({ mkDerivation, base, either, safe, transformers }:

5370+ mkDerivation {

5371+ pname = "errors";

5372+ version = "1.4.7";

5373+ sha256 = "09g53dylwsw1phxq5zhkbq8pnpwqzipvqclmcrdypzkpwkmfncl7";

5374+ configureFlags = [

5375+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5376+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5377+ "-fsplitbase" "-f-test-hlint"

5378+ ];

5379+ libraryHaskellDepends = [ base either safe transformers ];

5380+ description = "Simplified error-handling";

5381+ license = stdenv.lib.licenses.bsd3;

5382+ }) {};

5383+ "ersatz" = callPackage

5384+ ({ mkDerivation, array, base, blaze-builder, blaze-textual

5385+ , bytestring, containers, data-default, lens, mtl, parsec, process

5386+ , temporary, transformers, unordered-containers

5387+ }:

5388+ mkDerivation {

5389+ pname = "ersatz";

5390+ version = "0.2.6.1";

5391+ sha256 = "1hbn49ycc47f5zjf5zdgls23a8da389ma19g43bc379l8hm2xrjj";

5392+ configureFlags = [

5393+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5394+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5395+ "-fsplitbase" "-f-test-hlint"

5396+ ];

5397+ isLibrary = true;

5398+ isExecutable = true;

5399+ enableSeparateDataOutput = true;

5400+ libraryHaskellDepends = [

5401+ array base blaze-builder blaze-textual bytestring containers

5402+ data-default lens mtl process temporary transformers

5403+ unordered-containers

5404+ ];

5405+ executableHaskellDepends = [

5406+ array base containers lens mtl parsec

5407+ ];

5408+ doHaddock = false;

5409+ doCheck = false;

5410+ homepage = "http://github.com/ekmett/ersatz";

5411+ description = "A monad for expressing SAT or QSAT problems using observable sharing";

5412+ license = stdenv.lib.licenses.bsd3;

5413+ }) {};

5414+ "esqueleto" = callPackage

5415+ ({ mkDerivation, base, conduit, containers, hspec, HUnit

5416+ , monad-control, monad-logger, persistent, persistent-sqlite

5417+ , persistent-template, QuickCheck, resourcet, tagged, text

5418+ , transformers, unordered-containers

5419+ }:

5420+ mkDerivation {

5421+ pname = "esqueleto";

5422+ version = "2.1.2.1";

5423+ sha256 = "0lynhkbrxxrngvdj5d4xlmi92s4m3dzdpd7gs1k408slil2i7r7i";

5424+ configureFlags = [

5425+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5426+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5427+ "-fsplitbase" "-f-test-hlint"

5428+ ];

5429+ libraryHaskellDepends = [

5430+ base conduit monad-logger persistent resourcet tagged text

5431+ transformers unordered-containers

5432+ ];

5433+ testHaskellDepends = [

5434+ base conduit containers hspec HUnit monad-control monad-logger

5435+ persistent persistent-sqlite persistent-template QuickCheck

5436+ resourcet text transformers

5437+ ];

5438+ homepage = "https://github.com/prowdsponsor/esqueleto";

5439+ description = "Type-safe EDSL for SQL queries on persistent backends";

5440+ license = stdenv.lib.licenses.bsd3;

5441+ }) {};

5442+ "ex-pool" = callPackage

5443+ ({ mkDerivation, base, exceptions, hashable, stm, time

5444+ , transformers, vector

5445+ }:

5446+ mkDerivation {

5447+ pname = "ex-pool";

5448+ version = "0.2";

5449+ sha256 = "0da5grl2fdca24zhlngq2n16smdb4f5vvxqzc29ipsc3j7wkbmva";

5450+ configureFlags = [

5451+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5452+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5453+ "-fsplitbase" "-f-test-hlint"

5454+ ];

5455+ libraryHaskellDepends = [

5456+ base exceptions hashable stm time transformers vector

5457+ ];

5458+ homepage = "https://github.com/kim/ex-pool";

5459+ description = "Another fork of resource-pool, with a MonadIO and MonadCatch constraint";

5460+ license = stdenv.lib.licenses.bsd3;

5461+ }) {};

5462+ "exception-transformers" = callPackage

5463+ ({ mkDerivation, base, HUnit, stm, test-framework

5464+ , test-framework-hunit, transformers

5465+ }:

5466+ mkDerivation {

5467+ pname = "exception-transformers";

5468+ version = "0.3.0.4";

5469+ sha256 = "1m4mwgzynymdjvrrrvl90q468pgwik07yy2lsff9spxhcd43w2ra";

5470+ configureFlags = [

5471+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5472+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5473+ "-fsplitbase" "-f-test-hlint"

5474+ ];

5475+ libraryHaskellDepends = [ base stm transformers ];

5476+ testHaskellDepends = [

5477+ base HUnit test-framework test-framework-hunit transformers

5478+ ];

5479+ homepage = "http://www.cs.drexel.edu/~mainland/";

5480+ description = "Type classes and monads for unchecked extensible exceptions";

5481+ license = stdenv.lib.licenses.bsd3;

5482+ }) {};

5483+ "exceptions" = callPackage

5484+ ({ mkDerivation, base, mtl, QuickCheck, test-framework

5485+ , test-framework-quickcheck2, transformers

5486+ }:

5487+ mkDerivation {

5488+ pname = "exceptions";

5489+ version = "0.6.1";

5490+ sha256 = "09jv5jskv48fd5la1pdvafwc9j2jxj1ncf6yxzkwcjddynbkyszm";

5491+ revision = "1";

5492+ editedCabalFile = "1mn959298hryf3kl3lp7jrp23x7vhffrihhgbr23lq1silq40sp8";

5493+ configureFlags = [

5494+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5495+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5496+ "-fsplitbase" "-f-test-hlint"

5497+ ];

5498+ libraryHaskellDepends = [ base mtl transformers ];

5499+ testHaskellDepends = [

5500+ base mtl QuickCheck test-framework test-framework-quickcheck2

5501+ transformers

5502+ ];

5503+ homepage = "http://github.com/ekmett/exceptions/";

5504+ description = "Extensible optionally-pure exceptions";

5505+ license = stdenv.lib.licenses.bsd3;

5506+ }) {};

5507+ "executable-path" = callPackage

5508+ ({ mkDerivation, base, directory, filepath, unix }:

5509+ mkDerivation {

5510+ pname = "executable-path";

5511+ version = "0.0.3";

5512+ sha256 = "1jg58qf19qz93c60ryglcavwdcysz4fd4qn8kpw5im9w9kniawlc";

5513+ configureFlags = [

5514+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5515+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5516+ "-fsplitbase" "-f-test-hlint"

5517+ ];

5518+ libraryHaskellDepends = [ base directory filepath unix ];

5519+ homepage = "http://code.haskell.org/~bkomuves/";

5520+ description = "Finding out the full path of the executable";

5521+ license = stdenv.lib.licenses.publicDomain;

5522+ }) {};

5523+ "extensible-exceptions" = callPackage

5524+ ({ mkDerivation, base }:

5525+ mkDerivation {

5526+ pname = "extensible-exceptions";

5527+ version = "0.1.1.4";

5528+ sha256 = "1273nqws9ij1rp1bsq5jc7k2jxpqa0svawdbim05lf302y0firbc";

5529+ configureFlags = [

5530+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5531+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5532+ "-fsplitbase" "-f-test-hlint"

5533+ ];

5534+ libraryHaskellDepends = [ base ];

5535+ description = "Extensible exceptions";

5536+ license = stdenv.lib.licenses.bsd3;

5537+ }) {};

5538+ "extra" = callPackage

5539+ ({ mkDerivation, base, directory, filepath, process, QuickCheck

5540+ , time, unix

5541+ }:

5542+ mkDerivation {

5543+ pname = "extra";

5544+ version = "1.0";

5545+ sha256 = "0ainwq8f2mp1wc30srl971xy4qnrcyrcyig1kmrxx951hgav1dkb";

5546+ revision = "2";

5547+ editedCabalFile = "1dyd3bjpkgzszv0mc77l3f97k22lqcq08y538y50rjjb5cvkwffl";

5548+ configureFlags = [

5549+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5550+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5551+ "-fsplitbase" "-f-test-hlint"

5552+ ];

5553+ libraryHaskellDepends = [

5554+ base directory filepath process time unix

5555+ ];

5556+ testHaskellDepends = [

5557+ base directory filepath QuickCheck time unix

5558+ ];

5559+ homepage = "https://github.com/ndmitchell/extra#readme";

5560+ description = "Extra functions I use";

5561+ license = stdenv.lib.licenses.bsd3;

5562+ }) {};

5563+ "failure" = callPackage

5564+ ({ mkDerivation, base, transformers }:

5565+ mkDerivation {

5566+ pname = "failure";

5567+ version = "0.2.0.3";

5568+ sha256 = "0jimc2x46zq7wnmzfbnqi67jl8yhbvr0fa65ljlc9p3fns9mca3p";

5569+ configureFlags = [

5570+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5571+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5572+ "-fsplitbase" "-f-test-hlint"

5573+ ];

5574+ libraryHaskellDepends = [ base transformers ];

5575+ homepage = "http://www.haskell.org/haskellwiki/Failure";

5576+ description = "A simple type class for success/failure computations. (deprecated)";

5577+ license = stdenv.lib.licenses.bsd3;

5578+ }) {};

5579+ "fast-logger" = callPackage

5580+ ({ mkDerivation, array, auto-update, base, blaze-builder

5581+ , bytestring, directory, filepath, hspec, text

5582+ }:

5583+ mkDerivation {

5584+ pname = "fast-logger";

5585+ version = "2.2.3";

5586+ sha256 = "0zap61gz0snbq42h8nyjh637fr2cm1ny9f77sqd6v3yfqjq0ljh3";

5587+ revision = "1";

5588+ editedCabalFile = "0f9m99f68dk5m6iy7lbzif000l9imijpqygixgdhx0wfpards7xr";

5589+ configureFlags = [

5590+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5591+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5592+ "-fsplitbase" "-f-test-hlint"

5593+ ];

5594+ libraryHaskellDepends = [

5595+ array auto-update base blaze-builder bytestring directory filepath

5596+ text

5597+ ];

5598+ testHaskellDepends = [ base bytestring directory hspec ];

5599+ description = "A fast logging system";

5600+ license = stdenv.lib.licenses.bsd3;

5601+ }) {};

5602+ "fay" = callPackage

5603+ ({ mkDerivation, aeson, base, bytestring, containers, data-default

5604+ , directory, filepath, ghc-paths, haskell-names, haskell-packages

5605+ , haskell-src-exts, language-ecmascript, mtl, optparse-applicative

5606+ , process, safe, sourcemap, split, spoon, syb, text, time

5607+ , transformers, uniplate, unordered-containers, utf8-string, vector

5608+ }:

5609+ mkDerivation {

5610+ pname = "fay";

5611+ version = "0.21.2.1";

5612+ sha256 = "06ijfkm1x5a15hac9f4cs4f16rva2hkf07xfh0mm9q3wkamqxlfm";

5613+ configureFlags = [

5614+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5615+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5616+ "-fsplitbase" "-f-test-hlint"

5617+ ];

5618+ isLibrary = true;

5619+ isExecutable = true;

5620+ enableSeparateDataOutput = true;

5621+ libraryHaskellDepends = [

5622+ aeson base bytestring containers data-default directory filepath

5623+ ghc-paths haskell-names haskell-packages haskell-src-exts

5624+ language-ecmascript mtl process safe sourcemap split spoon syb text

5625+ time transformers uniplate unordered-containers utf8-string vector

5626+ ];

5627+ executableHaskellDepends = [ base mtl optparse-applicative split ];

5628+ homepage = "https://github.com/faylang/fay/wiki";

5629+ description = "A compiler for Fay, a Haskell subset that compiles to JavaScript";

5630+ license = stdenv.lib.licenses.bsd3;

5631+ }) {};

5632+ "fay-base" = callPackage

5633+ ({ mkDerivation, base, fay }:

5634+ mkDerivation {

5635+ pname = "fay-base";

5636+ version = "0.19.4.1";

5637+ sha256 = "1pk1jjwyh2n9fg583v4cd0ll5qglphwnfm08q95klcvc61p4wqg6";

5638+ configureFlags = [

5639+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5640+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5641+ "-fsplitbase" "-f-test-hlint"

5642+ ];

5643+ enableSeparateDataOutput = true;

5644+ libraryHaskellDepends = [ base fay ];

5645+ homepage = "https://github.com/faylang/fay/";

5646+ description = "The base package for Fay";

5647+ license = stdenv.lib.licenses.bsd3;

5648+ }) {};

5649+ "fay-builder" = callPackage

5650+ ({ mkDerivation, base, Cabal, data-default, directory, fay

5651+ , filepath, safe, split, text

5652+ }:

5653+ mkDerivation {

5654+ pname = "fay-builder";

5655+ version = "0.2.0.1";

5656+ sha256 = "1p8mg6g20jsnvkf3fl02wf757nw23hccwx2br9k8w4z60p9mvw6b";

5657+ configureFlags = [

5658+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5659+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5660+ "-fsplitbase" "-f-test-hlint"

5661+ ];

5662+ libraryHaskellDepends = [

5663+ base Cabal data-default directory fay filepath safe split text

5664+ ];

5665+ description = "Compile Fay code on cabal install, and ad-hoc recompile during development";

5666+ license = stdenv.lib.licenses.bsd3;

5667+ }) {};

5668+ "fay-dom" = callPackage

5669+ ({ mkDerivation, fay-base }:

5670+ mkDerivation {

5671+ pname = "fay-dom";

5672+ version = "0.5";

5673+ sha256 = "1r8kl6wbrl516qc29zs93png922p7zzg2lagvkcf2cb506qg1mr1";

5674+ configureFlags = [

5675+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5676+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5677+ "-fsplitbase" "-f-test-hlint"

5678+ ];

5679+ enableSeparateDataOutput = true;

5680+ libraryHaskellDepends = [ fay-base ];

5681+ homepage = "https://github.com/faylang/fay-dom";

5682+ description = "DOM FFI wrapper library for Fay";

5683+ license = stdenv.lib.licenses.bsd3;

5684+ }) {};

5685+ "fay-jquery" = callPackage

5686+ ({ mkDerivation, fay-base, fay-text }:

5687+ mkDerivation {

5688+ pname = "fay-jquery";

5689+ version = "0.6.0.2";

5690+ sha256 = "1gif4sd0qvb1jkl4j2iv0gqyyrkz9brfwcj9vv9sldqx0lmxkvpm";

5691+ configureFlags = [

5692+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5693+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5694+ "-fsplitbase" "-f-test-hlint"

5695+ ];

5696+ enableSeparateDataOutput = true;

5697+ libraryHaskellDepends = [ fay-base fay-text ];

5698+ homepage = "https://github.com/faylang/fay-jquery";

5699+ description = "jQuery bindings for Fay";

5700+ license = stdenv.lib.licenses.bsd3;

5701+ }) {};

5702+ "fay-text" = callPackage

5703+ ({ mkDerivation, fay, fay-base, text }:

5704+ mkDerivation {

5705+ pname = "fay-text";

5706+ version = "0.3.2";

5707+ sha256 = "1yjsn188ixpfqdr75xyl57rbv53dybik4g28h6p3jv73q494552m";

5708+ configureFlags = [

5709+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5710+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5711+ "-fsplitbase" "-f-test-hlint"

5712+ ];

5713+ enableSeparateDataOutput = true;

5714+ libraryHaskellDepends = [ fay fay-base text ];

5715+ homepage = "https://github.com/faylang/fay-text";

5716+ description = "Fay Text type represented as JavaScript strings";

5717+ license = stdenv.lib.licenses.mit;

5718+ }) {};

5719+ "fay-uri" = callPackage

5720+ ({ mkDerivation, fay-base }:

5721+ mkDerivation {

5722+ pname = "fay-uri";

5723+ version = "0.2.0.0";

5724+ sha256 = "1vv4jgkz9cx8inbn6g6sn3a0nf1ak81qlj5li21sk2isj0yws1nr";

5725+ configureFlags = [

5726+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5727+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5728+ "-fsplitbase" "-f-test-hlint"

5729+ ];

5730+ enableSeparateDataOutput = true;

5731+ libraryHaskellDepends = [ fay-base ];

5732+ homepage = "https://github.com/faylang/fay-uri";

5733+ description = "Persistent FFI bindings for using jsUri in Fay";

5734+ license = stdenv.lib.licenses.bsd3;

5735+ }) {};

5736+ "fb" = callPackage

5737+ ({ mkDerivation, aeson, attoparsec, base, base16-bytestring

5738+ , base64-bytestring, bytestring, cereal, conduit, conduit-extra

5739+ , crypto-api, cryptohash, cryptohash-cryptoapi, data-default

5740+ , http-conduit, http-types, lifted-base, monad-control

5741+ , monad-logger, old-locale, resourcet, text, time, transformers

5742+ , transformers-base, unordered-containers

5743+ }:

5744+ mkDerivation {

5745+ pname = "fb";

5746+ version = "1.0.7";

5747+ sha256 = "0ghyddxf4aqidqvbm93pjgaban0whfj4y1w11b7nxy89srhyjhh8";

5748+ revision = "1";

5749+ editedCabalFile = "035y07f8kk5ngccvi0rcqg6gaizamgh9xm6b6lz6yr36y1262zz0";

5750+ configureFlags = [

5751+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5752+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5753+ "-fsplitbase" "-f-test-hlint"

5754+ ];

5755+ libraryHaskellDepends = [

5756+ aeson attoparsec base base16-bytestring base64-bytestring

5757+ bytestring cereal conduit conduit-extra crypto-api cryptohash

5758+ cryptohash-cryptoapi data-default http-conduit http-types

5759+ lifted-base monad-control monad-logger old-locale resourcet text

5760+ time transformers transformers-base unordered-containers

5761+ ];

5762+ doHaddock = false;

5763+ doCheck = false;

5764+ homepage = "https://github.com/prowdsponsor/fb";

5765+ description = "Bindings to Facebook's API";

5766+ license = stdenv.lib.licenses.bsd3;

5767+ }) {};

5768+ "fb-persistent" = callPackage

5769+ ({ mkDerivation, base, cereal, fb, persistent, text, time }:

5770+ mkDerivation {

5771+ pname = "fb-persistent";

5772+ version = "0.3.4";

5773+ sha256 = "07hrifzwvv7fzqh70igfbxzn854yvyx7406s8byn0arhmp21ka3b";

5774+ configureFlags = [

5775+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5776+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5777+ "-fsplitbase" "-f-test-hlint"

5778+ ];

5779+ libraryHaskellDepends = [ base cereal fb persistent text time ];

5780+ homepage = "https://github.com/prowdsponsor/fb-persistent";

5781+ description = "Provides Persistent instances to Facebook types";

5782+ license = stdenv.lib.licenses.bsd3;

5783+ }) {};

5784+ "fclabels" = callPackage

5785+ ({ mkDerivation, base, mtl, template-haskell, transformers }:

5786+ mkDerivation {

5787+ pname = "fclabels";

5788+ version = "2.0.2";

5789+ sha256 = "108ad6l8ibz44n000hlywqpqslsz1czmsal7qvbd53chmmm4xgdp";

5790+ configureFlags = [

5791+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5792+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5793+ "-fsplitbase" "-f-test-hlint"

5794+ ];

5795+ libraryHaskellDepends = [ base mtl template-haskell transformers ];

5796+ homepage = "https://github.com/sebastiaanvisser/fclabels";

5797+ description = "First class accessor labels implemented as lenses";

5798+ license = stdenv.lib.licenses.bsd3;

5799+ }) {};

5800+ "fgl" = callPackage

5801+ ({ mkDerivation, array, base, containers, mtl }:

5802+ mkDerivation {

5803+ pname = "fgl";

5804+ version = "5.5.0.1";

5805+ sha256 = "0qw70f5hfrxmrx49wx8vk2f5cam7jbpb20mp4i0ybcwdld5ncqda";

5806+ revision = "1";

5807+ editedCabalFile = "0rcgswgwz4i2584vgcsqgsiag368vw787hlk3fd0ncn3hsgnr09z";

5808+ configureFlags = [

5809+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5810+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5811+ "-fsplitbase" "-f-test-hlint"

5812+ ];

5813+ libraryHaskellDepends = [ array base containers mtl ];

5814+ homepage = "http://web.engr.oregonstate.edu/~erwig/fgl/haskell";

5815+ description = "Martin Erwig's Functional Graph Library";

5816+ license = stdenv.lib.licenses.bsd3;

5817+ }) {};

5818+ "file-embed" = callPackage

5819+ ({ mkDerivation, base, bytestring, directory, filepath, HUnit

5820+ , template-haskell

5821+ }:

5822+ mkDerivation {

5823+ pname = "file-embed";

5824+ version = "0.0.7";

5825+ sha256 = "0mj8f70f9k78wjzcx59w68szajafmm119rcrsspmxsygglh8ji2g";

5826+ configureFlags = [

5827+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5828+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5829+ "-fsplitbase" "-f-test-hlint"

5830+ ];

5831+ libraryHaskellDepends = [

5832+ base bytestring directory filepath template-haskell

5833+ ];

5834+ testHaskellDepends = [ base filepath HUnit ];

5835+ homepage = "https://github.com/snoyberg/file-embed";

5836+ description = "Use Template Haskell to embed file contents directly";

5837+ license = stdenv.lib.licenses.bsd3;

5838+ }) {};

5839+ "file-location" = callPackage

5840+ ({ mkDerivation, base, containers, lifted-base, process

5841+ , template-haskell, transformers

5842+ }:

5843+ mkDerivation {

5844+ pname = "file-location";

5845+ version = "0.4.5.3";

5846+ sha256 = "0d1iqhdac1gcag1d7ch9ia4fm97jpp31m46b794z90bmm6nr29h9";

5847+ configureFlags = [

5848+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5849+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5850+ "-fsplitbase" "-f-test-hlint"

5851+ ];

5852+ libraryHaskellDepends = [

5853+ base containers lifted-base template-haskell transformers

5854+ ];

5855+ testHaskellDepends = [

5856+ base containers lifted-base process template-haskell transformers

5857+ ];

5858+ homepage = "https://github.com/gregwebs/FileLocation.hs";

5859+ description = "common functions that show file location information";

5860+ license = stdenv.lib.licenses.bsd3;

5861+ }) {};

5862+ "filemanip" = callPackage

5863+ ({ mkDerivation, base, bytestring, directory, filepath, mtl

5864+ , unix-compat

5865+ }:

5866+ mkDerivation {

5867+ pname = "filemanip";

5868+ version = "0.3.6.2";

5869+ sha256 = "03l114rhb4f6nyzs9w14i79d7kyyq9ia542alsqpbmikm9gxm4rz";

5870+ revision = "1";

5871+ editedCabalFile = "0izpy3szg42rah17c94y75yszk74ba7dhxnpk79kgwmh6a38j71v";

5872+ configureFlags = [

5873+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5874+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5875+ "-fsplitbase" "-f-test-hlint"

5876+ ];

5877+ libraryHaskellDepends = [

5878+ base bytestring directory filepath mtl unix-compat

5879+ ];

5880+ homepage = "https://github.com/bos/filemanip";

5881+ description = "Expressive file and directory manipulation for Haskell";

5882+ license = stdenv.lib.licenses.bsd3;

5883+ }) {};

5884+ "fingertree" = callPackage

5885+ ({ mkDerivation, base, HUnit, QuickCheck, test-framework

5886+ , test-framework-hunit, test-framework-quickcheck2

5887+ }:

5888+ mkDerivation {

5889+ pname = "fingertree";

5890+ version = "0.1.0.0";

5891+ sha256 = "0c35sryzsijwavvw9x1pk5p99rhmp4g8pjh2ds419mlfgxc039ms";

5892+ configureFlags = [

5893+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5894+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5895+ "-fsplitbase" "-f-test-hlint"

5896+ ];

5897+ libraryHaskellDepends = [ base ];

5898+ testHaskellDepends = [

5899+ base HUnit QuickCheck test-framework test-framework-hunit

5900+ test-framework-quickcheck2

5901+ ];

5902+ description = "Generic finger-tree structure, with example instances";

5903+ license = stdenv.lib.licenses.bsd3;

5904+ }) {};

5905+ "fixed" = callPackage

5906+ ({ mkDerivation, base }:

5907+ mkDerivation {

5908+ pname = "fixed";

5909+ version = "0.2.1";

5910+ sha256 = "1ayfya62ngcyyhi736fl5cd39iw568lkl16j4mliw3mi1cs2cic0";

5911+ revision = "1";

5912+ editedCabalFile = "10399igiipvv6s45l9iww08svlk5kp0ps8v4pr7dcxn4cl9wrp7b";

5913+ configureFlags = [

5914+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5915+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5916+ "-fsplitbase" "-f-test-hlint"

5917+ ];

5918+ libraryHaskellDepends = [ base ];

5919+ homepage = "http://github.com/ekmett/fixed";

5920+ description = "Signed 15.16 precision fixed point arithmetic";

5921+ license = stdenv.lib.licenses.bsd3;

5922+ }) {};

5923+ "fixed-list" = callPackage

5924+ ({ mkDerivation, base }:

5925+ mkDerivation {

5926+ pname = "fixed-list";

5927+ version = "0.1.5";

5928+ sha256 = "07b1kzysf96jckx7yghb2a93l884x8fvxxd0g2ja3hwb5y403911";

5929+ configureFlags = [

5930+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5931+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5932+ "-fsplitbase" "-f-test-hlint"

5933+ ];

5934+ libraryHaskellDepends = [ base ];

5935+ homepage = "http://github.com/jvranish/FixedList/tree/master";

5936+ description = "A fixed length list type";

5937+ license = stdenv.lib.licenses.bsd3;

5938+ }) {};

5939+ "flexible-defaults" = callPackage

5940+ ({ mkDerivation, base, containers, template-haskell, th-extras

5941+ , transformers

5942+ }:

5943+ mkDerivation {

5944+ pname = "flexible-defaults";

5945+ version = "0.0.1.1";

5946+ sha256 = "0cbp8hb7y29xz3hl780173cs6ca4df0r98fz7v3drqr46aq55ipl";

5947+ configureFlags = [

5948+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5949+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5950+ "-fsplitbase" "-f-test-hlint"

5951+ ];

5952+ libraryHaskellDepends = [

5953+ base containers template-haskell th-extras transformers

5954+ ];

5955+ homepage = "https://github.com/mokus0/flexible-defaults";

5956+ description = "Generate default function implementations for complex type classes";

5957+ license = stdenv.lib.licenses.publicDomain;

5958+ }) {};

5959+ "focus" = callPackage

5960+ ({ mkDerivation, base }:

5961+ mkDerivation {

5962+ pname = "focus";

5963+ version = "0.1.3";

5964+ sha256 = "11l6rlr22m0z41c9fynpisj0cnx70zzcxhsakz9b09ap8wj0raqy";

5965+ revision = "1";

5966+ editedCabalFile = "0p35inljpw01402xm3pw1is0d2g2l6cmvw9f4xd1asbxgravxvzc";

5967+ configureFlags = [

5968+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5969+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5970+ "-fsplitbase" "-f-test-hlint"

5971+ ];

5972+ libraryHaskellDepends = [ base ];

5973+ doHaddock = false;

5974+ doCheck = false;

5975+ homepage = "https://github.com/nikita-volkov/focus";

5976+ description = "A general abstraction for manipulating elements of container data structures";

5977+ license = stdenv.lib.licenses.mit;

5978+ }) {};

5979+ "foldl" = callPackage

5980+ ({ mkDerivation, base, bytestring, containers, primitive, text

5981+ , transformers, vector

5982+ }:

5983+ mkDerivation {

5984+ pname = "foldl";

5985+ version = "1.0.7";

5986+ sha256 = "0mqxibifrlfqnibzy9b2rncy4dyljdz35560ni3rwi8hkyix74a9";

5987+ revision = "1";

5988+ editedCabalFile = "1v6fiikb4xwkhqf32w7dcrc00asa07w4yks0x6a52mmyqz9r9xh0";

5989+ configureFlags = [

5990+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5991+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5992+ "-fsplitbase" "-f-test-hlint"

5993+ ];

5994+ libraryHaskellDepends = [

5995+ base bytestring containers primitive text transformers vector

5996+ ];

5997+ description = "Composable, streaming, and efficient left folds";

5998+ license = stdenv.lib.licenses.bsd3;

5999+ }) {};

6000+ "force-layout" = callPackage

6001+ ({ mkDerivation, base, containers, data-default-class, lens

6002+ , vector-space, vector-space-points

6003+ }:

6004+ mkDerivation {

6005+ pname = "force-layout";

6006+ version = "0.3.0.8";

6007+ sha256 = "00b831l94r3lx0b330ql3w551w0fwziayhsjydzbfqq335syaaxg";

6008+ configureFlags = [

6009+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6010+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6011+ "-fsplitbase" "-f-test-hlint"

6012+ ];

6013+ libraryHaskellDepends = [

6014+ base containers data-default-class lens vector-space

6015+ vector-space-points

6016+ ];

6017+ description = "Simple force-directed layout";

6018+ license = stdenv.lib.licenses.bsd3;

6019+ }) {};

6020+ "foreign-store" = callPackage

6021+ ({ mkDerivation, base }:

6022+ mkDerivation {

6023+ pname = "foreign-store";

6024+ version = "0.1";

6025+ sha256 = "1p7hsr1kg1667wql9c18q7bwpnrldnb8r18ijhji5c7qqr8yml5g";

6026+ configureFlags = [

6027+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6028+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6029+ "-fsplitbase" "-f-test-hlint"

6030+ ];

6031+ libraryHaskellDepends = [ base ];

6032+ homepage = "https://github.com/chrisdone/foreign-store";

6033+ description = "Store a stable pointer in a foreign context to be retrieved later. Persists through GHCi reloads.";

6034+ license = stdenv.lib.licenses.bsd3;

6035+ }) {};

6036+ "formatting" = callPackage

6037+ ({ mkDerivation, base, old-locale, scientific, text, text-format

6038+ , time

6039+ }:

6040+ mkDerivation {

6041+ pname = "formatting";

6042+ version = "5.4";

6043+ sha256 = "017fm3pqr2nqpcqmpldr74cvb641hxvybhvnwv8a8vv4ry1vdrk9";

6044+ revision = "1";

6045+ editedCabalFile = "11x0qcvf7s4x8g7k4ih7rq1qbmqnnl4j7hlz5n4l82lc977s83vw";

6046+ configureFlags = [

6047+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6048+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6049+ "-fsplitbase" "-f-test-hlint"

6050+ ];

6051+ libraryHaskellDepends = [

6052+ base old-locale scientific text text-format time

6053+ ];

6054+ description = "Combinator-based type-safe formatting (like printf() or FORMAT)";

6055+ license = stdenv.lib.licenses.bsd3;

6056+ }) {};

6057+ "fpco-api" = callPackage

6058+ ({ mkDerivation, aeson, attoparsec, base, base64-bytestring

6059+ , blaze-html, bytestring, cereal, containers, data-default, deepseq

6060+ , deepseq-generics, directory, failure, fay, filepath, ghc-prim

6061+ , hashable, http-conduit, http-types, ini, lifted-async

6062+ , lifted-base, monad-control, monad-extras, monad-logger, mtl

6063+ , network, optparse-applicative, persistent, persistent-template

6064+ , pretty-show, process, random, resourcet, safe, semigroups

6065+ , shakespeare, shakespeare-i18n, stm, syb, template-haskell, text

6066+ , time, transformers, transformers-base, unordered-containers

6067+ , vector, yesod-core

6068+ }:

6069+ mkDerivation {

6070+ pname = "fpco-api";

6071+ version = "1.2.0.4";

6072+ sha256 = "1hyvnra01c7jqh3n0zpnff6m9z2xjiq6fp4484qb7km58mw1hm2v";

6073+ configureFlags = [

6074+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6075+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6076+ "-fsplitbase" "-f-test-hlint"

6077+ ];

6078+ isLibrary = true;

6079+ isExecutable = true;

6080+ libraryHaskellDepends = [

6081+ aeson attoparsec base base64-bytestring blaze-html bytestring

6082+ cereal containers data-default deepseq deepseq-generics directory

6083+ failure fay filepath ghc-prim hashable http-conduit http-types

6084+ lifted-async lifted-base monad-control monad-extras monad-logger

6085+ mtl network persistent persistent-template pretty-show random

6086+ resourcet safe semigroups shakespeare shakespeare-i18n stm syb

6087+ template-haskell text time transformers transformers-base

6088+ unordered-containers vector yesod-core

6089+ ];

6090+ executableHaskellDepends = [

6091+ aeson base bytestring data-default directory filepath ini network

6092+ optparse-applicative process safe text unordered-containers

6093+ ];

6094+ homepage = "https://www.fpcomplete.com/page/api";

6095+ description = "Simple interface to the FP Complete IDE API";

6096+ license = stdenv.lib.licenses.bsd3;

6097+ }) {};

6098+ "free" = callPackage

6099+ ({ mkDerivation, base, bifunctors, comonad, distributive, mtl

6100+ , prelude-extras, profunctors, semigroupoids, semigroups

6101+ , template-haskell, transformers

6102+ }:

6103+ mkDerivation {

6104+ pname = "free";

6105+ version = "4.9";

6106+ sha256 = "01pa9ax9i4pkh9a5achndx5s7sxvhnk6rm57g8rzav79hzsr4cnx";

6107+ revision = "1";

6108+ editedCabalFile = "17x2nhdcffzk63878zsqxkmmw0rbqasdsqjkba2va080z1ywx10d";

6109+ configureFlags = [

6110+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6111+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6112+ "-fsplitbase" "-f-test-hlint"

6113+ ];

6114+ libraryHaskellDepends = [

6115+ base bifunctors comonad distributive mtl prelude-extras profunctors

6116+ semigroupoids semigroups template-haskell transformers

6117+ ];

6118+ homepage = "http://github.com/ekmett/free/";

6119+ description = "Monads for free";

6120+ license = stdenv.lib.licenses.bsd3;

6121+ }) {};

6122+ "freenect" = callPackage

6123+ ({ mkDerivation, base, freenect, freenect_sync, vector }:

6124+ mkDerivation {

6125+ pname = "freenect";

6126+ version = "1.2";

6127+ sha256 = "11ggp90npdyfdmf8zhjk442zl0j0lni6hizhgc0409za9i6s1l5g";

6128+ configureFlags = [

6129+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6130+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6131+ "-fsplitbase" "-f-test-hlint"

6132+ "--extra-include-dirs=${pkgs.freenect}/include/libfreenect"

6133+ "--extra-lib-dirs=${pkgs.freenect}/lib"

6134+ ];

6135+ libraryHaskellDepends = [ base vector ];

6136+ librarySystemDepends = [ freenect freenect_sync ];

6137+ homepage = "https://github.com/chrisdone/freenect";

6138+ description = "Interface to the Kinect device";

6139+ license = stdenv.lib.licenses.bsd3;

6140+ }) {inherit (pkgs) freenect; freenect_sync = null;};

6141+ "frisby" = callPackage

6142+ ({ mkDerivation, array, base, containers, mtl }:

6143+ mkDerivation {

6144+ pname = "frisby";

6145+ version = "0.2";

6146+ sha256 = "0isj9p7j33va1a4q78vnq32j9jdbjww596rxja235z4whicraf53";

6147+ revision = "1";

6148+ editedCabalFile = "1ip1bykcrnqzfjbsi4gfj59lc24k3kvyn949ryczpqshlpgnbnqj";

6149+ configureFlags = [

6150+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6151+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6152+ "-fsplitbase" "-f-test-hlint"

6153+ ];

6154+ libraryHaskellDepends = [ array base containers mtl ];

6155+ homepage = "http://repetae.net/computer/frisby/";

6156+ description = "Linear time composable parser for PEG grammars";

6157+ license = stdenv.lib.licenses.bsd3;

6158+ }) {};

6159+ "fsnotify" = callPackage

6160+ ({ mkDerivation, async, base, containers, directory, hinotify

6161+ , system-fileio, system-filepath, tasty, tasty-hunit, temporary-rc

6162+ , text, time

6163+ }:

6164+ mkDerivation {

6165+ pname = "fsnotify";

6166+ version = "0.1.0.3";

6167+ sha256 = "0m6jyg45azk377jklgwyqrx95q174cxd5znpyh9azznkh09wq58z";

6168+ configureFlags = [

6169+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6170+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6171+ "-fsplitbase" "-f-test-hlint"

6172+ ];

6173+ libraryHaskellDepends = [

6174+ async base containers hinotify system-fileio system-filepath text

6175+ time

6176+ ];

6177+ testHaskellDepends = [

6178+ async base directory system-fileio system-filepath tasty

6179+ tasty-hunit temporary-rc

6180+ ];

6181+ doHaddock = false;

6182+ doCheck = false;

6183+ description = "Cross platform library for file change notification";

6184+ license = stdenv.lib.licenses.bsd3;

6185+ }) {};

6186+ "fuzzcheck" = callPackage

6187+ ({ mkDerivation, base, hspec, hspec-expectations, HUnit

6188+ , lifted-base, monad-control, QuickCheck, random, transformers

6189+ }:

6190+ mkDerivation {

6191+ pname = "fuzzcheck";

6192+ version = "0.1.1";

6193+ sha256 = "0qfr4f0b50l368b45yzwhqd4g2y1kvfrfj4hr84cdxcwdrwn9mpc";

6194+ configureFlags = [

6195+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6196+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6197+ "-fsplitbase" "-f-test-hlint"

6198+ ];

6199+ libraryHaskellDepends = [

6200+ base lifted-base monad-control QuickCheck random transformers

6201+ ];

6202+ testHaskellDepends = [

6203+ base hspec hspec-expectations HUnit QuickCheck

6204+ ];

6205+ homepage = "https://github.com/fpco/fuzzcheck";

6206+ description = "A simple checker for stress testing monadic code";

6207+ license = stdenv.lib.licenses.bsd3;

6208+ }) {};

6209+ "gd" = callPackage

6210+ ({ mkDerivation, base, bytestring, expat, fontconfig, freetype, gd

6211+ , libjpeg, libpng, zlib

6212+ }:

6213+ mkDerivation {

6214+ pname = "gd";

6215+ version = "3000.7.3";

6216+ sha256 = "1dkzv6zs00qi0jmblkw05ywizc8y3baz7pnz0lcqn1cs1mhcpbhl";

6217+ configureFlags = [

6218+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6219+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6220+ "-fsplitbase" "-f-test-hlint"

6221+ ];

6222+ libraryHaskellDepends = [ base bytestring ];

6223+ librarySystemDepends = [

6224+ expat fontconfig freetype gd libjpeg libpng zlib

6225+ ];

6226+ description = "A Haskell binding to a subset of the GD graphics library";

6227+ license = stdenv.lib.licenses.bsd3;

6228+ }) {inherit (pkgs) expat; inherit (pkgs) fontconfig;

6229+ inherit (pkgs) freetype; inherit (pkgs) gd; inherit (pkgs) libjpeg;

6230+ inherit (pkgs) libpng; inherit (pkgs) zlib;};

6231+ "generic-aeson" = callPackage

6232+ ({ mkDerivation, aeson, attoparsec, base, generic-deriving, mtl

6233+ , tagged, text, unordered-containers, vector

6234+ }:

6235+ mkDerivation {

6236+ pname = "generic-aeson";

6237+ version = "0.2.0.2";

6238+ sha256 = "1x58c7xgdc1asg4n61fpikn7jvspyqawykq4q49xhsp5dp11lzzh";

6239+ revision = "2";

6240+ editedCabalFile = "1vxmhq6wmxwb9m1br2raq2vzsvyp5s9l2jq87ahgm1fjqnayysyi";

6241+ configureFlags = [

6242+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6243+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6244+ "-fsplitbase" "-f-test-hlint"

6245+ ];

6246+ libraryHaskellDepends = [

6247+ aeson attoparsec base generic-deriving mtl tagged text

6248+ unordered-containers vector

6249+ ];

6250+ description = "Derivation of Aeson instances using GHC generics";

6251+ license = stdenv.lib.licenses.bsd3;

6252+ }) {};

6253+ "generic-deriving" = callPackage

6254+ ({ mkDerivation, base, ghc-prim, template-haskell }:

6255+ mkDerivation {

6256+ pname = "generic-deriving";

6257+ version = "1.6.3";

6258+ sha256 = "04cjyl5aphf36qbbn75midrqj151fc77z2znpal8dk52gaab2f67";

6259+ configureFlags = [

6260+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6261+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6262+ "-fsplitbase" "-f-test-hlint"

6263+ ];

6264+ libraryHaskellDepends = [ base ghc-prim template-haskell ];

6265+ description = "Generic programming library for generalised deriving";

6266+ license = stdenv.lib.licenses.bsd3;

6267+ }) {};

6268+ "generics-sop" = callPackage

6269+ ({ mkDerivation, base, ghc-prim, template-haskell }:

6270+ mkDerivation {

6271+ pname = "generics-sop";

6272+ version = "0.1.0.3";

6273+ sha256 = "0wvrav5armspfp6iixns1db45xfpqicx74asi14a2gnl28yqmfpl";

6274+ configureFlags = [

6275+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6276+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6277+ "-fsplitbase" "-f-test-hlint"

6278+ ];

6279+ libraryHaskellDepends = [ base ghc-prim template-haskell ];

6280+ description = "Generic Programming using True Sums of Products";

6281+ license = stdenv.lib.licenses.bsd3;

6282+ }) {};

6283+ "ghc-heap-view" = callPackage

6284+ ({ mkDerivation, base, binary, bytestring, containers, deepseq, ghc

6285+ , template-haskell, transformers

6286+ }:

6287+ mkDerivation {

6288+ pname = "ghc-heap-view";

6289+ version = "0.5.3";

6290+ sha256 = "1jcqi4gahxmhd61hl75wgb9dp99kxld68860jnd9x4hnp5cd33q0";

6291+ configureFlags = [

6292+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6293+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6294+ "-fsplitbase" "-f-test-hlint"

6295+ ];

6296+ enableSeparateDataOutput = true;

6297+ libraryHaskellDepends = [

6298+ base binary bytestring containers ghc template-haskell transformers

6299+ ];

6300+ testHaskellDepends = [ base deepseq ];

6301+ description = "Extract the heap representation of Haskell values and thunks";

6302+ license = stdenv.lib.licenses.bsd3;

6303+ }) {};

6304+ "ghc-mod" = callPackage

6305+ ({ mkDerivation, async, base, Cabal, containers, data-default

6306+ , deepseq, directory, djinn-ghc, doctest, filepath, ghc, ghc-paths

6307+ , ghc-syb-utils, haskell-src-exts, hlint, hspec, io-choice

6308+ , monad-control, monad-journal, mtl, old-time, pretty, process

6309+ , split, syb, temporary, text, time, transformers

6310+ , transformers-base

6311+ }:

6312+ mkDerivation {

6313+ pname = "ghc-mod";

6314+ version = "5.2.1.1";

6315+ sha256 = "09dg54970s4n54xxmalr5a2g4r5jnwccl9984shmmv0vsr3h5k26";

6316+ revision = "2";

6317+ editedCabalFile = "0b8k9npdxkh7r2xpdjjfp75d4wxgiyhbzv7g9dc0k7kzc2ffsj55";

6318+ configureFlags = [

6319+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6320+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6321+ "-fsplitbase" "-f-test-hlint"

6322+ ];

6323+ isLibrary = true;

6324+ isExecutable = true;

6325+ enableSeparateDataOutput = true;

6326+ libraryHaskellDepends = [

6327+ base Cabal containers deepseq directory djinn-ghc filepath ghc

6328+ ghc-paths ghc-syb-utils haskell-src-exts hlint io-choice

6329+ monad-control monad-journal mtl old-time pretty process split syb

6330+ temporary text time transformers transformers-base

6331+ ];

6332+ executableHaskellDepends = [

6333+ async base containers data-default directory filepath ghc mtl

6334+ old-time pretty process split time

6335+ ];

6336+ testHaskellDepends = [

6337+ base Cabal containers deepseq directory djinn-ghc doctest filepath

6338+ ghc ghc-paths ghc-syb-utils haskell-src-exts hlint hspec io-choice

6339+ monad-control monad-journal mtl old-time pretty process split syb

6340+ temporary text time transformers transformers-base

6341+ ];

6342+ doHaddock = false;

6343+ doCheck = false;

6344+ homepage = "http://www.mew.org/~kazu/proj/ghc-mod/";

6345+ description = "Happy Haskell Programming";

6346+ license = stdenv.lib.licenses.bsd3;

6347+ }) {};

6348+ "ghc-mtl" = callPackage

6349+ ({ mkDerivation, base, exceptions, extensible-exceptions, ghc, mtl

6350+ }:

6351+ mkDerivation {

6352+ pname = "ghc-mtl";

6353+ version = "1.2.1.0";

6354+ sha256 = "0h6r6gip9nsjlsq88wj105hhqliy7ac2dmmndsfzbjz07b03cklk";

6355+ configureFlags = [

6356+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6357+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6358+ "-fsplitbase" "-f-test-hlint"

6359+ ];

6360+ libraryHaskellDepends = [

6361+ base exceptions extensible-exceptions ghc mtl

6362+ ];

6363+ homepage = "http://hub.darcs.net/jcpetruzza/ghc-mtl";

6364+ description = "An mtl compatible version of the Ghc-Api monads and monad-transformers";

6365+ license = stdenv.lib.licenses.bsd3;

6366+ }) {};

6367+ "ghc-paths" = callPackage

6368+ ({ mkDerivation, base, Cabal, directory }:

6369+ mkDerivation {

6370+ pname = "ghc-paths";

6371+ version = "0.1.0.9";

6372+ sha256 = "0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg";

6373+ revision = "2";

6374+ editedCabalFile = "1gs6biqbcabgmrwhc1bq1bdaxdwwh26v4mpvj5c7cfyigc64gwyk";

6375+ configureFlags = [

6376+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6377+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6378+ "-fsplitbase" "-f-test-hlint"

6379+ ];

6380+ setupHaskellDepends = [ base Cabal directory ];

6381+ libraryHaskellDepends = [ base ];

6382+ description = "Knowledge of GHC's installation directories";

6383+ license = stdenv.lib.licenses.bsd3;

6384+ }) {};

6385+ "ghc-syb-utils" = callPackage

6386+ ({ mkDerivation, base, ghc, syb }:

6387+ mkDerivation {

6388+ pname = "ghc-syb-utils";

6389+ version = "0.2.2";

6390+ sha256 = "03r4x3a4hjivxladlw23jk8s2pgfh85lqf196ks1ngyg6ih1g6lk";

6391+ configureFlags = [

6392+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6393+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6394+ "-fsplitbase" "-f-test-hlint"

6395+ ];

6396+ libraryHaskellDepends = [ base ghc syb ];

6397+ homepage = "http://github.com/nominolo/ghc-syb";

6398+ description = "Scrap Your Boilerplate utilities for the GHC API";

6399+ license = stdenv.lib.licenses.bsd3;

6400+ }) {};

6401+ "ghcid" = callPackage

6402+ ({ mkDerivation, base, cmdargs, directory, extra, filepath, process

6403+ , tasty, tasty-hunit, terminal-size, time

6404+ }:

6405+ mkDerivation {

6406+ pname = "ghcid";

6407+ version = "0.3.2";

6408+ sha256 = "1kx20la4snldhd709y69za8bs57v90nblghfrxrvmzhrmpvh4bn3";

6409+ revision = "1";

6410+ editedCabalFile = "1l30j6nsrxaaaiczpzmcnzpii76i9j9g4djybak38g9r3mh2q9jq";

6411+ configureFlags = [

6412+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6413+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6414+ "-fsplitbase" "-f-test-hlint"

6415+ ];

6416+ isLibrary = true;

6417+ isExecutable = true;

6418+ libraryHaskellDepends = [

6419+ base cmdargs directory extra filepath process terminal-size time

6420+ ];

6421+ executableHaskellDepends = [

6422+ base cmdargs directory extra filepath process terminal-size time

6423+ ];

6424+ testHaskellDepends = [

6425+ base cmdargs directory extra filepath process tasty tasty-hunit

6426+ terminal-size time

6427+ ];

6428+ doHaddock = false;

6429+ doCheck = false;

6430+ homepage = "https://github.com/ndmitchell/ghcid#readme";

6431+ description = "GHCi based bare bones IDE";

6432+ license = stdenv.lib.licenses.bsd3;

6433+ }) {};

6434+ "gio" = callPackage

6435+ ({ mkDerivation, array, base, bytestring, containers, glib

6436+ , gtk2hs-buildtools, mtl, system-glib

6437+ }:

6438+ mkDerivation {

6439+ pname = "gio";

6440+ version = "0.13.0.3";

6441+ sha256 = "15025jj6i1gpvjs46545vzmvs6ka41x15lrllqr9hd0qsyhibsf5";

6442+ configureFlags = [

6443+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6444+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6445+ "-fsplitbase" "-f-test-hlint"

6446+ ];

6447+ enableSeparateDataOutput = true;

6448+ libraryHaskellDepends = [

6449+ array base bytestring containers glib mtl

6450+ ];

6451+ libraryPkgconfigDepends = [ system-glib ];

6452+ libraryToolDepends = [ gtk2hs-buildtools ];

6453+ doHaddock = false;

6454+ doCheck = false;

6455+ homepage = "http://projects.haskell.org/gtk2hs/";

6456+ description = "Binding to the GIO";

6457+ license = stdenv.lib.licenses.lgpl21;

6458+ }) {system-glib = pkgs.glib;};

6459+ "gl" = callPackage

6460+ ({ mkDerivation, base, containers, directory, filepath, fixed, half

6461+ , hxt, mesa, split, transformers

6462+ }:

6463+ mkDerivation {

6464+ pname = "gl";

6465+ version = "0.6.1";

6466+ sha256 = "0wqsbwnp69g6vz5irf65zv1nx4vnlwcm771jxzk70r2wzi2vsg3y";

6467+ configureFlags = [

6468+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6469+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6470+ "-fsplitbase" "-f-test-hlint"

6471+ ];

6472+ libraryHaskellDepends = [

6473+ base containers directory filepath fixed half hxt split

6474+ transformers

6475+ ];

6476+ librarySystemDepends = [ mesa ];

6477+ doHaddock = false;

6478+ doCheck = false;

6479+ description = "Complete OpenGL raw bindings";

6480+ license = stdenv.lib.licenses.bsd3;

6481+ }) {inherit (pkgs) mesa;};

6482+ "glib" = callPackage

6483+ ({ mkDerivation, base, bytestring, containers, glib

6484+ , gtk2hs-buildtools, text, utf8-string

6485+ }:

6486+ mkDerivation {

6487+ pname = "glib";

6488+ version = "0.13.0.6";

6489+ sha256 = "1hn3l0vrz76gmk7bjhs4nw68izf29k0pxm92l0zih7wq5ny4lhrv";

6490+ configureFlags = [

6491+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6492+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6493+ "-fsplitbase" "-f-test-hlint"

6494+ ];

6495+ libraryHaskellDepends = [

6496+ base bytestring containers text utf8-string

6497+ ];

6498+ libraryPkgconfigDepends = [ glib ];

6499+ libraryToolDepends = [ gtk2hs-buildtools ];

6500+ doHaddock = false;

6501+ doCheck = false;

6502+ homepage = "http://projects.haskell.org/gtk2hs/";

6503+ description = "Binding to the GLIB library for Gtk2Hs";

6504+ license = stdenv.lib.licenses.lgpl21;

6505+ }) {inherit (pkgs) glib;};

6506+ "graph-core" = callPackage

6507+ ({ mkDerivation, base, containers, deepseq, hashable, HTF, mtl

6508+ , QuickCheck, safe, unordered-containers, vector

6509+ }:

6510+ mkDerivation {

6511+ pname = "graph-core";

6512+ version = "0.2.1.0";

6513+ sha256 = "0xx99p2i1ng79rph0hkb2dp5r9y77s0y4v8njsywxyq4kbl3ly7f";

6514+ revision = "1";

6515+ editedCabalFile = "0a86rpz2vkg1hr6av4xywch0ccn437ljjw2jrcw1712ma6yv536d";

6516+ configureFlags = [

6517+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6518+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6519+ "-fsplitbase" "-f-test-hlint"

6520+ ];

6521+ libraryHaskellDepends = [

6522+ base containers deepseq hashable mtl QuickCheck safe

6523+ unordered-containers vector

6524+ ];

6525+ testHaskellDepends = [

6526+ base containers deepseq hashable HTF mtl QuickCheck safe

6527+ unordered-containers vector

6528+ ];

6529+ homepage = "https://github.com/factisresearch/graph-core";

6530+ description = "Fast, memory efficient and persistent graph implementation";

6531+ license = stdenv.lib.licenses.mit;

6532+ }) {};

6533+ "graphs" = callPackage

6534+ ({ mkDerivation, array, base, containers, transformers, void }:

6535+ mkDerivation {

6536+ pname = "graphs";

6537+ version = "0.5.0.1";

6538+ sha256 = "1qr5ihf66byq6wq3f6al1i2jrxfi107b5agwck265425mq0jaf9f";

6539+ configureFlags = [

6540+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6541+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6542+ "-fsplitbase" "-f-test-hlint"

6543+ ];

6544+ libraryHaskellDepends = [

6545+ array base containers transformers void

6546+ ];

6547+ homepage = "http://github.com/ekmett/graphs";

6548+ description = "A simple monadic graph library";

6549+ license = stdenv.lib.licenses.bsd3;

6550+ }) {};

6551+ "graphviz" = callPackage

6552+ ({ mkDerivation, base, bytestring, colour, containers, directory

6553+ , dlist, fgl, filepath, polyparse, process, QuickCheck, temporary

6554+ , text, transformers, wl-pprint-text

6555+ }:

6556+ mkDerivation {

6557+ pname = "graphviz";

6558+ version = "2999.17.0.1";

6559+ sha256 = "0s6l1mlqvllrlx7vc06lgcs68ajhfk98awm63ab1dkqmcnj23ixv";

6560+ configureFlags = [

6561+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6562+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6563+ "-fsplitbase" "-f-test-hlint"

6564+ ];

6565+ isLibrary = true;

6566+ isExecutable = true;

6567+ libraryHaskellDepends = [

6568+ base bytestring colour containers directory dlist fgl filepath

6569+ polyparse process temporary text transformers wl-pprint-text

6570+ ];

6571+ executableHaskellDepends = [

6572+ base bytestring directory filepath text

6573+ ];

6574+ testHaskellDepends = [

6575+ base containers fgl filepath QuickCheck text

6576+ ];

6577+ doHaddock = false;

6578+ doCheck = false;

6579+ homepage = "http://projects.haskell.org/graphviz/";

6580+ description = "Bindings to Graphviz for graph visualisation";

6581+ license = stdenv.lib.licenses.bsd3;

6582+ }) {};

6583+ "gravatar" = callPackage

6584+ ({ mkDerivation, base, bytestring, data-default, HTTP, pureMD5

6585+ , text

6586+ }:

6587+ mkDerivation {

6588+ pname = "gravatar";

6589+ version = "0.6";

6590+ sha256 = "035qhrk0s4bpv9xvji4j7w2r98gppn2armz4wjdjy8f50anjpfw3";

6591+ configureFlags = [

6592+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6593+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6594+ "-fsplitbase" "-f-test-hlint"

6595+ ];

6596+ libraryHaskellDepends = [

6597+ base bytestring data-default HTTP pureMD5 text

6598+ ];

6599+ homepage = "http://github.com/pbrisbin/gravatar";

6600+ description = "Look up gravatar image urls by email address";

6601+ license = stdenv.lib.licenses.bsd3;

6602+ }) {};

6603+ "groundhog" = callPackage

6604+ ({ mkDerivation, base, blaze-builder, bytestring, containers

6605+ , monad-control, monad-logger, mtl, text, time, transformers

6606+ , transformers-base

6607+ }:

6608+ mkDerivation {

6609+ pname = "groundhog";

6610+ version = "0.7.0";

6611+ sha256 = "0l86d46ch5ivm3hjdz02rzwj1dijnilksm2i7zrcj7hyhksci2v6";

6612+ revision = "2";

6613+ editedCabalFile = "0ylll9yqm0nr607jd3phfg0h7n8j6sgn1g568nckyq3gikz4mn24";

6614+ configureFlags = [

6615+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6616+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6617+ "-fsplitbase" "-f-test-hlint"

6618+ ];

6619+ libraryHaskellDepends = [

6620+ base blaze-builder bytestring containers monad-control monad-logger

6621+ mtl text time transformers transformers-base

6622+ ];

6623+ homepage = "http://github.com/lykahb/groundhog";

6624+ description = "Type-safe datatype-database mapping library";

6625+ license = stdenv.lib.licenses.bsd3;

6626+ }) {};

6627+ "groundhog-mysql" = callPackage

6628+ ({ mkDerivation, base, bytestring, containers, groundhog

6629+ , monad-control, monad-logger, mysql, mysql-simple, resource-pool

6630+ , text, time, transformers

6631+ }:

6632+ mkDerivation {

6633+ pname = "groundhog-mysql";

6634+ version = "0.7.0";

6635+ sha256 = "1impf72vq2lrf6apcg5lmw9pnrbhk77f83r1a8kp4ssn61zsk6z8";

6636+ configureFlags = [

6637+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6638+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6639+ "-fsplitbase" "-f-test-hlint"

6640+ ];

6641+ libraryHaskellDepends = [

6642+ base bytestring containers groundhog monad-control monad-logger

6643+ mysql mysql-simple resource-pool text time transformers

6644+ ];

6645+ description = "MySQL backend for the groundhog library";

6646+ license = stdenv.lib.licenses.bsd3;

6647+ }) {};

6648+ "groundhog-postgresql" = callPackage

6649+ ({ mkDerivation, attoparsec, base, blaze-builder, bytestring

6650+ , containers, groundhog, monad-control, monad-logger

6651+ , postgresql-libpq, postgresql-simple, resource-pool, text, time

6652+ , transformers

6653+ }:

6654+ mkDerivation {

6655+ pname = "groundhog-postgresql";

6656+ version = "0.7.0";

6657+ sha256 = "05j5188gm183mwzp270m1h4311n4b4cxlz7c3y47p7bjv65daq4a";

6658+ configureFlags = [

6659+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6660+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6661+ "-fsplitbase" "-f-test-hlint"

6662+ ];

6663+ libraryHaskellDepends = [

6664+ attoparsec base blaze-builder bytestring containers groundhog

6665+ monad-control monad-logger postgresql-libpq postgresql-simple

6666+ resource-pool text time transformers

6667+ ];

6668+ description = "PostgreSQL backend for the groundhog library";

6669+ license = stdenv.lib.licenses.bsd3;

6670+ }) {};

6671+ "groundhog-sqlite" = callPackage

6672+ ({ mkDerivation, base, bytestring, containers, direct-sqlite

6673+ , groundhog, monad-control, monad-logger, resource-pool, text

6674+ , transformers, unordered-containers

6675+ }:

6676+ mkDerivation {

6677+ pname = "groundhog-sqlite";

6678+ version = "0.7.0";

6679+ sha256 = "17np5dx8c1z27h8dv4gw2qzqx2qs5l4ars1k0xdqs0xzf745id84";

6680+ configureFlags = [

6681+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6682+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6683+ "-fsplitbase" "-f-test-hlint"

6684+ ];

6685+ libraryHaskellDepends = [

6686+ base bytestring containers direct-sqlite groundhog monad-control

6687+ monad-logger resource-pool text transformers unordered-containers

6688+ ];

6689+ description = "Sqlite3 backend for the groundhog library";

6690+ license = stdenv.lib.licenses.bsd3;

6691+ }) {};

6692+ "groundhog-th" = callPackage

6693+ ({ mkDerivation, aeson, base, bytestring, containers, groundhog

6694+ , template-haskell, text, time, unordered-containers, yaml

6695+ }:

6696+ mkDerivation {

6697+ pname = "groundhog-th";

6698+ version = "0.7.0";

6699+ sha256 = "14g4665wrr3226m2v63p4j8g9bcyi5la7nk2vh509xyz3z17aq67";

6700+ revision = "1";

6701+ editedCabalFile = "1zsiahvfgqxq9kgig46l9hyarg8kwzp1j2hr4671bxs1c1ah1na1";

6702+ configureFlags = [

6703+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6704+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6705+ "-fsplitbase" "-f-test-hlint"

6706+ ];

6707+ libraryHaskellDepends = [

6708+ aeson base bytestring containers groundhog template-haskell text

6709+ time unordered-containers yaml

6710+ ];

6711+ description = "Type-safe datatype-database mapping library";

6712+ license = stdenv.lib.licenses.bsd3;

6713+ }) {};

6714+ "groupoids" = callPackage

6715+ ({ mkDerivation, base, semigroupoids }:

6716+ mkDerivation {

6717+ pname = "groupoids";

6718+ version = "4.0";

6719+ sha256 = "08la44c19pz2clws5mb939zc1d17cb6qy9qlh2n1634pl0zrawb6";

6720+ configureFlags = [

6721+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6722+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6723+ "-fsplitbase" "-f-test-hlint"

6724+ ];

6725+ libraryHaskellDepends = [ base semigroupoids ];

6726+ doHaddock = false;

6727+ doCheck = false;

6728+ homepage = "http://github.com/ekmett/groupoids/";

6729+ description = "This package has been absorbed into semigroupoids 4.0";

6730+ license = stdenv.lib.licenses.bsd3;

6731+ }) {};

6732+ "groups" = callPackage

6733+ ({ mkDerivation, base }:

6734+ mkDerivation {

6735+ pname = "groups";

6736+ version = "0.4.0.0";

6737+ sha256 = "1kp8h3617cimya8nnadljyy4vk66dzl5nzfm900k2gh3ci8kja6k";

6738+ configureFlags = [

6739+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6740+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6741+ "-fsplitbase" "-f-test-hlint"

6742+ ];

6743+ libraryHaskellDepends = [ base ];

6744+ description = "Haskell 98 groups";

6745+ license = stdenv.lib.licenses.bsd3;

6746+ }) {};

6747+ "gtk" = callPackage

6748+ ({ mkDerivation, array, base, bytestring, cairo, containers, gio

6749+ , glib, gtk2, gtk2hs-buildtools, mtl, pango, text

6750+ }:

6751+ mkDerivation {

6752+ pname = "gtk";

6753+ version = "0.13.3";

6754+ sha256 = "016v6r53py659ncx0nvlcvvs3j3kj6rrbrm7lk8sggdhm7jvz6w7";

6755+ configureFlags = [

6756+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6757+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6758+ "-fsplitbase" "-f-test-hlint"

6759+ ];

6760+ enableSeparateDataOutput = true;

6761+ libraryHaskellDepends = [

6762+ array base bytestring cairo containers gio glib mtl pango text

6763+ ];

6764+ libraryPkgconfigDepends = [ gtk2 ];

6765+ libraryToolDepends = [ gtk2hs-buildtools ];

6766+ doHaddock = false;

6767+ doCheck = false;

6768+ homepage = "http://projects.haskell.org/gtk2hs/";

6769+ description = "Binding to the Gtk+ graphical user interface library";

6770+ license = stdenv.lib.licenses.lgpl21;

6771+ }) {gtk2 = pkgs.gnome2.gtk;};

6772+ "gtk2hs-buildtools" = callPackage

6773+ ({ mkDerivation, alex, array, base, containers, directory, filepath

6774+ , happy, hashtables, pretty, process, random

6775+ }:

6776+ mkDerivation {

6777+ pname = "gtk2hs-buildtools";

6778+ version = "0.13.0.3";

6779+ sha256 = "1ijcmcjp8mralpzl1gvh24bzq8njlzkvck1r07b010rrklv04arp";

6780+ configureFlags = [

6781+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6782+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6783+ "-fsplitbase" "-f-test-hlint"

6784+ ];

6785+ isLibrary = false;

6786+ isExecutable = true;

6787+ enableSeparateDataOutput = true;

6788+ executableHaskellDepends = [

6789+ array base containers directory filepath hashtables pretty process

6790+ random

6791+ ];

6792+ executableToolDepends = [ alex happy ];

6793+ doHaddock = false;

6794+ homepage = "http://projects.haskell.org/gtk2hs/";

6795+ description = "Tools to build the Gtk2Hs suite of User Interface libraries";

6796+ license = stdenv.lib.licenses.gpl2;

6797+ }) {};

6798+ "hOpenPGP" = callPackage

6799+ ({ mkDerivation, ansi-wl-pprint, attoparsec, base

6800+ , base64-bytestring, bytestring, bzlib, cereal, cereal-conduit

6801+ , conduit, conduit-extra, containers, crypto-cipher-types

6802+ , crypto-pubkey, crypto-random, cryptocipher, cryptohash

6803+ , data-default, errors, hashable, incremental-parser, ixset, lens

6804+ , monad-loops, mtl, nettle, openpgp-asciiarmor, QuickCheck

6805+ , quickcheck-instances, resourcet, securemem, semigroups, split

6806+ , tasty, tasty-hunit, tasty-quickcheck, text, time, transformers

6807+ , unordered-containers, zlib

6808+ }:

6809+ mkDerivation {

6810+ pname = "hOpenPGP";

6811+ version = "1.11";

6812+ sha256 = "1alcaqx2i4a4cbmh0brb9axfsm4nb8fs4mqglh609iy3bdl791b7";

6813+ configureFlags = [

6814+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6815+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6816+ "-fsplitbase" "-f-test-hlint"

6817+ ];

6818+ libraryHaskellDepends = [

6819+ ansi-wl-pprint attoparsec base base64-bytestring bytestring bzlib

6820+ cereal cereal-conduit conduit conduit-extra containers

6821+ crypto-cipher-types crypto-pubkey crypto-random cryptocipher

6822+ cryptohash data-default errors hashable incremental-parser ixset

6823+ lens monad-loops mtl nettle openpgp-asciiarmor resourcet securemem

6824+ semigroups split text time transformers unordered-containers zlib

6825+ ];

6826+ testHaskellDepends = [

6827+ ansi-wl-pprint attoparsec base bytestring bzlib cereal

6828+ cereal-conduit conduit conduit-extra containers crypto-cipher-types

6829+ crypto-pubkey crypto-random cryptocipher cryptohash data-default

6830+ errors hashable incremental-parser ixset lens monad-loops mtl

6831+ nettle QuickCheck quickcheck-instances resourcet securemem

6832+ semigroups split tasty tasty-hunit tasty-quickcheck text time

6833+ transformers unordered-containers zlib

6834+ ];

6835+ homepage = "http://floss.scru.org/hOpenPGP/";

6836+ description = "native Haskell implementation of OpenPGP (RFC4880)";

6837+ license = stdenv.lib.licenses.mit;

6838+ }) {};

6839+ "hPDB" = callPackage

6840+ ({ mkDerivation, AC-Vector, base, bytestring, containers, deepseq

6841+ , directory, ghc-prim, iterable, mmap, mtl, Octree, parallel

6842+ , QuickCheck, tagged, template-haskell, text, text-format, vector

6843+ , zlib

6844+ }:

6845+ mkDerivation {

6846+ pname = "hPDB";

6847+ version = "1.2.0";

6848+ sha256 = "1a5lwjrqqm8arsark87vd512w45pik9jxih5zzzamksn4j9mc6y8";

6849+ configureFlags = [

6850+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6851+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6852+ "-fsplitbase" "-f-test-hlint"

6853+ ];

6854+ libraryHaskellDepends = [

6855+ AC-Vector base bytestring containers deepseq directory ghc-prim

6856+ iterable mmap mtl Octree parallel QuickCheck tagged

6857+ template-haskell text text-format vector zlib

6858+ ];

6859+ homepage = "https://github.com/BioHaskell/hPDB";

6860+ description = "Protein Databank file format library";

6861+ license = stdenv.lib.licenses.bsd3;

6862+ }) {};

6863+ "hPDB-examples" = callPackage

6864+ ({ mkDerivation, AC-Vector, base, bytestring, containers, deepseq

6865+ , directory, ghc-prim, GLUT, hPDB, iterable, mtl, Octree, OpenGL

6866+ , QuickCheck, template-haskell, text, text-format, vector

6867+ }:

6868+ mkDerivation {

6869+ pname = "hPDB-examples";

6870+ version = "1.1.2";

6871+ sha256 = "0i5ig6h884m34cjzml29yadf7jflxhd4rih60r93s4c7i4npkixj";

6872+ configureFlags = [

6873+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6874+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6875+ "-fsplitbase" "-f-test-hlint"

6876+ ];

6877+ isLibrary = false;

6878+ isExecutable = true;

6879+ executableHaskellDepends = [

6880+ AC-Vector base bytestring containers deepseq directory ghc-prim

6881+ GLUT hPDB iterable mtl Octree OpenGL QuickCheck template-haskell

6882+ text text-format vector

6883+ ];

6884+ doHaddock = false;

6885+ homepage = "https://github.com/BioHaskell/hPDB-examples";

6886+ description = "Examples for hPDB library";

6887+ license = stdenv.lib.licenses.bsd3;

6888+ }) {};

6889+ "haddock-api" = callPackage

6890+ ({ mkDerivation, array, base, bytestring, Cabal, containers

6891+ , deepseq, directory, filepath, ghc, ghc-paths, haddock-library

6892+ , xhtml

6893+ }:

6894+ mkDerivation {

6895+ pname = "haddock-api";

6896+ version = "2.15.0";

6897+ sha256 = "17h5h40ddn0kiqnz6rmz9p0jqvng11lq3xm6lnizwix9kcwl843b";

6898+ configureFlags = [

6899+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6900+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6901+ "-fsplitbase" "-f-test-hlint"

6902+ ];

6903+ enableSeparateDataOutput = true;

6904+ libraryHaskellDepends = [

6905+ array base bytestring Cabal containers deepseq directory filepath

6906+ ghc ghc-paths haddock-library xhtml

6907+ ];

6908+ homepage = "http://www.haskell.org/haddock/";

6909+ description = "A documentation-generation tool for Haskell libraries";

6910+ license = stdenv.lib.licenses.bsd3;

6911+ }) {};

6912+ "haddock-library" = callPackage

6913+ ({ mkDerivation, base, base-compat, bytestring, deepseq, hspec

6914+ , QuickCheck

6915+ }:

6916+ mkDerivation {

6917+ pname = "haddock-library";

6918+ version = "1.1.1";

6919+ sha256 = "0sjnmbmq1pss9ikcqnhvpf57rv78lzi1r99ywpmmvj1gyva2s31m";

6920+ configureFlags = [

6921+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6922+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6923+ "-fsplitbase" "-f-test-hlint"

6924+ ];

6925+ libraryHaskellDepends = [ base bytestring deepseq ];

6926+ testHaskellDepends = [

6927+ base base-compat bytestring deepseq hspec QuickCheck

6928+ ];

6929+ homepage = "http://www.haskell.org/haddock/";

6930+ description = "Library exposing some functionality of Haddock";

6931+ license = stdenv.lib.licenses.bsd3;

6932+ }) {};

6933+ "half" = callPackage

6934+ ({ mkDerivation, base }:

6935+ mkDerivation {

6936+ pname = "half";

6937+ version = "0.2.0.1";

6938+ sha256 = "0lwh5bv8pnp9fzq64z1fg1i4fv8h2lcchs1298agq881hcay19qw";

6939+ revision = "1";

6940+ editedCabalFile = "1knc268v79zb3fs2x09gjs7fh6i24iaplpdblg4lr72xgawc1bfg";

6941+ configureFlags = [

6942+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6943+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6944+ "-fsplitbase" "-f-test-hlint"

6945+ ];

6946+ libraryHaskellDepends = [ base ];

6947+ homepage = "http://github.com/ekmett/half";

6948+ description = "Half-precision floating-point";

6949+ license = stdenv.lib.licenses.bsd3;

6950+ }) {};

6951+ "hamlet" = callPackage

6952+ ({ mkDerivation, base, shakespeare }:

6953+ mkDerivation {

6954+ pname = "hamlet";

6955+ version = "1.2.0";

6956+ sha256 = "0rla3ap3malk8j6mh07fr2aqvbscpy743wrfq3skgjv3j4jlpjfi";

6957+ configureFlags = [

6958+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6959+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6960+ "-fsplitbase" "-f-test-hlint"

6961+ ];

6962+ libraryHaskellDepends = [ base shakespeare ];

6963+ doHaddock = false;

6964+ doCheck = false;

6965+ homepage = "http://www.yesodweb.com/book/shakespearean-templates";

6966+ description = "Haml-like template files that are compile-time checked (deprecated)";

6967+ license = stdenv.lib.licenses.mit;

6968+ }) {};

6969+ "happstack-server" = callPackage

6970+ ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring

6971+ , containers, directory, extensible-exceptions, filepath, hslogger

6972+ , html, HUnit, monad-control, mtl, network, old-locale, parsec

6973+ , process, sendfile, syb, system-filepath, template-haskell, text

6974+ , threads, time, time-compat, transformers, transformers-base, unix

6975+ , utf8-string, xhtml, zlib

6976+ }:

6977+ mkDerivation {

6978+ pname = "happstack-server";

6979+ version = "7.3.9";

6980+ sha256 = "10js2kmxw5lyy1h5xyz7qx852d29cl48qxyvadc4bdad6w06gdlz";

6981+ revision = "1";

6982+ editedCabalFile = "0d3pxb58abql2k80zkp0gfnsqc9dhrzv64lydnad6q9w3y1208ag";

6983+ configureFlags = [

6984+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6985+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6986+ "-fsplitbase" "-f-test-hlint"

6987+ ];

6988+ libraryHaskellDepends = [

6989+ base base64-bytestring blaze-html bytestring containers directory

6990+ extensible-exceptions filepath hslogger html monad-control mtl

6991+ network old-locale parsec process sendfile syb system-filepath

6992+ template-haskell text threads time time-compat transformers

6993+ transformers-base unix utf8-string xhtml zlib

6994+ ];

6995+ testHaskellDepends = [

6996+ base bytestring containers HUnit parsec zlib

6997+ ];

6998+ doHaddock = false;

6999+ doCheck = false;

7000+ homepage = "http://happstack.com";

7001+ description = "Web related tools and services";

7002+ license = stdenv.lib.licenses.bsd3;

7003+ }) {};

7004+ "happy" = callPackage

7005+ ({ mkDerivation, array, base, containers, mtl, process }:

7006+ mkDerivation {

7007+ pname = "happy";

7008+ version = "1.19.4";

7009+ sha256 = "0vcklr1y6yjf8z4wip4al2zw4qlfxcahbdxwpf6c9y31dkv9kr3b";

7010+ revision = "1";

7011+ editedCabalFile = "09586bhhl6v0k36ga5zg353910287zjl4pxwa8h8v2lagsskjjrr";

7012+ configureFlags = [

7013+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7014+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7015+ "-fsplitbase" "-f-test-hlint"

7016+ ];

7017+ isLibrary = false;

7018+ isExecutable = true;

7019+ executableHaskellDepends = [ array base containers mtl ];

7020+ testHaskellDepends = [ base process ];

7021+ doHaddock = false;

7022+ homepage = "http://www.haskell.org/happy/";

7023+ description = "Happy is a parser generator for Haskell";

7024+ license = stdenv.lib.licenses.bsd3;

7025+ }) {};

7026+ "hashable" = callPackage

7027+ ({ mkDerivation, base, bytestring, criterion, ghc-prim, HUnit

7028+ , integer-gmp, QuickCheck, random, siphash, test-framework

7029+ , test-framework-hunit, test-framework-quickcheck2, text, unix

7030+ }:

7031+ mkDerivation {

7032+ pname = "hashable";

7033+ version = "1.2.3.0";

7034+ sha256 = "02akgpwjzj2w5jnn31xp6yvgs4xmyircm8wcbq9v0icza6yb11qi";

7035+ revision = "1";

7036+ editedCabalFile = "1i6q4vzdb0kxl7rdh2g6cjaqrnc0zh19rjgd209hhpn9w5gwi0ri";

7037+ configureFlags = [

7038+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7039+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7040+ "-fsplitbase" "-f-test-hlint"

7041+ ];

7042+ libraryHaskellDepends = [

7043+ base bytestring ghc-prim integer-gmp text

7044+ ];

7045+ testHaskellDepends = [

7046+ base bytestring ghc-prim HUnit QuickCheck random test-framework

7047+ test-framework-hunit test-framework-quickcheck2 text unix

7048+ ];

7049+ benchmarkHaskellDepends = [

7050+ base bytestring criterion ghc-prim integer-gmp siphash text

7051+ ];

7052+ doHaddock = false;

7053+ doCheck = false;

7054+ homepage = "http://github.com/tibbe/hashable";

7055+ description = "A class for types that can be converted to a hash value";

7056+ license = stdenv.lib.licenses.bsd3;

7057+ }) {};

7058+ "hashable-extras" = callPackage

7059+ ({ mkDerivation, base, bifunctors, bytestring, directory, doctest

7060+ , filepath, generic-deriving, hashable, transformers

7061+ }:

7062+ mkDerivation {

7063+ pname = "hashable-extras";

7064+ version = "0.2.0.1";

7065+ sha256 = "09y2m0wpim7sl7n9qnkr0miwfsbvb1q8lm6shpcq0jxzxknbag7s";

7066+ revision = "2";

7067+ editedCabalFile = "1k4f8acpd2w0mywffwpn6jipfvj3wy68jqf2ndfkcxi688lwawsg";

7068+ configureFlags = [

7069+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7070+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7071+ "-fsplitbase" "-f-test-hlint"

7072+ ];

7073+ libraryHaskellDepends = [

7074+ base bifunctors bytestring generic-deriving hashable transformers

7075+ ];

7076+ testHaskellDepends = [ base directory doctest filepath ];

7077+ homepage = "http://github.com/analytics/hashable-extras/";

7078+ description = "Higher-rank Hashable";

7079+ license = stdenv.lib.licenses.bsd3;

7080+ }) {};

7081+ "hashmap" = callPackage

7082+ ({ mkDerivation, base, containers, deepseq, hashable }:

7083+ mkDerivation {

7084+ pname = "hashmap";

7085+ version = "1.3.0.1";

7086+ sha256 = "16scl1rbq0f18mggrj4lbhgkz7kzshsw9a523rjd8cjkdjz1ijwr";

7087+ configureFlags = [

7088+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7089+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7090+ "-fsplitbase" "-f-test-hlint"

7091+ ];

7092+ libraryHaskellDepends = [ base containers deepseq hashable ];

7093+ homepage = "http://git.auryn.cz/haskell/hashmap/";

7094+ description = "Persistent containers Map and Set based on hashing";

7095+ license = stdenv.lib.licenses.bsd3;

7096+ }) {};

7097+ "hashtables" = callPackage

7098+ ({ mkDerivation, base, ghc-prim, hashable, primitive, vector }:

7099+ mkDerivation {

7100+ pname = "hashtables";

7101+ version = "1.1.2.1";

7102+ sha256 = "1166baqalpp9v735821drjvyasr44p4znbcs7njyr09fx87r23f5";

7103+ configureFlags = [

7104+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7105+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7106+ "-fsplitbase" "-f-test-hlint"

7107+ ];

7108+ libraryHaskellDepends = [

7109+ base ghc-prim hashable primitive vector

7110+ ];

7111+ homepage = "http://github.com/gregorycollins/hashtables";

7112+ description = "Mutable hash tables in the ST monad";

7113+ license = stdenv.lib.licenses.bsd3;

7114+ }) {};

7115+ "haskell-lexer" = callPackage

7116+ ({ mkDerivation, base }:

7117+ mkDerivation {

7118+ pname = "haskell-lexer";

7119+ version = "1.0";

7120+ sha256 = "11jv30msg4rym73lk6j21ky2510c3av8qxk5p4z63j4m283w9l46";

7121+ configureFlags = [

7122+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7123+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7124+ "-fsplitbase" "-f-test-hlint"

7125+ ];

7126+ libraryHaskellDepends = [ base ];

7127+ description = "A fully compliant Haskell 98 lexer";

7128+ license = stdenv.lib.licenses.bsd3;

7129+ }) {};

7130+ "haskell-names" = callPackage

7131+ ({ mkDerivation, aeson, base, bytestring, Cabal, containers

7132+ , data-lens-light, filemanip, filepath, haskell-packages

7133+ , haskell-src-exts, hse-cpp, mtl, pretty-show, tagged, tasty

7134+ , tasty-golden, transformers, traverse-with-class, type-eq

7135+ , uniplate, utf8-string

7136+ }:

7137+ mkDerivation {

7138+ pname = "haskell-names";

7139+ version = "0.4.1";

7140+ sha256 = "1zkfq54s7n17g77sqzfhhc4bmqwdwbynz0gzwyaf3m4nmz6lkfl8";

7141+ revision = "1";

7142+ editedCabalFile = "0hgpfdgd00s1mb7f3yqlk6h8arvxyb312wzxvz4gx44nmlvlnryl";

7143+ configureFlags = [

7144+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7145+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7146+ "-fsplitbase" "-f-test-hlint"

7147+ ];

7148+ enableSeparateDataOutput = true;

7149+ libraryHaskellDepends = [

7150+ aeson base bytestring Cabal containers data-lens-light filepath

7151+ haskell-packages haskell-src-exts hse-cpp mtl tagged transformers

7152+ traverse-with-class type-eq uniplate

7153+ ];

7154+ testHaskellDepends = [

7155+ aeson base bytestring Cabal containers filemanip filepath

7156+ haskell-packages haskell-src-exts hse-cpp mtl pretty-show tagged

7157+ tasty tasty-golden traverse-with-class uniplate utf8-string

7158+ ];

7159+ homepage = "http://documentup.com/haskell-suite/haskell-names";

7160+ description = "Name resolution library for Haskell";

7161+ license = stdenv.lib.licenses.bsd3;

7162+ }) {};

7163+ "haskell-packages" = callPackage

7164+ ({ mkDerivation, aeson, base, bytestring, Cabal, containers

7165+ , deepseq, directory, filepath, haskell-src-exts, hse-cpp, mtl

7166+ , optparse-applicative, tagged, transformers, transformers-compat

7167+ }:

7168+ mkDerivation {

7169+ pname = "haskell-packages";

7170+ version = "0.2.4.3";

7171+ sha256 = "0s1z5zzl53nmjnrlf1czri634h8fksbgkqvvz8hpwa60wsaf4dxn";

7172+ revision = "1";

7173+ editedCabalFile = "010bzma7707fhvl3r1myydlp1vy8a3yr3i6sipzjncv77b0yfhnb";

7174+ configureFlags = [

7175+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7176+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7177+ "-fsplitbase" "-f-test-hlint"

7178+ ];

7179+ libraryHaskellDepends = [

7180+ aeson base bytestring Cabal containers deepseq directory filepath

7181+ haskell-src-exts hse-cpp mtl optparse-applicative tagged

7182+ transformers transformers-compat

7183+ ];

7184+ homepage = "http://documentup.com/haskell-suite/haskell-packages";

7185+ description = "Haskell suite library for package management and integration with Cabal";

7186+ license = stdenv.lib.licenses.mit;

7187+ }) {};

7188+ "haskell-src" = callPackage

7189+ ({ mkDerivation, array, base, pretty, syb }:

7190+ mkDerivation {

7191+ pname = "haskell-src";

7192+ version = "1.0.1.6";

7193+ sha256 = "1vscvbsly7k0zqb7fi6bm38dfacyl8qgmv0h25fqkn95c0v5dif7";

7194+ revision = "1";

7195+ editedCabalFile = "118zvq8lk82i23ddiyb4mzlg4lapkbzd4cbmysfm30wfvayz68zn";

7196+ configureFlags = [

7197+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7198+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7199+ "-fsplitbase" "-f-test-hlint"

7200+ ];

7201+ libraryHaskellDepends = [ array base pretty syb ];

7202+ description = "Support for manipulating Haskell source code";

7203+ license = stdenv.lib.licenses.bsd3;

7204+ }) {};

7205+ "haskell-src-exts" = callPackage

7206+ ({ mkDerivation, array, base, containers, cpphs, directory

7207+ , filepath, ghc-prim, happy, mtl, pretty, smallcheck, syb, tasty

7208+ , tasty-golden, tasty-smallcheck

7209+ }:

7210+ mkDerivation {

7211+ pname = "haskell-src-exts";

7212+ version = "1.16.0.1";

7213+ sha256 = "1h8gjw5g92rvvzadqzpscg73x7ajvs1wlphrh27afim3scdd8frz";

7214+ configureFlags = [

7215+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7216+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7217+ "-fsplitbase" "-f-test-hlint"

7218+ ];

7219+ libraryHaskellDepends = [ array base cpphs ghc-prim pretty ];

7220+ libraryToolDepends = [ happy ];

7221+ testHaskellDepends = [

7222+ base containers directory filepath mtl smallcheck syb tasty

7223+ tasty-golden tasty-smallcheck

7224+ ];

7225+ homepage = "https://github.com/haskell-suite/haskell-src-exts";

7226+ description = "Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer";

7227+ license = stdenv.lib.licenses.bsd3;

7228+ }) {};

7229+ "haskell-src-meta" = callPackage

7230+ ({ mkDerivation, base, haskell-src-exts, pretty, syb

7231+ , template-haskell, th-orphans

7232+ }:

7233+ mkDerivation {

7234+ pname = "haskell-src-meta";

7235+ version = "0.6.0.8";

7236+ sha256 = "1fv228n9zbqa52aif7pkylrqgz2n63xhxly9f828i18xf02rmxnk";

7237+ revision = "1";

7238+ editedCabalFile = "12lz67xk1mc3zkqnx8r54q9m1pmi1ikmgf9v3cisy22sw5vrcq4q";

7239+ configureFlags = [

7240+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7241+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7242+ "-fsplitbase" "-f-test-hlint"

7243+ ];

7244+ libraryHaskellDepends = [

7245+ base haskell-src-exts pretty syb template-haskell th-orphans

7246+ ];

7247+ description = "Parse source to template-haskell abstract syntax";

7248+ license = stdenv.lib.licenses.bsd3;

7249+ }) {};

7250+ "hasql" = callPackage

7251+ ({ mkDerivation, attoparsec, base, base-prelude, bytestring

7252+ , ex-pool, hasql-backend, hasql-postgres, list-t, loch-th, mmorph

7253+ , monad-control, placeholders, safe, template-haskell, text, time

7254+ , transformers, transformers-base, vector

7255+ }:

7256+ mkDerivation {

7257+ pname = "hasql";

7258+ version = "0.4.0";

7259+ sha256 = "1y4fs0pa8kbgjdkwp47p03gizj878dyil32zyxhapharmvajhp37";

7260+ configureFlags = [

7261+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7262+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7263+ "-fsplitbase" "-f-test-hlint"

7264+ ];

7265+ libraryHaskellDepends = [

7266+ attoparsec base base-prelude bytestring ex-pool hasql-backend

7267+ list-t loch-th mmorph monad-control placeholders safe

7268+ template-haskell text time transformers transformers-base vector

7269+ ];

7270+ benchmarkHaskellDepends = [ base hasql-postgres transformers ];

7271+ doHaddock = false;

7272+ doCheck = false;

7273+ homepage = "https://github.com/nikita-volkov/hasql";

7274+ description = "A minimalistic general high level API for relational databases";

7275+ license = stdenv.lib.licenses.mit;

7276+ }) {};

7277+ "hasql-backend" = callPackage

7278+ ({ mkDerivation, base, base-prelude, bytestring, list-t, text

7279+ , vector

7280+ }:

7281+ mkDerivation {

7282+ pname = "hasql-backend";

7283+ version = "0.2.1";

7284+ sha256 = "0m9wslhmqrmcsx1mw8h6ks52i811pzy7w9k5ddc0y1dy7ibcbfcc";

7285+ configureFlags = [

7286+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7287+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7288+ "-fsplitbase" "-f-test-hlint"

7289+ ];

7290+ libraryHaskellDepends = [

7291+ base base-prelude bytestring list-t text vector

7292+ ];

7293+ doHaddock = false;

7294+ doCheck = false;

7295+ homepage = "https://github.com/nikita-volkov/hasql-backend";

7296+ description = "API for backends of \"hasql\"";

7297+ license = stdenv.lib.licenses.mit;

7298+ }) {};

7299+ "hasql-postgres" = callPackage

7300+ ({ mkDerivation, attoparsec, base, base-prelude, bytestring, either

7301+ , hashable, hashtables, hasql-backend, list-t, loch-th, mmorph

7302+ , placeholders, postgresql-binary, postgresql-libpq, scientific

7303+ , template-haskell, text, time, transformers, uuid, vector

7304+ }:

7305+ mkDerivation {

7306+ pname = "hasql-postgres";

7307+ version = "0.7.3";

7308+ sha256 = "07rhb9jd3amc61gjyb27s7l3f9g77il3jbsay7i49ylfr8h58cxr";

7309+ configureFlags = [

7310+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7311+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7312+ "-fsplitbase" "-f-test-hlint"

7313+ ];

7314+ libraryHaskellDepends = [

7315+ attoparsec base base-prelude bytestring either hashable hashtables

7316+ hasql-backend list-t loch-th mmorph placeholders postgresql-binary

7317+ postgresql-libpq scientific template-haskell text time transformers

7318+ uuid vector

7319+ ];

7320+ doHaddock = false;

7321+ doCheck = false;

7322+ homepage = "https://github.com/nikita-volkov/hasql-postgres";

7323+ description = "A \"PostgreSQL\" backend for the \"hasql\" library";

7324+ license = stdenv.lib.licenses.mit;

7325+ }) {};

7326+ "hastache" = callPackage

7327+ ({ mkDerivation, base, blaze-builder, bytestring, containers

7328+ , directory, filepath, HUnit, ieee754, mtl, syb, text, transformers

7329+ , utf8-string

7330+ }:

7331+ mkDerivation {

7332+ pname = "hastache";

7333+ version = "0.6.0";

7334+ sha256 = "1z609mhsc875ba3k6mlmlqpmqlwgxpav2asnf83yzq1q7bfs0cxh";

7335+ revision = "3";

7336+ editedCabalFile = "0vkygv0n5h5d8phnaw498532i0l6cbjwcv1xn6rcy3dcmi6i54zg";

7337+ configureFlags = [

7338+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7339+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7340+ "-fsplitbase" "-f-test-hlint"

7341+ ];

7342+ libraryHaskellDepends = [

7343+ base blaze-builder bytestring containers directory filepath ieee754

7344+ mtl syb text transformers utf8-string

7345+ ];

7346+ testHaskellDepends = [

7347+ base bytestring directory HUnit mtl syb text

7348+ ];

7349+ homepage = "http://github.com/lymar/hastache";

7350+ description = "Haskell implementation of Mustache templates";

7351+ license = stdenv.lib.licenses.bsd3;

7352+ }) {};

7353+ "haxr" = callPackage

7354+ ({ mkDerivation, array, base, base64-bytestring, blaze-builder

7355+ , bytestring, HaXml, HTTP, mtl, network, network-uri, old-locale

7356+ , old-time, template-haskell, time, utf8-string

7357+ }:

7358+ mkDerivation {

7359+ pname = "haxr";

7360+ version = "3000.10.3.1";

7361+ sha256 = "0alvrsk85f1l79hfa9shagjckp4sx835l9734ab2izfv50mxx7gm";

7362+ revision = "1";

7363+ editedCabalFile = "060r24v3x8idc07ji22z7aq53h2mw3k2vv8kyn7k4q5f4b8q26li";

7364+ configureFlags = [

7365+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7366+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7367+ "-fsplitbase" "-f-test-hlint"

7368+ ];

7369+ libraryHaskellDepends = [

7370+ array base base64-bytestring blaze-builder bytestring HaXml HTTP

7371+ mtl network network-uri old-locale old-time template-haskell time

7372+ utf8-string

7373+ ];

7374+ homepage = "http://www.haskell.org/haskellwiki/HaXR";

7375+ description = "XML-RPC client and server library";

7376+ license = stdenv.lib.licenses.bsd3;

7377+ }) {};

7378+ "hdaemonize" = callPackage

7379+ ({ mkDerivation, base, extensible-exceptions, filepath, hsyslog

7380+ , mtl, unix

7381+ }:

7382+ mkDerivation {

7383+ pname = "hdaemonize";

7384+ version = "0.5.0.0";

7385+ sha256 = "15dyaa9rbmsjp3sg9yxg1i90kfy9rvlzmwg5kl8kwal69ajzjjgv";

7386+ configureFlags = [

7387+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7388+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7389+ "-fsplitbase" "-f-test-hlint"

7390+ ];

7391+ libraryHaskellDepends = [

7392+ base extensible-exceptions filepath hsyslog mtl unix

7393+ ];

7394+ homepage = "http://github.com/madhadron/hdaemonize";

7395+ description = "Library to handle the details of writing daemons for UNIX";

7396+ license = stdenv.lib.licenses.bsd3;

7397+ }) {};

7398+ "hdevtools" = callPackage

7399+ ({ mkDerivation, base, Cabal, cmdargs, directory, filepath, ghc

7400+ , ghc-paths, network, syb, time, unix

7401+ }:

7402+ mkDerivation {

7403+ pname = "hdevtools";

7404+ version = "0.1.0.6";

7405+ sha256 = "1plpkdhjv2493zy7fdn3a6cwdava0yrqqkzyn3wddi9f70xd62ak";

7406+ configureFlags = [

7407+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7408+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7409+ "-fsplitbase" "-f-test-hlint"

7410+ ];

7411+ isLibrary = false;

7412+ isExecutable = true;

7413+ executableHaskellDepends = [

7414+ base Cabal cmdargs directory filepath ghc ghc-paths network syb

7415+ time unix

7416+ ];

7417+ doHaddock = false;

7418+ homepage = "https://github.com/bitc/hdevtools/";

7419+ description = "Persistent GHC powered background server for FAST haskell development tools";

7420+ license = stdenv.lib.licenses.mit;

7421+ }) {};

7422+ "heaps" = callPackage

7423+ ({ mkDerivation, base, directory, doctest, filepath }:

7424+ mkDerivation {

7425+ pname = "heaps";

7426+ version = "0.3.1";

7427+ sha256 = "1h0p097zc1wjinhdhy4ssav7jpicc85074d926nmnhdgz9vaajwj";

7428+ revision = "1";

7429+ editedCabalFile = "0p5m4rmihxzy08c4m76id5apc9w5yfsgin1l1g708p1i53plnfwf";

7430+ configureFlags = [

7431+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7432+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7433+ "-fsplitbase" "-f-test-hlint"

7434+ ];

7435+ libraryHaskellDepends = [ base ];

7436+ testHaskellDepends = [ base directory doctest filepath ];

7437+ homepage = "http://github.com/ekmett/heaps/";

7438+ description = "Asymptotically optimal Brodal/Okasaki heaps";

7439+ license = stdenv.lib.licenses.bsd3;

7440+ }) {};

7441+ "hebrew-time" = callPackage

7442+ ({ mkDerivation, base, HUnit, QuickCheck, test-framework

7443+ , test-framework-hunit, test-framework-quickcheck2, time

7444+ }:

7445+ mkDerivation {

7446+ pname = "hebrew-time";

7447+ version = "0.1.1";

7448+ sha256 = "0ckridxf4rvhhp0k1mckbbbpzfs32l4mwg7n9mrmsggldpl7x6f7";

7449+ configureFlags = [

7450+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7451+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7452+ "-fsplitbase" "-f-test-hlint"

7453+ ];

7454+ libraryHaskellDepends = [ base time ];

7455+ testHaskellDepends = [

7456+ base HUnit QuickCheck test-framework test-framework-hunit

7457+ test-framework-quickcheck2 time

7458+ ];

7459+ homepage = "https://github.com/snoyberg/hebrew-time";

7460+ description = "Hebrew dates and prayer times";

7461+ license = stdenv.lib.licenses.mit;

7462+ }) {};

7463+ "heist" = callPackage

7464+ ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html

7465+ , bytestring, containers, directory, directory-tree, dlist, errors

7466+ , filepath, hashable, map-syntax, MonadCatchIO-transformers, mtl

7467+ , process, random, text, time, transformers, unordered-containers

7468+ , vector, xmlhtml

7469+ }:

7470+ mkDerivation {

7471+ pname = "heist";

7472+ version = "0.14.0.1";

7473+ sha256 = "1nhksdn95v35ymml3kgm70axjl4vkjfvj1wvlcm1a1frlnbk993w";

7474+ revision = "1";

7475+ editedCabalFile = "1bhyqxcswqilvjkyzka3vbqw5fd7ppff50afg1f9z285md4ndi3c";

7476+ configureFlags = [

7477+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7478+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7479+ "-fsplitbase" "-f-test-hlint"

7480+ ];

7481+ libraryHaskellDepends = [

7482+ aeson attoparsec base blaze-builder blaze-html bytestring

7483+ containers directory directory-tree dlist errors filepath hashable

7484+ map-syntax MonadCatchIO-transformers mtl process random text time

7485+ transformers unordered-containers vector xmlhtml

7486+ ];

7487+ homepage = "http://snapframework.com/";

7488+ description = "An Haskell template system supporting both HTML5 and XML";

7489+ license = stdenv.lib.licenses.bsd3;

7490+ }) {};

7491+ "here" = callPackage

7492+ ({ mkDerivation, base, haskell-src-meta, mtl, parsec

7493+ , template-haskell

7494+ }:

7495+ mkDerivation {

7496+ pname = "here";

7497+ version = "1.2.6";

7498+ sha256 = "1c7b0a5a42ki8ndvc2k35jnsj433f1nv1j40vviasxksm7acbwif";

7499+ configureFlags = [

7500+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7501+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7502+ "-fsplitbase" "-f-test-hlint"

7503+ ];

7504+ libraryHaskellDepends = [

7505+ base haskell-src-meta mtl parsec template-haskell

7506+ ];

7507+ homepage = "https://github.com/tmhedberg/here";

7508+ description = "Here docs & interpolated strings via quasiquotation";

7509+ license = stdenv.lib.licenses.bsd3;

7510+ }) {};

7511+ "heredoc" = callPackage

7512+ ({ mkDerivation, base, template-haskell }:

7513+ mkDerivation {

7514+ pname = "heredoc";

7515+ version = "0.2.0.0";

7516+ sha256 = "0h0g2f7yscwl1ba1yn3jnz2drvd6ns9m910hwlmq3kdq3k39y3f9";

7517+ configureFlags = [

7518+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7519+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7520+ "-fsplitbase" "-f-test-hlint"

7521+ ];

7522+ libraryHaskellDepends = [ base template-haskell ];

7523+ homepage = "http://hackage.haskell.org/package/heredoc";

7524+ description = "multi-line string / here document using QuasiQuotes";

7525+ license = stdenv.lib.licenses.publicDomain;

7526+ }) {};

7527+ "highlighting-kate" = callPackage

7528+ ({ mkDerivation, base, blaze-html, containers, Diff, directory

7529+ , filepath, mtl, parsec, process, regex-pcre-builtin, utf8-string

7530+ }:

7531+ mkDerivation {

7532+ pname = "highlighting-kate";

7533+ version = "0.5.11";

7534+ sha256 = "0jfgz4cyn6fylfrsk1yi0fykir8mhxdniq80h7hy5i2xv7qwf5vw";

7535+ revision = "1";

7536+ editedCabalFile = "0in197jpmpjhyajs05srkhhi7mp41w0583azlcx7y9qq6cbir0v4";

7537+ configureFlags = [

7538+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7539+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7540+ "-fsplitbase" "-f-test-hlint"

7541+ ];

7542+ isLibrary = true;

7543+ isExecutable = true;

7544+ libraryHaskellDepends = [

7545+ base blaze-html containers mtl parsec regex-pcre-builtin

7546+ utf8-string

7547+ ];

7548+ executableHaskellDepends = [ base blaze-html containers filepath ];

7549+ testHaskellDepends = [

7550+ base blaze-html containers Diff directory filepath process

7551+ ];

7552+ homepage = "http://github.com/jgm/highlighting-kate";

7553+ description = "Syntax highlighting";

7554+ license = "GPL";

7555+ }) {};

7556+ "hinotify" = callPackage

7557+ ({ mkDerivation, base, containers, directory, unix }:

7558+ mkDerivation {

7559+ pname = "hinotify";

7560+ version = "0.3.7";

7561+ sha256 = "0i7mxg9ilzcgijda6j3ya5xnpbxa3wm9xswdfif95jim9w82sw0b";

7562+ configureFlags = [

7563+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7564+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7565+ "-fsplitbase" "-f-test-hlint"

7566+ ];

7567+ libraryHaskellDepends = [ base containers directory unix ];

7568+ homepage = "https://github.com/kolmodin/hinotify.git";

7569+ description = "Haskell binding to inotify";

7570+ license = stdenv.lib.licenses.bsd3;

7571+ }) {};

7572+ "hint" = callPackage

7573+ ({ mkDerivation, base, directory, exceptions, extensible-exceptions

7574+ , filepath, ghc, ghc-mtl, ghc-paths, HUnit, mtl, random, unix

7575+ , utf8-string

7576+ }:

7577+ mkDerivation {

7578+ pname = "hint";

7579+ version = "0.4.2.1";

7580+ sha256 = "0nc545y1v3s1897f3ims7m37wnn288xyz1zb9sxqs6immdxyly0g";

7581+ revision = "2";

7582+ editedCabalFile = "1ijalrx03rnd2ky2ghd8fqh8l2nvxpyyqvywl2pcnj1w8vywvng8";

7583+ configureFlags = [

7584+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7585+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7586+ "-fsplitbase" "-f-test-hlint"

7587+ ];

7588+ libraryHaskellDepends = [

7589+ base directory exceptions extensible-exceptions filepath ghc

7590+ ghc-mtl ghc-paths mtl random unix utf8-string

7591+ ];

7592+ testHaskellDepends = [

7593+ base directory exceptions extensible-exceptions filepath HUnit mtl

7594+ ];

7595+ homepage = "http://hub.darcs.net/jcpetruzza/hint";

7596+ description = "Runtime Haskell interpreter (GHC API wrapper)";

7597+ license = stdenv.lib.licenses.bsd3;

7598+ }) {};

7599+ "histogram-fill" = callPackage

7600+ ({ mkDerivation, base, criterion, deepseq, monad-primitive

7601+ , mwc-random, primitive, vector

7602+ }:

7603+ mkDerivation {

7604+ pname = "histogram-fill";

7605+ version = "0.8.3.0";

7606+ sha256 = "0k9qfrjf7zdxx8iw9yqy6lvn2p3c2mpzfbbx713rripf6y531m3g";

7607+ configureFlags = [

7608+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7609+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7610+ "-fsplitbase" "-f-test-hlint"

7611+ ];

7612+ libraryHaskellDepends = [

7613+ base deepseq monad-primitive primitive vector

7614+ ];

7615+ benchmarkHaskellDepends = [ base criterion mwc-random vector ];

7616+ homepage = "https://github.com/Shimuuar/histogram-fill/";

7617+ description = "Library for histograms creation";

7618+ license = stdenv.lib.licenses.bsd3;

7619+ }) {};

7620+ "hit" = callPackage

7621+ ({ mkDerivation, attoparsec, base, bytedump, bytestring, containers

7622+ , cryptohash, hourglass, HUnit, mtl, parsec, patience, QuickCheck

7623+ , random, system-fileio, system-filepath, test-framework

7624+ , test-framework-quickcheck2, unix-compat, vector, zlib

7625+ , zlib-bindings

7626+ }:

7627+ mkDerivation {

7628+ pname = "hit";

7629+ version = "0.6.2";

7630+ sha256 = "07lfjbn48v8ykkyj15diy4a9kpgzc93gv0l1rdfcacl3f26a97hs";

7631+ configureFlags = [

7632+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7633+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7634+ "-fsplitbase" "-f-test-hlint"

7635+ ];

7636+ isLibrary = true;

7637+ isExecutable = true;

7638+ enableSeparateDataOutput = true;

7639+ libraryHaskellDepends = [

7640+ attoparsec base bytestring containers cryptohash hourglass mtl

7641+ parsec patience random system-fileio system-filepath unix-compat

7642+ vector zlib zlib-bindings

7643+ ];

7644+ testHaskellDepends = [

7645+ base bytedump bytestring hourglass HUnit QuickCheck test-framework

7646+ test-framework-quickcheck2

7647+ ];

7648+ homepage = "http://github.com/vincenthz/hit";

7649+ description = "Git operations in haskell";

7650+ license = stdenv.lib.licenses.bsd3;

7651+ }) {};

7652+ "hjsmin" = callPackage

7653+ ({ mkDerivation, base, blaze-builder, bytestring, Cabal, containers

7654+ , HUnit, language-javascript, optparse-applicative, QuickCheck

7655+ , test-framework, test-framework-hunit, text

7656+ }:

7657+ mkDerivation {

7658+ pname = "hjsmin";

7659+ version = "0.1.4.7";

7660+ sha256 = "1gw9is6piqrqxnrwp8v3vij90icmym58rxqnnklrcjfi3ai7y58f";

7661+ revision = "1";

7662+ editedCabalFile = "0895ki6x963h6x1vq4r91rgfig952rryy0qz88vkhgd19wgza94b";

7663+ configureFlags = [

7664+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7665+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7666+ "-fsplitbase" "-f-test-hlint"

7667+ ];

7668+ isLibrary = true;

7669+ isExecutable = true;

7670+ libraryHaskellDepends = [

7671+ base blaze-builder bytestring containers language-javascript text

7672+ ];

7673+ executableHaskellDepends = [

7674+ base blaze-builder bytestring containers language-javascript

7675+ optparse-applicative text

7676+ ];

7677+ testHaskellDepends = [

7678+ base blaze-builder bytestring Cabal containers HUnit

7679+ language-javascript QuickCheck test-framework test-framework-hunit

7680+ text

7681+ ];

7682+ homepage = "http://github.com/alanz/hjsmin";

7683+ description = "Haskell implementation of a javascript minifier";

7684+ license = stdenv.lib.licenses.bsd3;

7685+ }) {};

7686+ "hledger" = callPackage

7687+ ({ mkDerivation, base, cmdargs, containers, csv, directory

7688+ , filepath, haskeline, hledger-lib, HUnit, mtl, old-locale

7689+ , old-time, parsec, pretty-show, process, regexpr, safe

7690+ , shakespeare, shakespeare-text, split, tabular, test-framework

7691+ , test-framework-hunit, text, time, transformers, utf8-string

7692+ , wizards

7693+ }:

7694+ mkDerivation {

7695+ pname = "hledger";

7696+ version = "0.23.3";

7697+ sha256 = "10qrjwfmpddba6m3n5f527l77g3xf9d8fyxyhrl5593g6bgq9v7m";

7698+ configureFlags = [

7699+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7700+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7701+ "-fsplitbase" "-f-test-hlint"

7702+ ];

7703+ isLibrary = true;

7704+ isExecutable = true;

7705+ libraryHaskellDepends = [

7706+ base cmdargs containers directory filepath haskeline hledger-lib

7707+ HUnit mtl old-locale old-time parsec pretty-show process regexpr

7708+ safe shakespeare shakespeare-text split tabular text time

7709+ utf8-string wizards

7710+ ];

7711+ executableHaskellDepends = [

7712+ base cmdargs containers directory filepath haskeline hledger-lib

7713+ HUnit mtl old-locale old-time parsec pretty-show process regexpr

7714+ safe shakespeare shakespeare-text split tabular text time

7715+ utf8-string wizards

7716+ ];

7717+ testHaskellDepends = [

7718+ base cmdargs containers csv directory filepath haskeline

7719+ hledger-lib HUnit mtl old-locale old-time parsec pretty-show

7720+ process regexpr safe shakespeare shakespeare-text split tabular

7721+ test-framework test-framework-hunit text time transformers wizards

7722+ ];

7723+ homepage = "http://hledger.org";

7724+ description = "The main command-line interface for the hledger accounting tool";

7725+ license = "GPL";

7726+ }) {};

7727+ "hledger-lib" = callPackage

7728+ ({ mkDerivation, base, bytestring, cmdargs, containers, csv

7729+ , directory, filepath, HUnit, mtl, old-locale, old-time, parsec

7730+ , pretty-show, regex-tdfa, regexpr, safe, split, test-framework

7731+ , test-framework-hunit, time, transformers, utf8-string

7732+ }:

7733+ mkDerivation {

7734+ pname = "hledger-lib";

7735+ version = "0.23.3";

7736+ sha256 = "0in61wrkbdllghdkxmwwn2b2k2g9w7kqijwl58szfx9h7w8g3dbi";

7737+ configureFlags = [

7738+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7739+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7740+ "-fsplitbase" "-f-test-hlint"

7741+ ];

7742+ libraryHaskellDepends = [

7743+ base bytestring cmdargs containers csv directory filepath HUnit mtl

7744+ old-locale old-time parsec pretty-show regex-tdfa regexpr safe

7745+ split time transformers utf8-string

7746+ ];

7747+ testHaskellDepends = [

7748+ base cmdargs containers csv directory filepath HUnit mtl old-locale

7749+ old-time parsec pretty-show regex-tdfa regexpr safe split

7750+ test-framework test-framework-hunit time transformers

7751+ ];

7752+ homepage = "http://hledger.org";

7753+ description = "Core data types, parsers and utilities for the hledger accounting tool";

7754+ license = "GPL";

7755+ }) {};

7756+ "hlibgit2" = callPackage

7757+ ({ mkDerivation, base, bindings-DSL, openssl, process, zlib }:

7758+ mkDerivation {

7759+ pname = "hlibgit2";

7760+ version = "0.18.0.13";

7761+ sha256 = "1bslg51kkhnwm48kxaad4izq3xmzv6dpqy10a5kh16vr5zy3w5hz";

7762+ configureFlags = [

7763+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7764+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7765+ "-fsplitbase" "-f-test-hlint"

7766+ ];

7767+ libraryHaskellDepends = [ base bindings-DSL zlib ];

7768+ librarySystemDepends = [ openssl ];

7769+ testHaskellDepends = [ base process ];

7770+ description = "Low-level bindings to libgit2";

7771+ license = stdenv.lib.licenses.mit;

7772+ }) {inherit (pkgs) openssl;};

7773+ "hlint" = callPackage

7774+ ({ mkDerivation, ansi-terminal, base, cmdargs, containers, cpphs

7775+ , directory, extra, filepath, haskell-src-exts, hscolour, process

7776+ , transformers, uniplate

7777+ }:

7778+ mkDerivation {

7779+ pname = "hlint";

7780+ version = "1.9.13";

7781+ sha256 = "1cj487l3jvrp43acwk3ihc5mzyqwxxa0nqahad27sd3bbmx86p4a";

7782+ configureFlags = [

7783+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7784+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7785+ "-fsplitbase" "-f-test-hlint"

7786+ ];

7787+ isLibrary = true;

7788+ isExecutable = true;

7789+ enableSeparateDataOutput = true;

7790+ libraryHaskellDepends = [

7791+ ansi-terminal base cmdargs containers cpphs directory extra

7792+ filepath haskell-src-exts hscolour process transformers uniplate

7793+ ];

7794+ executableHaskellDepends = [ base ];

7795+ homepage = "http://community.haskell.org/~ndm/hlint/";

7796+ description = "Source code suggestions";

7797+ license = stdenv.lib.licenses.bsd3;

7798+ }) {};

7799+ "hmatrix" = callPackage

7800+ ({ mkDerivation, array, base, binary, blas, bytestring, deepseq

7801+ , liblapack, random, split, storable-complex, vector

7802+ }:

7803+ mkDerivation {

7804+ pname = "hmatrix";

7805+ version = "0.16.1.0";

7806+ sha256 = "0jdkh9cq3dzc2fdkqv2zpv70knfkr0i01wv83zw3gjjv081gcn5h";

7807+ revision = "1";

7808+ editedCabalFile = "0rw037drvvxkbv1j4lf9bmi21vxc7p8yw929sx9rhn21g4grs990";

7809+ configureFlags = [

7810+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7811+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7812+ "-fsplitbase" "-f-test-hlint"

7813+ ];

7814+ libraryHaskellDepends = [

7815+ array base binary bytestring deepseq random split storable-complex

7816+ vector

7817+ ];

7818+ librarySystemDepends = [ blas liblapack ];

7819+ preConfigure = "sed -i hmatrix.cabal -e '/\\/usr\\//D'";

7820+ homepage = "https://github.com/albertoruiz/hmatrix";

7821+ description = "Numeric Linear Algebra";

7822+ license = stdenv.lib.licenses.bsd3;

7823+ }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};

7824+ "hmatrix-gsl" = callPackage

7825+ ({ mkDerivation, array, base, gsl, hmatrix, process, random, vector

7826+ }:

7827+ mkDerivation {

7828+ pname = "hmatrix-gsl";

7829+ version = "0.16.0.2";

7830+ sha256 = "1l865v2vpjl7f5741z58m9gw1ksskgzfm5gzp9pxiqazsgb2h5ym";

7831+ configureFlags = [

7832+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7833+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7834+ "-fsplitbase" "-f-test-hlint"

7835+ ];

7836+ libraryHaskellDepends = [

7837+ array base hmatrix process random vector

7838+ ];

7839+ libraryPkgconfigDepends = [ gsl ];

7840+ homepage = "https://github.com/albertoruiz/hmatrix";

7841+ description = "Numerical computation";

7842+ license = "GPL";

7843+ }) {inherit (pkgs) gsl;};

7844+ "holy-project" = callPackage

7845+ ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal

7846+ , directory, filepath, hastache, http-conduit, HUnit, lens

7847+ , lens-aeson, process, QuickCheck, random, smallcheck, split, syb

7848+ , tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck, text

7849+ , time, unix

7850+ }:

7851+ mkDerivation {

7852+ pname = "holy-project";

7853+ version = "0.1.1.1";

7854+ sha256 = "0vb4mlz6gb01aadm2b8kgvgnrwwvl6q4ndx6xldi0xi3rm22xkwj";

7855+ configureFlags = [

7856+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7857+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7858+ "-fsplitbase" "-f-test-hlint"

7859+ ];

7860+ isLibrary = true;

7861+ isExecutable = true;

7862+ enableSeparateDataOutput = true;

7863+ libraryHaskellDepends = [

7864+ aeson ansi-terminal base bytestring directory filepath hastache

7865+ http-conduit lens lens-aeson process random split syb text time

7866+ unix

7867+ ];

7868+ executableHaskellDepends = [

7869+ aeson ansi-terminal base bytestring Cabal directory filepath

7870+ hastache http-conduit HUnit lens lens-aeson process QuickCheck

7871+ random smallcheck split syb tasty tasty-hunit tasty-quickcheck

7872+ tasty-smallcheck text time unix

7873+ ];

7874+ testHaskellDepends = [

7875+ base bytestring Cabal HUnit QuickCheck smallcheck tasty tasty-hunit

7876+ tasty-quickcheck tasty-smallcheck

7877+ ];

7878+ homepage = "http://github.com/yogsototh/holy-project";

7879+ description = "Start your Haskell project with cabal, git and tests";

7880+ license = stdenv.lib.licenses.mit;

7881+ }) {};

7882+ "hoogle" = callPackage

7883+ ({ mkDerivation, aeson, array, base, binary, blaze-builder

7884+ , bytestring, Cabal, case-insensitive, cmdargs, conduit, containers

7885+ , deepseq, directory, filepath, haskell-src-exts, http-types

7886+ , old-locale, parsec, process, QuickCheck, random, resourcet, safe

7887+ , shake, tagsoup, temporary, text, time, transformers, uniplate

7888+ , unix, vector, vector-algorithms, wai, warp

7889+ }:

7890+ mkDerivation {

7891+ pname = "hoogle";

7892+ version = "4.2.36";

7893+ sha256 = "1h65pl0jfki2pcrywak9mh3hfi3wziffhb2q0xp6r4v01536zifv";

7894+ configureFlags = [

7895+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7896+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7897+ "-fsplitbase" "-f-test-hlint"

7898+ ];

7899+ isLibrary = true;

7900+ isExecutable = true;

7901+ enableSeparateDataOutput = true;

7902+ libraryHaskellDepends = [

7903+ array base binary blaze-builder bytestring case-insensitive conduit

7904+ containers deepseq directory filepath haskell-src-exts http-types

7905+ parsec process QuickCheck random resourcet safe text transformers

7906+ uniplate unix vector vector-algorithms wai

7907+ ];

7908+ executableHaskellDepends = [

7909+ aeson array base binary blaze-builder bytestring Cabal

7910+ case-insensitive cmdargs conduit containers deepseq directory

7911+ filepath haskell-src-exts http-types old-locale parsec process

7912+ QuickCheck random resourcet safe shake tagsoup text time

7913+ transformers uniplate unix vector vector-algorithms wai warp

7914+ ];

7915+ testHaskellDepends = [ base directory filepath process temporary ];

7916+ testTarget = "--test-option=--no-net";

7917+ homepage = "http://www.haskell.org/hoogle/";

7918+ description = "Haskell API Search";

7919+ license = stdenv.lib.licenses.bsd3;

7920+ }) {};

7921+ "hopenpgp-tools" = callPackage

7922+ ({ mkDerivation, aeson, alex, ansi-wl-pprint, array, attoparsec

7923+ , base, base16-bytestring, bytestring, cereal, cereal-conduit

7924+ , conduit, conduit-extra, containers, crypto-pubkey, cryptohash

7925+ , directory, errors, fgl, graphviz, happy, hOpenPGP, ixset, lens

7926+ , monad-loops, old-locale, openpgp-asciiarmor, optparse-applicative

7927+ , resourcet, text, time, transformers, unordered-containers, yaml

7928+ }:

7929+ mkDerivation {

7930+ pname = "hopenpgp-tools";

7931+ version = "0.13";

7932+ sha256 = "07w46jcdx573p4jii6xvgz1y8xm4iab89jg8jh0645pja5zv8nsz";

7933+ configureFlags = [

7934+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7935+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7936+ "-fsplitbase" "-f-test-hlint"

7937+ ];

7938+ isLibrary = false;

7939+ isExecutable = true;

7940+ executableHaskellDepends = [

7941+ aeson ansi-wl-pprint array attoparsec base base16-bytestring

7942+ bytestring cereal cereal-conduit conduit conduit-extra containers

7943+ crypto-pubkey cryptohash directory errors fgl graphviz hOpenPGP

7944+ ixset lens monad-loops old-locale openpgp-asciiarmor

7945+ optparse-applicative resourcet text time transformers

7946+ unordered-containers yaml

7947+ ];

7948+ executableToolDepends = [ alex happy ];

7949+ doHaddock = false;

7950+ homepage = "http://floss.scru.org/hopenpgp-tools";

7951+ description = "hOpenPGP-based command-line tools";

7952+ license = "unknown";

7953+ }) {};

7954+ "hostname" = callPackage

7955+ ({ mkDerivation, base }:

7956+ mkDerivation {

7957+ pname = "hostname";

7958+ version = "1.0";

7959+ sha256 = "0p6gm4328946qxc295zb6vhwhf07l1fma82vd0siylnsnsqxlhwv";

7960+ configureFlags = [

7961+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7962+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7963+ "-fsplitbase" "-f-test-hlint"

7964+ ];

7965+ libraryHaskellDepends = [ base ];

7966+ description = "A very simple package providing a cross-platform means of determining the hostname";

7967+ license = stdenv.lib.licenses.bsd3;

7968+ }) {};

7969+ "hostname-validate" = callPackage

7970+ ({ mkDerivation, attoparsec, base, bytestring }:

7971+ mkDerivation {

7972+ pname = "hostname-validate";

7973+ version = "1.0.0";

7974+ sha256 = "0my8g4kqf9mz7ii79ff53rwkx3yv9kkn4jbm60q4b7g1rzhb3bvz";

7975+ configureFlags = [

7976+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7977+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7978+ "-fsplitbase" "-f-test-hlint"

7979+ ];

7980+ libraryHaskellDepends = [ attoparsec base bytestring ];

7981+ description = "Validate hostnames e.g. localhost or foo.co.uk.";

7982+ license = stdenv.lib.licenses.bsd3;

7983+ }) {};

7984+ "hourglass" = callPackage

7985+ ({ mkDerivation, base, bytestring, criterion, deepseq, mtl

7986+ , old-locale, tasty, tasty-hunit, tasty-quickcheck, time

7987+ }:

7988+ mkDerivation {

7989+ pname = "hourglass";

7990+ version = "0.2.6";

7991+ sha256 = "029fmx5r6krj7y7mn4b4m2lpaa3iw6vhyznrib5lhf469i1jp9m3";

7992+ revision = "1";

7993+ editedCabalFile = "056kf543w7xrqsg925f2g6wb4wyy1b9f98dgn82sng9jv3qjsrp4";

7994+ configureFlags = [

7995+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7996+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7997+ "-fsplitbase" "-f-test-hlint"

7998+ ];

7999+ libraryHaskellDepends = [ base deepseq ];

8000+ testHaskellDepends = [

8001+ base deepseq mtl old-locale tasty tasty-hunit tasty-quickcheck time

8002+ ];

8003+ benchmarkHaskellDepends = [

8004+ base bytestring criterion deepseq mtl old-locale time

8005+ ];

8006+ homepage = "https://github.com/vincenthz/hs-hourglass";

8007+ description = "simple performant time related library";

8008+ license = stdenv.lib.licenses.bsd3;

8009+ }) {};

8010+ "hs-bibutils" = callPackage

8011+ ({ mkDerivation, base, syb }:

8012+ mkDerivation {

8013+ pname = "hs-bibutils";

8014+ version = "5.0";

8015+ sha256 = "18gchn62g2cqzyj1nr8wd5i6smhq739g00cblkllj1jkni33ch2l";

8016+ configureFlags = [

8017+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8018+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8019+ "-fsplitbase" "-f-test-hlint"

8020+ ];

8021+ libraryHaskellDepends = [ base syb ];

8022+ homepage = "http://gorgias.mine.nu/repos/hs-bibutils/";

8023+ description = "Haskell bindings to bibutils, the bibliography conversion utilities";

8024+ license = "GPL";

8025+ }) {};

8026+ "hscolour" = callPackage

8027+ ({ mkDerivation, base, containers }:

8028+ mkDerivation {

8029+ pname = "hscolour";

8030+ version = "1.20.3";

8031+ sha256 = "15ix93sw4p7g5ln2halcgqppdc0i0vmkzcjzxvqzkk9yp9pq3nrs";

8032+ configureFlags = [

8033+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8034+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8035+ "-fsplitbase" "-f-test-hlint"

8036+ ];

8037+ isLibrary = true;

8038+ isExecutable = true;

8039+ enableSeparateDataOutput = true;

8040+ libraryHaskellDepends = [ base containers ];

8041+ executableHaskellDepends = [ base containers ];

8042+ homepage = "http://code.haskell.org/~malcolm/hscolour/";

8043+ description = "Colourise Haskell code";

8044+ license = "GPL";

8045+ }) {};

8046+ "hse-cpp" = callPackage

8047+ ({ mkDerivation, base, cpphs, haskell-src-exts }:

8048+ mkDerivation {

8049+ pname = "hse-cpp";

8050+ version = "0.1";

8051+ sha256 = "0f1bgi1hnpnry1pm7jhi626afdvymzy7k0a70n07n41js46pjxd0";

8052+ revision = "1";

8053+ editedCabalFile = "0jrav7kl7a3a421xhaqh03jvj7qsgscpi93fpxss0q4pgq98gmcy";

8054+ configureFlags = [

8055+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8056+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8057+ "-fsplitbase" "-f-test-hlint"

8058+ ];

8059+ libraryHaskellDepends = [ base cpphs haskell-src-exts ];

8060+ description = "Preprocess+parse haskell code";

8061+ license = stdenv.lib.licenses.mit;

8062+ }) {};

8063+ "hslogger" = callPackage

8064+ ({ mkDerivation, base, containers, directory, mtl, network

8065+ , old-locale, process, time, unix

8066+ }:

8067+ mkDerivation {

8068+ pname = "hslogger";

8069+ version = "1.2.6";

8070+ sha256 = "0yqw7824bn8vb9iynx8lkgswxd0nz484k4bvcwd02wvakbbfawkk";

8071+ configureFlags = [

8072+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8073+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8074+ "-fsplitbase" "-f-test-hlint"

8075+ ];

8076+ isLibrary = true;

8077+ isExecutable = true;

8078+ libraryHaskellDepends = [

8079+ base containers directory mtl network old-locale process time unix

8080+ ];

8081+ homepage = "http://software.complete.org/hslogger";

8082+ description = "Versatile logging framework";

8083+ license = stdenv.lib.licenses.bsd3;

8084+ }) {};

8085+ "hslua" = callPackage

8086+ ({ mkDerivation, base, mtl }:

8087+ mkDerivation {

8088+ pname = "hslua";

8089+ version = "0.3.13";

8090+ sha256 = "02j3hrzq3dgcv4bvf4xz14qxvzlb0vlxrf7lk9wqwdy43b978mz9";

8091+ configureFlags = [

8092+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8093+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8094+ "-fsplitbase" "-f-test-hlint"

8095+ ];

8096+ libraryHaskellDepends = [ base mtl ];

8097+ testHaskellDepends = [ base ];

8098+ description = "A Lua language interpreter embedding in Haskell";

8099+ license = stdenv.lib.licenses.mit;

8100+ }) {};

8101+ "hspec" = callPackage

8102+ ({ mkDerivation, base, directory, hspec-core, hspec-discover

8103+ , hspec-expectations, hspec-meta, HUnit, QuickCheck, stringbuilder

8104+ , transformers

8105+ }:

8106+ mkDerivation {

8107+ pname = "hspec";

8108+ version = "2.1.2";

8109+ sha256 = "04n34g7gbmbkyqzp9by4qdcf87m1gasmc2hnm8i0dqpcnssv05py";

8110+ revision = "1";

8111+ editedCabalFile = "1y3kjhdm7lcrhjmk8xh5px84c4q14njmlvfyd0afbpq8r1cd0h03";

8112+ configureFlags = [

8113+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8114+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8115+ "-fsplitbase" "-f-test-hlint"

8116+ ];

8117+ libraryHaskellDepends = [

8118+ base hspec-core hspec-discover hspec-expectations HUnit QuickCheck

8119+ transformers

8120+ ];

8121+ testHaskellDepends = [

8122+ base directory hspec-core hspec-meta stringbuilder

8123+ ];

8124+ doHaddock = false;

8125+ doCheck = false;

8126+ homepage = "http://hspec.github.io/";

8127+ description = "A Testing Framework for Haskell";

8128+ license = stdenv.lib.licenses.mit;

8129+ }) {};

8130+ "hspec-core" = callPackage

8131+ ({ mkDerivation, ansi-terminal, async, base, deepseq

8132+ , hspec-expectations, hspec-meta, HUnit, process, QuickCheck

8133+ , quickcheck-io, random, setenv, silently, tf-random, time

8134+ , transformers

8135+ }:

8136+ mkDerivation {

8137+ pname = "hspec-core";

8138+ version = "2.1.2";

8139+ sha256 = "1mvsfr175g5dbk1xz48d0p4lv4gvv4z3ss3n2s7d2h83i25bmjvh";

8140+ revision = "3";

8141+ editedCabalFile = "0lkmnjmhzlx1vy3aqz8w71dfjm4567zp2s8w7d5i75c1vwpb43dv";

8142+ configureFlags = [

8143+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8144+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8145+ "-fsplitbase" "-f-test-hlint"

8146+ ];

8147+ libraryHaskellDepends = [

8148+ ansi-terminal async base deepseq hspec-expectations HUnit

8149+ QuickCheck quickcheck-io random setenv tf-random time transformers

8150+ ];

8151+ testHaskellDepends = [

8152+ ansi-terminal async base deepseq hspec-expectations hspec-meta

8153+ HUnit process QuickCheck quickcheck-io random setenv silently

8154+ tf-random time transformers

8155+ ];

8156+ homepage = "http://hspec.github.io/";

8157+ description = "A Testing Framework for Haskell";

8158+ license = stdenv.lib.licenses.mit;

8159+ }) {};

8160+ "hspec-discover" = callPackage

8161+ ({ mkDerivation, base, directory, filepath, hspec-meta }:

8162+ mkDerivation {

8163+ pname = "hspec-discover";

8164+ version = "2.1.2";

8165+ sha256 = "0zv215br94agvg8dbz0f5az5cahgnw8gdx0z84zlrpjxkzf3rb19";

8166+ configureFlags = [

8167+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8168+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8169+ "-fsplitbase" "-f-test-hlint"

8170+ ];

8171+ isLibrary = true;

8172+ isExecutable = true;

8173+ executableHaskellDepends = [ base directory filepath ];

8174+ testHaskellDepends = [ base directory filepath hspec-meta ];

8175+ doHaddock = false;

8176+ doCheck = false;

8177+ homepage = "http://hspec.github.io/";

8178+ description = "Automatically discover and run Hspec tests";

8179+ license = stdenv.lib.licenses.mit;

8180+ }) {};

8181+ "hspec-expectations" = callPackage

8182+ ({ mkDerivation, base, hspec, HUnit, markdown-unlit, silently }:

8183+ mkDerivation {

8184+ pname = "hspec-expectations";

8185+ version = "0.6.1";

8186+ sha256 = "0rr1dn39daxi4kqnbz3k21slxpscz939bx16161rr1zp4v7m1lzj";

8187+ revision = "1";

8188+ editedCabalFile = "0wc2d02i2y2a2xil6r43n60r5rzkr5nlbffwhcg2mwvpq0sglfqi";

8189+ configureFlags = [

8190+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8191+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8192+ "-fsplitbase" "-f-test-hlint"

8193+ ];

8194+ libraryHaskellDepends = [ base HUnit ];

8195+ testHaskellDepends = [ base hspec HUnit markdown-unlit silently ];

8196+ homepage = "https://github.com/sol/hspec-expectations#readme";

8197+ description = "Catchy combinators for HUnit";

8198+ license = stdenv.lib.licenses.mit;

8199+ }) {};

8200+ "hspec-meta" = callPackage

8201+ ({ mkDerivation, ansi-terminal, async, base, deepseq, directory

8202+ , filepath, hspec-expectations, HUnit, QuickCheck, quickcheck-io

8203+ , random, setenv, time, transformers

8204+ }:

8205+ mkDerivation {

8206+ pname = "hspec-meta";

8207+ version = "2.0.0";

8208+ sha256 = "0x1k2d4nycglzn9l4i32xrampr9fgzjpp4j1jyy7pj89cfl8jc8f";

8209+ configureFlags = [

8210+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8211+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8212+ "-fsplitbase" "-f-test-hlint"

8213+ ];

8214+ isLibrary = true;

8215+ isExecutable = true;

8216+ libraryHaskellDepends = [

8217+ ansi-terminal async base deepseq hspec-expectations HUnit

8218+ QuickCheck quickcheck-io random setenv time transformers

8219+ ];

8220+ executableHaskellDepends = [ base directory filepath ];

8221+ homepage = "http://hspec.github.io/";

8222+ description = "A version of Hspec which is used to test Hspec itself";

8223+ license = stdenv.lib.licenses.mit;

8224+ }) {};

8225+ "hspec-wai" = callPackage

8226+ ({ mkDerivation, base, bytestring, case-insensitive, hspec

8227+ , hspec-core, hspec-expectations, http-types, QuickCheck, text

8228+ , transformers, wai, wai-extra

8229+ }:

8230+ mkDerivation {

8231+ pname = "hspec-wai";

8232+ version = "0.6.2";

8233+ sha256 = "0nia4hz41g4264mn4s5j8dn9dh0xhdf1gym92wvjmy43rhj3qpzb";

8234+ configureFlags = [

8235+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8236+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8237+ "-fsplitbase" "-f-test-hlint"

8238+ ];

8239+ libraryHaskellDepends = [

8240+ base bytestring case-insensitive hspec-core hspec-expectations

8241+ http-types text transformers wai wai-extra

8242+ ];

8243+ testHaskellDepends = [

8244+ base bytestring case-insensitive hspec hspec-core

8245+ hspec-expectations http-types QuickCheck text transformers wai

8246+ wai-extra

8247+ ];

8248+ doHaddock = false;

8249+ doCheck = false;

8250+ description = "Experimental Hspec support for testing WAI applications";

8251+ license = stdenv.lib.licenses.mit;

8252+ }) {};

8253+ "hspec-wai-json" = callPackage

8254+ ({ mkDerivation, aeson, aeson-qq, base, bytestring, hspec

8255+ , hspec-wai, template-haskell

8256+ }:

8257+ mkDerivation {

8258+ pname = "hspec-wai-json";

8259+ version = "0.6.0";

8260+ sha256 = "0r9p8v3cynyx5gnan86cc0l5hrmnm3mx7w2kkc1npv6zq0cj1bgq";

8261+ configureFlags = [

8262+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8263+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8264+ "-fsplitbase" "-f-test-hlint"

8265+ ];

8266+ libraryHaskellDepends = [

8267+ aeson aeson-qq base bytestring hspec-wai template-haskell

8268+ ];

8269+ testHaskellDepends = [ base hspec hspec-wai ];

8270+ description = "Testing JSON APIs with hspec-wai";

8271+ license = stdenv.lib.licenses.mit;

8272+ }) {};

8273+ "hspec2" = callPackage

8274+ ({ mkDerivation, base, hspec, hspec-discover }:

8275+ mkDerivation {

8276+ pname = "hspec2";

8277+ version = "0.6.1";

8278+ sha256 = "0zlvm7r46q8yhgx2kx9mfrf6x2f5amdbi3a59fh69dsqs4lbgmf4";

8279+ revision = "1";

8280+ editedCabalFile = "0zqh0f7d89aw3ib7mx2wlkpc166f3zipgka4m54y2shcz3rbl7nl";

8281+ configureFlags = [

8282+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8283+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8284+ "-fsplitbase" "-f-test-hlint"

8285+ ];

8286+ libraryHaskellDepends = [ base hspec hspec-discover ];

8287+ doHaddock = false;

8288+ doCheck = false;

8289+ homepage = "http://hspec.github.io/";

8290+ description = "Alpha version of Hspec 2.0";

8291+ license = stdenv.lib.licenses.mit;

8292+ }) {};

8293+ "hsyslog" = callPackage

8294+ ({ mkDerivation, base, doctest }:

8295+ mkDerivation {

8296+ pname = "hsyslog";

8297+ version = "2.0";

8298+ sha256 = "02v698grn43bvikqhqiz9ys8x2amngdmhvl3i0ar9203p2x8q3pq";

8299+ configureFlags = [

8300+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8301+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8302+ "-fsplitbase" "-f-test-hlint"

8303+ ];

8304+ libraryHaskellDepends = [ base ];

8305+ testHaskellDepends = [ base doctest ];

8306+ homepage = "http://github.com/peti/hsyslog";

8307+ description = "FFI interface to syslog(3) from POSIX.1-2001";

8308+ license = stdenv.lib.licenses.bsd3;

8309+ }) {};

8310+ "html" = callPackage

8311+ ({ mkDerivation, base }:

8312+ mkDerivation {

8313+ pname = "html";

8314+ version = "1.0.1.2";

8315+ sha256 = "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c";

8316+ configureFlags = [

8317+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8318+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8319+ "-fsplitbase" "-f-test-hlint"

8320+ ];

8321+ libraryHaskellDepends = [ base ];

8322+ description = "HTML combinator library";

8323+ license = stdenv.lib.licenses.bsd3;

8324+ }) {};

8325+ "html-conduit" = callPackage

8326+ ({ mkDerivation, base, bytestring, conduit, conduit-extra

8327+ , containers, hspec, HUnit, resourcet, system-filepath

8328+ , tagstream-conduit, text, transformers, xml-conduit, xml-types

8329+ }:

8330+ mkDerivation {

8331+ pname = "html-conduit";

8332+ version = "1.1.1.1";

8333+ sha256 = "1bsr0fsy7k606m477c4rxdh7j71nyrp86f1lg9wlwnbm31vrhw00";

8334+ configureFlags = [

8335+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8336+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8337+ "-fsplitbase" "-f-test-hlint"

8338+ ];

8339+ libraryHaskellDepends = [

8340+ base bytestring conduit conduit-extra containers resourcet

8341+ system-filepath tagstream-conduit text transformers xml-conduit

8342+ xml-types

8343+ ];

8344+ testHaskellDepends = [

8345+ base bytestring containers hspec HUnit xml-conduit

8346+ ];

8347+ homepage = "https://github.com/snoyberg/xml";

8348+ description = "Parse HTML documents using xml-conduit datatypes";

8349+ license = stdenv.lib.licenses.mit;

8350+ }) {};

8351+ "http-client" = callPackage

8352+ ({ mkDerivation, array, async, base, base64-bytestring

8353+ , blaze-builder, bytestring, case-insensitive, containers, cookie

8354+ , data-default-class, deepseq, exceptions, filepath, ghc-prim

8355+ , hspec, http-types, mime-types, monad-control, network

8356+ , publicsuffixlist, random, streaming-commons, text, time

8357+ , transformers, zlib

8358+ }:

8359+ mkDerivation {

8360+ pname = "http-client";

8361+ version = "0.4.6";

8362+ sha256 = "0zv1jncacwxxk8dj1jlicjdlfhxigpl23frq2vrp4w76d1lsa0d8";

8363+ configureFlags = [

8364+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8365+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8366+ "-fsplitbase" "-f-test-hlint"

8367+ ];

8368+ libraryHaskellDepends = [

8369+ array base base64-bytestring blaze-builder bytestring

8370+ case-insensitive containers cookie data-default-class deepseq

8371+ exceptions filepath ghc-prim http-types mime-types network

8372+ publicsuffixlist random streaming-commons text time transformers

8373+ ];

8374+ testHaskellDepends = [

8375+ async base base64-bytestring blaze-builder bytestring

8376+ case-insensitive containers deepseq hspec http-types monad-control

8377+ network streaming-commons text time transformers zlib

8378+ ];

8379+ homepage = "https://github.com/snoyberg/http-client";

8380+ description = "An HTTP client engine, intended as a base layer for more user-friendly packages";

8381+ license = stdenv.lib.licenses.mit;

8382+ }) {};

8383+ "http-client-tls" = callPackage

8384+ ({ mkDerivation, base, bytestring, connection, data-default-class

8385+ , hspec, http-client, http-types, network, tls

8386+ }:

8387+ mkDerivation {

8388+ pname = "http-client-tls";

8389+ version = "0.2.2";

8390+ sha256 = "0a01r05h5fxswyn6k6cgqgak4scqjan72hyy5wbdqzzhl4rmh7j5";

8391+ revision = "1";

8392+ editedCabalFile = "01ycp67hb0vlk4l43fv53vspw4izp9mjzapagfzamrahlcdps85b";

8393+ configureFlags = [

8394+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8395+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8396+ "-fsplitbase" "-f-test-hlint"

8397+ ];

8398+ libraryHaskellDepends = [

8399+ base bytestring connection data-default-class http-client network

8400+ tls

8401+ ];

8402+ testHaskellDepends = [ base hspec http-client http-types ];

8403+ homepage = "https://github.com/snoyberg/http-client";

8404+ description = "http-client backend using the connection package and tls library";

8405+ license = stdenv.lib.licenses.mit;

8406+ }) {};

8407+ "http-conduit" = callPackage

8408+ ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive

8409+ , conduit, conduit-extra, connection, cookie, data-default-class

8410+ , hspec, http-client, http-client-tls, http-types, HUnit

8411+ , lifted-base, monad-control, mtl, network, resourcet

8412+ , streaming-commons, text, time, transformers, utf8-string, wai

8413+ , wai-conduit, warp, warp-tls

8414+ }:

8415+ mkDerivation {

8416+ pname = "http-conduit";

8417+ version = "2.1.5";

8418+ sha256 = "0vk2an6h3h7a5klk9xrf3apfm6xdmqm418yrr7pb56b7w5sfq003";

8419+ revision = "1";

8420+ editedCabalFile = "0rgdrjwkkh778d788xhrnnibygprgy718365214n38yl6jxmqlqg";

8421+ configureFlags = [

8422+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8423+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8424+ "-fsplitbase" "-f-test-hlint"

8425+ ];

8426+ libraryHaskellDepends = [

8427+ base bytestring conduit http-client http-client-tls http-types

8428+ lifted-base monad-control mtl resourcet transformers

8429+ ];

8430+ testHaskellDepends = [

8431+ base blaze-builder bytestring case-insensitive conduit

8432+ conduit-extra connection cookie data-default-class hspec

8433+ http-client http-types HUnit lifted-base network streaming-commons

8434+ text time transformers utf8-string wai wai-conduit warp warp-tls

8435+ ];

8436+ homepage = "http://www.yesodweb.com/book/http-conduit";

8437+ description = "HTTP client package with conduit interface and HTTPS support";

8438+ license = stdenv.lib.licenses.bsd3;

8439+ }) {};

8440+ "http-date" = callPackage

8441+ ({ mkDerivation, array, attoparsec, base, bytestring, doctest

8442+ , hspec, old-locale, time

8443+ }:

8444+ mkDerivation {

8445+ pname = "http-date";

8446+ version = "0.0.4";

8447+ sha256 = "1pbm066i1cpa3z2kfsqpva0qixnx87s76dpafz3wf6dkaqj8n8i5";

8448+ configureFlags = [

8449+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8450+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8451+ "-fsplitbase" "-f-test-hlint"

8452+ ];

8453+ libraryHaskellDepends = [ array attoparsec base bytestring ];

8454+ testHaskellDepends = [

8455+ base bytestring doctest hspec old-locale time

8456+ ];

8457+ description = "HTTP Date parser/formatter";

8458+ license = stdenv.lib.licenses.bsd3;

8459+ }) {};

8460+ "http-reverse-proxy" = callPackage

8461+ ({ mkDerivation, async, base, blaze-builder, bytestring

8462+ , case-insensitive, conduit, conduit-extra, containers

8463+ , data-default-class, hspec, http-client, http-conduit, http-types

8464+ , lifted-base, monad-control, network, resourcet, streaming-commons

8465+ , text, transformers, wai, wai-logger, warp, word8

8466+ }:

8467+ mkDerivation {

8468+ pname = "http-reverse-proxy";

8469+ version = "0.4.1.2";

8470+ sha256 = "1gggn5l08g7mxbka0h7h8w687y3awbm19395fi6wvis76isyz8wy";

8471+ revision = "1";

8472+ editedCabalFile = "0fwwb3wnmxrfvn8pvi3hpz8hrpjd8s5rajhh4j4x9355ac7cz61i";

8473+ configureFlags = [

8474+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8475+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8476+ "-fsplitbase" "-f-test-hlint"

8477+ ];

8478+ libraryHaskellDepends = [

8479+ async base blaze-builder bytestring case-insensitive conduit

8480+ conduit-extra containers data-default-class http-client http-types

8481+ lifted-base monad-control network resourcet streaming-commons text

8482+ transformers wai wai-logger word8

8483+ ];

8484+ testHaskellDepends = [

8485+ base blaze-builder bytestring conduit conduit-extra hspec

8486+ http-conduit http-types lifted-base network resourcet

8487+ streaming-commons transformers wai warp

8488+ ];

8489+ homepage = "https://github.com/fpco/http-reverse-proxy";

8490+ description = "Reverse proxy HTTP requests, either over raw sockets or with WAI";

8491+ license = stdenv.lib.licenses.bsd3;

8492+ }) {};

8493+ "http-types" = callPackage

8494+ ({ mkDerivation, array, base, blaze-builder, bytestring

8495+ , case-insensitive, doctest, hspec, QuickCheck

8496+ , quickcheck-instances, text

8497+ }:

8498+ mkDerivation {

8499+ pname = "http-types";

8500+ version = "0.8.5";

8501+ sha256 = "0d282sf3xyk5makhnwfm2k9mgw1fkh07kasmy85fiwjkc1447ciw";

8502+ configureFlags = [

8503+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8504+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8505+ "-fsplitbase" "-f-test-hlint"

8506+ ];

8507+ libraryHaskellDepends = [

8508+ array base blaze-builder bytestring case-insensitive text

8509+ ];

8510+ testHaskellDepends = [

8511+ base blaze-builder bytestring doctest hspec QuickCheck

8512+ quickcheck-instances text

8513+ ];

8514+ homepage = "https://github.com/aristidb/http-types";

8515+ description = "Generic HTTP types for Haskell (for both client and server code)";

8516+ license = stdenv.lib.licenses.bsd3;

8517+ }) {};

8518+ "hweblib" = callPackage

8519+ ({ mkDerivation, attoparsec, base, bytestring, containers

8520+ , criterion, HUnit, mtl, text, transformers

8521+ }:

8522+ mkDerivation {

8523+ pname = "hweblib";

8524+ version = "0.6.3";

8525+ sha256 = "03dmx5irlsyb3b9zg2r6nz947sslizkn0nlk65ldb5n4m8my33hy";

8526+ configureFlags = [

8527+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8528+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8529+ "-fsplitbase" "-f-test-hlint"

8530+ ];

8531+ libraryHaskellDepends = [

8532+ attoparsec base bytestring containers mtl text transformers

8533+ ];

8534+ testHaskellDepends = [

8535+ attoparsec base bytestring containers HUnit mtl transformers

8536+ ];

8537+ benchmarkHaskellDepends = [

8538+ attoparsec base bytestring containers criterion HUnit mtl

8539+ transformers

8540+ ];

8541+ homepage = "http://github.com/aycanirican/hweblib";

8542+ description = "Haskell Web Library";

8543+ license = stdenv.lib.licenses.bsd3;

8544+ }) {};

8545+ "hxt" = callPackage

8546+ ({ mkDerivation, base, binary, bytestring, containers, deepseq

8547+ , directory, filepath, HUnit, hxt-charproperties

8548+ , hxt-regex-xmlschema, hxt-unicode, mtl, network, parsec

8549+ }:

8550+ mkDerivation {

8551+ pname = "hxt";

8552+ version = "9.3.1.7";

8553+ sha256 = "1dgdq2l9k8v36iahmkxxjmmv955f9gv6lq09nsah9zcscsgm0v2i";

8554+ configureFlags = [

8555+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8556+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8557+ "-fsplitbase" "-f-test-hlint"

8558+ ];

8559+ libraryHaskellDepends = [

8560+ base binary bytestring containers deepseq directory filepath HUnit

8561+ hxt-charproperties hxt-regex-xmlschema hxt-unicode mtl network

8562+ parsec

8563+ ];

8564+ homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";

8565+ description = "A collection of tools for processing XML with Haskell";

8566+ license = stdenv.lib.licenses.mit;

8567+ }) {};

8568+ "hxt-charproperties" = callPackage

8569+ ({ mkDerivation, base }:

8570+ mkDerivation {

8571+ pname = "hxt-charproperties";

8572+ version = "9.2.0.0";

8573+ sha256 = "01v3j0cg9pkp18iy4s8s582qqq98r4l9jzr84x5sa2rva4cg0gpi";

8574+ configureFlags = [

8575+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8576+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8577+ "-fsplitbase" "-f-test-hlint"

8578+ ];

8579+ libraryHaskellDepends = [ base ];

8580+ homepage = "https://github.com/UweSchmidt/hxt";

8581+ description = "Character properties and classes for XML and Unicode";

8582+ license = stdenv.lib.licenses.mit;

8583+ }) {};

8584+ "hxt-http" = callPackage

8585+ ({ mkDerivation, base, bytestring, HTTP, hxt, network, parsec }:

8586+ mkDerivation {

8587+ pname = "hxt-http";

8588+ version = "9.1.5";

8589+ sha256 = "172y08zx9q4qvdi7k9hg9qahp6qjs24r663il6fmynaw7szsiib9";

8590+ configureFlags = [

8591+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8592+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8593+ "-fsplitbase" "-f-test-hlint"

8594+ ];

8595+ libraryHaskellDepends = [

8596+ base bytestring HTTP hxt network parsec

8597+ ];

8598+ homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";

8599+ description = "Interface to native Haskell HTTP package HTTP";

8600+ license = stdenv.lib.licenses.mit;

8601+ }) {};

8602+ "hxt-pickle-utils" = callPackage

8603+ ({ mkDerivation, base, hxt, mtl }:

8604+ mkDerivation {

8605+ pname = "hxt-pickle-utils";

8606+ version = "0.1.0.2";

8607+ sha256 = "06v4935lljcyyx4a5v0z4id3fz4v28aghsrzr94k6diibpnwcdz2";

8608+ revision = "1";

8609+ editedCabalFile = "1yyjb49q82wqhhbg1922az76rr41ipji8a7bw1zfxhsp5i03n5w9";

8610+ configureFlags = [

8611+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8612+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8613+ "-fsplitbase" "-f-test-hlint"

8614+ ];

8615+ libraryHaskellDepends = [ base hxt mtl ];

8616+ homepage = "https://github.com/silkapp/hxt-pickle-utils";

8617+ description = "Utility functions for using HXT picklers";

8618+ license = stdenv.lib.licenses.bsd3;

8619+ }) {};

8620+ "hxt-regex-xmlschema" = callPackage

8621+ ({ mkDerivation, base, bytestring, criterion, deepseq, HUnit

8622+ , hxt-charproperties, parsec, text

8623+ }:

8624+ mkDerivation {

8625+ pname = "hxt-regex-xmlschema";

8626+ version = "9.2.0";

8627+ sha256 = "0pcbyvc71173ad0zkgpdpyyljngrk4p1jjjaw5wbwcvm4ijh44g3";

8628+ revision = "1";

8629+ editedCabalFile = "1diblgrmih50p34nsjhi8wzrspvasynmxbbn1i9scfinzmaq9004";

8630+ configureFlags = [

8631+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8632+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8633+ "-fsplitbase" "-f-test-hlint"

8634+ ];

8635+ libraryHaskellDepends = [

8636+ base bytestring hxt-charproperties parsec text

8637+ ];

8638+ testHaskellDepends = [ base bytestring HUnit parsec text ];

8639+ benchmarkHaskellDepends = [

8640+ base bytestring criterion deepseq parsec text

8641+ ];

8642+ homepage = "http://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema";

8643+ description = "A regular expression library for W3C XML Schema regular expressions";

8644+ license = stdenv.lib.licenses.mit;

8645+ }) {};

8646+ "hxt-relaxng" = callPackage

8647+ ({ mkDerivation, base, containers, hxt, hxt-charproperties

8648+ , hxt-regex-xmlschema, network, parsec

8649+ }:

8650+ mkDerivation {

8651+ pname = "hxt-relaxng";

8652+ version = "9.1.5.1";

8653+ sha256 = "16jzsk9gkrqnq1d1n5nm0w6b4viq7938zlis26mm975x6s12i1w6";

8654+ configureFlags = [

8655+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8656+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8657+ "-fsplitbase" "-f-test-hlint"

8658+ ];

8659+ libraryHaskellDepends = [

8660+ base containers hxt hxt-charproperties hxt-regex-xmlschema network

8661+ parsec

8662+ ];

8663+ homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";

8664+ description = "The HXT RelaxNG validator";

8665+ license = stdenv.lib.licenses.mit;

8666+ }) {};

8667+ "hxt-unicode" = callPackage

8668+ ({ mkDerivation, base, hxt-charproperties }:

8669+ mkDerivation {

8670+ pname = "hxt-unicode";

8671+ version = "9.0.2.2";

8672+ sha256 = "1iljbk7f7d4wkl592bp0vw807683sqdxfnigindkrvr9p1xvwg8r";

8673+ configureFlags = [

8674+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8675+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8676+ "-fsplitbase" "-f-test-hlint"

8677+ ];

8678+ libraryHaskellDepends = [ base hxt-charproperties ];

8679+ homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";

8680+ description = "Unicode en-/decoding functions for utf8, iso-latin-* and other encodings";

8681+ license = stdenv.lib.licenses.mit;

8682+ }) {};

8683+ "hybrid-vectors" = callPackage

8684+ ({ mkDerivation, base, deepseq, primitive, vector }:

8685+ mkDerivation {

8686+ pname = "hybrid-vectors";

8687+ version = "0.1.2";

8688+ sha256 = "1scx1xr9rqdpxc1kj5zgf8w1ld1mj68hxr3nl1p352wspvpgd3qf";

8689+ revision = "1";

8690+ editedCabalFile = "1rrrj5ahlg4mifzfrlj8ha82qfr031kcf6w4w1j6h7ab4hji7q2j";

8691+ configureFlags = [

8692+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8693+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8694+ "-fsplitbase" "-f-test-hlint"

8695+ ];

8696+ libraryHaskellDepends = [ base deepseq primitive vector ];

8697+ homepage = "http://github.com/ekmett/hybrid-vectors";

8698+ description = "Hybrid vectors e.g. Mixed Boxed/Unboxed vectors";

8699+ license = stdenv.lib.licenses.bsd3;

8700+ }) {};

8701+ "hyphenation" = callPackage

8702+ ({ mkDerivation, base, containers, directory, doctest, filepath

8703+ , unordered-containers

8704+ }:

8705+ mkDerivation {

8706+ pname = "hyphenation";

8707+ version = "0.4";

8708+ sha256 = "06na4y568v3plsyvgcqmra1crv10fcfal419fjjv300vkaafbyxb";

8709+ configureFlags = [

8710+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8711+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8712+ "-fsplitbase" "-f-test-hlint"

8713+ ];

8714+ enableSeparateDataOutput = true;

8715+ libraryHaskellDepends = [ base containers unordered-containers ];

8716+ testHaskellDepends = [

8717+ base containers directory doctest filepath unordered-containers

8718+ ];

8719+ doHaddock = false;

8720+ doCheck = false;

8721+ homepage = "http://github.com/ekmett/hyphenation";

8722+ description = "Configurable Knuth-Liang hyphenation";

8723+ license = stdenv.lib.licenses.bsd3;

8724+ }) {};

8725+ "idna" = callPackage

8726+ ({ mkDerivation, base, punycode, stringprep, text }:

8727+ mkDerivation {

8728+ pname = "idna";

8729+ version = "0.3.0";

8730+ sha256 = "04w2mp9wa4mzdz4njx47j081jia8y000b46cw8vmx44fx8gv1zwp";

8731+ configureFlags = [

8732+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8733+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8734+ "-fsplitbase" "-f-test-hlint"

8735+ ];

8736+ libraryHaskellDepends = [ base punycode stringprep text ];

8737+ description = "Implements IDNA (RFC 3490)";

8738+ license = stdenv.lib.licenses.bsd3;

8739+ }) {};

8740+ "ieee754" = callPackage

8741+ ({ mkDerivation, base }:

8742+ mkDerivation {

8743+ pname = "ieee754";

8744+ version = "0.7.4";

8745+ sha256 = "1pxbkfa21mvc869n18nn7r29hcinxdbsnk68nlldzld8f6m13g1h";

8746+ configureFlags = [

8747+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8748+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8749+ "-fsplitbase" "-f-test-hlint"

8750+ ];

8751+ libraryHaskellDepends = [ base ];

8752+ homepage = "http://github.com/patperry/hs-ieee754";

8753+ description = "Utilities for dealing with IEEE floating point numbers";

8754+ license = stdenv.lib.licenses.bsd3;

8755+ }) {};

8756+ "imagesize-conduit" = callPackage

8757+ ({ mkDerivation, base, bytestring, conduit, conduit-extra, hspec

8758+ , resourcet

8759+ }:

8760+ mkDerivation {

8761+ pname = "imagesize-conduit";

8762+ version = "1.0.0.4";

8763+ sha256 = "0hhmjbdqdljfy3khzpg2xq6kgxa9x89jvpci7lf413pc1lpg4cw7";

8764+ revision = "1";

8765+ editedCabalFile = "0gaas69df3m6q6yanzhzyv4smqkar4svs6yzy7vcvq9aayk6x6ls";

8766+ configureFlags = [

8767+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8768+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8769+ "-fsplitbase" "-f-test-hlint"

8770+ ];

8771+ libraryHaskellDepends = [ base bytestring conduit conduit-extra ];

8772+ testHaskellDepends = [

8773+ base bytestring conduit conduit-extra hspec resourcet

8774+ ];

8775+ homepage = "http://github.com/silkapp/imagesize-conduit";

8776+ description = "Determine the size of some common image formats";

8777+ license = stdenv.lib.licenses.bsd3;

8778+ }) {};

8779+ "immortal" = callPackage

8780+ ({ mkDerivation, base, lifted-base, monad-control, stm, tasty

8781+ , tasty-hunit, transformers, transformers-base

8782+ }:

8783+ mkDerivation {

8784+ pname = "immortal";

8785+ version = "0.2";

8786+ sha256 = "1si9zh309xh29qrxkhb0shwisjrsja2d9lpj17dwlzn0gv0i1672";

8787+ configureFlags = [

8788+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8789+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8790+ "-fsplitbase" "-f-test-hlint"

8791+ ];

8792+ libraryHaskellDepends = [

8793+ base lifted-base monad-control transformers-base

8794+ ];

8795+ testHaskellDepends = [

8796+ base lifted-base stm tasty tasty-hunit transformers

8797+ ];

8798+ homepage = "https://github.com/feuerbach/immortal";

8799+ description = "Spawn threads that never die (unless told to do so)";

8800+ license = stdenv.lib.licenses.mit;

8801+ }) {};

8802+ "incremental-parser" = callPackage

8803+ ({ mkDerivation, base, checkers, monoid-subclasses, QuickCheck

8804+ , test-framework, test-framework-quickcheck2

8805+ }:

8806+ mkDerivation {

8807+ pname = "incremental-parser";

8808+ version = "0.2.3.3";

8809+ sha256 = "0d1d05xf03glq770psykp1ip2z296spyrgs2g8nvigk6af2zy7nn";

8810+ configureFlags = [

8811+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8812+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8813+ "-fsplitbase" "-f-test-hlint"

8814+ ];

8815+ libraryHaskellDepends = [ base monoid-subclasses ];

8816+ testHaskellDepends = [

8817+ base checkers monoid-subclasses QuickCheck test-framework

8818+ test-framework-quickcheck2

8819+ ];

8820+ homepage = "http://patch-tag.com/r/blamario/incremental-parser/wiki/";

8821+ description = "Generic parser library capable of providing partial results from partial input";

8822+ license = "GPL";

8823+ }) {};

8824+ "indents" = callPackage

8825+ ({ mkDerivation, base, concatenative, mtl, parsec }:

8826+ mkDerivation {

8827+ pname = "indents";

8828+ version = "0.3.3";

8829+ sha256 = "16lz21bp9j14xilnq8yym22p3saxvc9fsgfcf5awn2a6i6n527xn";

8830+ configureFlags = [

8831+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8832+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8833+ "-fsplitbase" "-f-test-hlint"

8834+ ];

8835+ libraryHaskellDepends = [ base concatenative mtl parsec ];

8836+ homepage = "http://patch-tag.com/r/salazar/indents";

8837+ description = "indentation sensitive parser-combinators for parsec";

8838+ license = stdenv.lib.licenses.bsd3;

8839+ }) {};

8840+ "ini" = callPackage

8841+ ({ mkDerivation, attoparsec, base, text, unordered-containers }:

8842+ mkDerivation {

8843+ pname = "ini";

8844+ version = "0.2.2";

8845+ sha256 = "1g2dpx3cb06750qdv1ynfw7yj6r72jzzn0xxiwa7a33ncskhd8ig";

8846+ configureFlags = [

8847+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8848+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8849+ "-fsplitbase" "-f-test-hlint"

8850+ ];

8851+ libraryHaskellDepends = [

8852+ attoparsec base text unordered-containers

8853+ ];

8854+ description = "Quick and easy configuration files in the INI format";

8855+ license = stdenv.lib.licenses.bsd3;

8856+ }) {};

8857+ "integration" = callPackage

8858+ ({ mkDerivation, base, parallel }:

8859+ mkDerivation {

8860+ pname = "integration";

8861+ version = "0.2.0.1";

8862+ sha256 = "1pwykd7jjy1d7inf747mpz2bh7ygakmlb90xi57dwm8h249knbmk";

8863+ configureFlags = [

8864+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8865+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8866+ "-fsplitbase" "-f-test-hlint"

8867+ ];

8868+ libraryHaskellDepends = [ base parallel ];

8869+ homepage = "https://github.com/ekmett/integration";

8870+ description = "Fast robust numeric integration via tanh-sinh quadrature";

8871+ license = stdenv.lib.licenses.bsd3;

8872+ }) {};

8873+ "interpolate" = callPackage

8874+ ({ mkDerivation, base, bytestring, haskell-src-meta, hspec

8875+ , QuickCheck, quickcheck-instances, template-haskell, text

8876+ }:

8877+ mkDerivation {

8878+ pname = "interpolate";

8879+ version = "0.1.0";

8880+ sha256 = "0wlc10qd1bq3xj64a3yq2gzds9kas9zyylkm9kxd46gy35fns6id";

8881+ revision = "1";

8882+ editedCabalFile = "0ld319k9phmp6dp8m87bdhqp5519dxggf8r2a5z8hkznyjpa131j";

8883+ configureFlags = [

8884+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8885+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8886+ "-fsplitbase" "-f-test-hlint"

8887+ ];

8888+ libraryHaskellDepends = [ base haskell-src-meta template-haskell ];

8889+ testHaskellDepends = [

8890+ base bytestring haskell-src-meta hspec QuickCheck

8891+ quickcheck-instances template-haskell text

8892+ ];

8893+ description = "String interpolation done right";

8894+ license = stdenv.lib.licenses.mit;

8895+ }) {};

8896+ "interpolatedstring-perl6" = callPackage

8897+ ({ mkDerivation, base, bytestring, haskell-src-meta

8898+ , template-haskell, text

8899+ }:

8900+ mkDerivation {

8901+ pname = "interpolatedstring-perl6";

8902+ version = "0.9.0";

8903+ sha256 = "15hzmni3wfdgjl0vyk5mcld61ba99wdax87s7wkz2s8bsyxkbq9n";

8904+ configureFlags = [

8905+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8906+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8907+ "-fsplitbase" "-f-test-hlint"

8908+ ];

8909+ enableSeparateDataOutput = true;

8910+ libraryHaskellDepends = [

8911+ base bytestring haskell-src-meta template-haskell text

8912+ ];

8913+ description = "QuasiQuoter for Perl6-style multi-line interpolated strings";

8914+ license = stdenv.lib.licenses.bsd3;

8915+ }) {};

8916+ "intervals" = callPackage

8917+ ({ mkDerivation, array, base, directory, distributive, doctest

8918+ , filepath, ghc-prim

8919+ }:

8920+ mkDerivation {

8921+ pname = "intervals";

8922+ version = "0.7.0.1";

8923+ sha256 = "02qb44ga2yfsymkfixy3fdp943r2flwrsaqhb0pjddr3ixzm4ap9";

8924+ revision = "1";

8925+ editedCabalFile = "0jyl65cqm0v70kr3j3b5ng9rdjhq66mgag4908dk8byz45wmqczz";

8926+ configureFlags = [

8927+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8928+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8929+ "-fsplitbase" "-f-test-hlint"

8930+ ];

8931+ libraryHaskellDepends = [ array base distributive ghc-prim ];

8932+ testHaskellDepends = [ base directory doctest filepath ];

8933+ homepage = "http://github.com/ekmett/intervals";

8934+ description = "Interval Arithmetic";

8935+ license = stdenv.lib.licenses.bsd3;

8936+ }) {};

8937+ "io-choice" = callPackage

8938+ ({ mkDerivation, base, hspec, lifted-base, monad-control

8939+ , template-haskell, transformers, transformers-base

8940+ }:

8941+ mkDerivation {

8942+ pname = "io-choice";

8943+ version = "0.0.5";

8944+ sha256 = "19nr8kxcg98510cqgjn4c9sd8i9yz8fv4ryqg6lzzgpwqzkvx5ph";

8945+ configureFlags = [

8946+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8947+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8948+ "-fsplitbase" "-f-test-hlint"

8949+ ];

8950+ libraryHaskellDepends = [

8951+ base lifted-base monad-control template-haskell transformers

8952+ transformers-base

8953+ ];

8954+ testHaskellDepends = [

8955+ base hspec lifted-base monad-control transformers

8956+ ];

8957+ description = "Choice for IO and lifted IO";

8958+ license = stdenv.lib.licenses.bsd3;

8959+ }) {};

8960+ "io-manager" = callPackage

8961+ ({ mkDerivation, base, containers }:

8962+ mkDerivation {

8963+ pname = "io-manager";

8964+ version = "0.1.0.2";

8965+ sha256 = "0f21h36z2ls0d6g31pcf4kcyfninaxws8w159zy33bwa19saf2mz";

8966+ configureFlags = [

8967+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8968+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8969+ "-fsplitbase" "-f-test-hlint"

8970+ ];

8971+ isLibrary = true;

8972+ isExecutable = true;

8973+ libraryHaskellDepends = [ base containers ];

8974+ executableHaskellDepends = [ base containers ];

8975+ description = "Skeleton library around the IO monad";

8976+ license = stdenv.lib.licenses.bsd3;

8977+ }) {};

8978+ "io-memoize" = callPackage

8979+ ({ mkDerivation, async, base }:

8980+ mkDerivation {

8981+ pname = "io-memoize";

8982+ version = "1.1.1.0";

8983+ sha256 = "0ga85wdvz67jjx8qh6f687kfikcrfmp7winn13v6na7vlaqs2ly7";

8984+ configureFlags = [

8985+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8986+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8987+ "-fsplitbase" "-f-test-hlint"

8988+ ];

8989+ libraryHaskellDepends = [ async base ];

8990+ homepage = "https://github.com/DanBurton/io-memoize";

8991+ description = "Memoize IO actions";

8992+ license = stdenv.lib.licenses.bsd3;

8993+ }) {};

8994+ "iproute" = callPackage

8995+ ({ mkDerivation, appar, base, byteorder, containers, doctest, hspec

8996+ , network, QuickCheck, safe

8997+ }:

8998+ mkDerivation {

8999+ pname = "iproute";

9000+ version = "1.3.1";

9001+ sha256 = "1l3asv8q1jiwsvpq6kkigrzpm3pjbm03gpc4rbhn6kpi6z9h8cdp";

9002+ configureFlags = [

9003+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9004+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9005+ "-fsplitbase" "-f-test-hlint"

9006+ ];

9007+ libraryHaskellDepends = [

9008+ appar base byteorder containers network

9009+ ];

9010+ testHaskellDepends = [

9011+ appar base byteorder containers doctest hspec network QuickCheck

9012+ safe

9013+ ];

9014+ homepage = "http://www.mew.org/~kazu/proj/iproute/";

9015+ description = "IP Routing Table";

9016+ license = stdenv.lib.licenses.bsd3;

9017+ }) {};

9018+ "iterable" = callPackage

9019+ ({ mkDerivation, base, mtl, tagged, template-haskell, vector }:

9020+ mkDerivation {

9021+ pname = "iterable";

9022+ version = "3.0";

9023+ sha256 = "194718jpjwkv3ynlpgjlpvf0iqnj7dkd3zmci363gsa425i3vlbc";

9024+ configureFlags = [

9025+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9026+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9027+ "-fsplitbase" "-f-test-hlint"

9028+ ];

9029+ enableSeparateDataOutput = true;

9030+ libraryHaskellDepends = [

9031+ base mtl tagged template-haskell vector

9032+ ];

9033+ homepage = "https://github.com/BioHaskell/iterable";

9034+ description = "API for hierarchical multilevel collections";

9035+ license = stdenv.lib.licenses.bsd3;

9036+ }) {};

9037+ "ixset" = callPackage

9038+ ({ mkDerivation, base, containers, safecopy, syb, syb-with-class

9039+ , template-haskell

9040+ }:

9041+ mkDerivation {

9042+ pname = "ixset";

9043+ version = "1.0.6";

9044+ sha256 = "097f9fkm9a2n67bzagr9h2v7acdn8h1ayv9c83n7nv1dh157bpyv";

9045+ configureFlags = [

9046+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9047+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9048+ "-fsplitbase" "-f-test-hlint"

9049+ ];

9050+ libraryHaskellDepends = [

9051+ base containers safecopy syb syb-with-class template-haskell

9052+ ];

9053+ homepage = "http://happstack.com";

9054+ description = "Efficient relational queries on Haskell sets";

9055+ license = stdenv.lib.licenses.bsd3;

9056+ }) {};

9057+ "js-flot" = callPackage

9058+ ({ mkDerivation, base, HTTP }:

9059+ mkDerivation {

9060+ pname = "js-flot";

9061+ version = "0.8.3";

9062+ sha256 = "0yjyzqh3qzhy5h3nql1fckw0gcfb0f4wj9pm85nafpfqp2kg58hv";

9063+ configureFlags = [

9064+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9065+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9066+ "-fsplitbase" "-f-test-hlint"

9067+ ];

9068+ enableSeparateDataOutput = true;

9069+ libraryHaskellDepends = [ base ];

9070+ testHaskellDepends = [ base HTTP ];

9071+ homepage = "https://github.com/ndmitchell/js-flot#readme";

9072+ description = "Obtain minified flot code";

9073+ license = stdenv.lib.licenses.mit;

9074+ }) {};

9075+ "js-jquery" = callPackage

9076+ ({ mkDerivation, base, HTTP }:

9077+ mkDerivation {

9078+ pname = "js-jquery";

9079+ version = "1.11.1";

9080+ sha256 = "0k4hrpxsc48nanr2zw6jcirirsarlshycx7d5hzqqv9jfhy1i88d";

9081+ configureFlags = [

9082+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9083+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9084+ "-fsplitbase" "-f-test-hlint"

9085+ ];

9086+ enableSeparateDataOutput = true;

9087+ libraryHaskellDepends = [ base ];

9088+ testHaskellDepends = [ base HTTP ];

9089+ homepage = "https://github.com/ndmitchell/js-jquery#readme";

9090+ description = "Obtain minified jQuery code";

9091+ license = stdenv.lib.licenses.mit;

9092+ }) {};

9093+ "json-schema" = callPackage

9094+ ({ mkDerivation, aeson, aeson-utils, attoparsec, base, bytestring

9095+ , containers, generic-aeson, generic-deriving, mtl, scientific

9096+ , tagged, tasty, tasty-hunit, tasty-th, text, time

9097+ , unordered-containers, vector

9098+ }:

9099+ mkDerivation {

9100+ pname = "json-schema";

9101+ version = "0.7.3.0";

9102+ sha256 = "0jdhmzg1is8dnyz46r6w616xq0w1lypc9xz1c2mcimr9xb9r70zw";

9103+ revision = "1";

9104+ editedCabalFile = "0lpsmp2wkdijhgqr4ykj0fzzgadgxgdw4ly3rzlqd6311rdljaky";

9105+ configureFlags = [

9106+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9107+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9108+ "-fsplitbase" "-f-test-hlint"

9109+ ];

9110+ libraryHaskellDepends = [

9111+ aeson base containers generic-aeson generic-deriving mtl scientific

9112+ tagged text time unordered-containers vector

9113+ ];

9114+ testHaskellDepends = [

9115+ aeson aeson-utils attoparsec base bytestring generic-aeson tagged

9116+ tasty tasty-hunit tasty-th text vector

9117+ ];

9118+ doHaddock = false;

9119+ doCheck = false;

9120+ description = "Types and type classes for defining JSON schemas";

9121+ license = stdenv.lib.licenses.bsd3;

9122+ }) {};

9123+ "kan-extensions" = callPackage

9124+ ({ mkDerivation, adjunctions, array, base, comonad, containers

9125+ , contravariant, distributive, free, mtl, pointed, semigroupoids

9126+ , tagged, transformers

9127+ }:

9128+ mkDerivation {

9129+ pname = "kan-extensions";

9130+ version = "4.1.1";

9131+ sha256 = "0g7z37c2jvhvq08ynnd5z2spp7w56vqhpg5biscj62rw7fzssnar";

9132+ revision = "1";

9133+ editedCabalFile = "0gm8m0sxr86cf8g877b30l0cpckim7sqls9ripny44b7fz8hz0fr";

9134+ configureFlags = [

9135+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9136+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9137+ "-fsplitbase" "-f-test-hlint"

9138+ ];

9139+ libraryHaskellDepends = [

9140+ adjunctions array base comonad containers contravariant

9141+ distributive free mtl pointed semigroupoids tagged transformers

9142+ ];

9143+ homepage = "http://github.com/ekmett/kan-extensions/";

9144+ description = "Kan extensions, Kan lifts, various forms of the Yoneda lemma, and (co)density (co)monads";

9145+ license = stdenv.lib.licenses.bsd3;

9146+ }) {};

9147+ "kdt" = callPackage

9148+ ({ mkDerivation, base, criterion, deepseq, deepseq-generics

9149+ , mersenne-random-pure64, MonadRandom, pqueue, QuickCheck

9150+ }:

9151+ mkDerivation {

9152+ pname = "kdt";

9153+ version = "0.2.2";

9154+ sha256 = "1kj914xya5msw9hb2lqa36jf68pna8dfq21jbylq2m68k0ydcivi";

9155+ configureFlags = [

9156+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9157+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9158+ "-fsplitbase" "-f-test-hlint"

9159+ ];

9160+ libraryHaskellDepends = [ base deepseq deepseq-generics pqueue ];

9161+ testHaskellDepends = [ base deepseq deepseq-generics QuickCheck ];

9162+ benchmarkHaskellDepends = [

9163+ base criterion deepseq deepseq-generics mersenne-random-pure64

9164+ MonadRandom pqueue QuickCheck

9165+ ];

9166+ homepage = "https://github.com/giogadi/kdt";

9167+ description = "Fast and flexible k-d trees for various types of point queries";

9168+ license = stdenv.lib.licenses.mit;

9169+ }) {};

9170+ "keter" = callPackage

9171+ ({ mkDerivation, aeson, array, async, attoparsec, base

9172+ , blaze-builder, bytestring, case-insensitive, conduit

9173+ , conduit-extra, containers, data-default, directory, filepath

9174+ , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy

9175+ , http-types, lifted-base, mtl, network, network-conduit-tls

9176+ , process, random, regex-tdfa, stm, system-fileio, system-filepath

9177+ , tar, template-haskell, text, time, transformers, unix

9178+ , unix-compat, unordered-containers, vector, wai, wai-app-static

9179+ , wai-extra, warp, warp-tls, yaml, zlib

9180+ }:

9181+ mkDerivation {

9182+ pname = "keter";

9183+ version = "1.3.6";

9184+ sha256 = "00g34gazj3kk39nk34vzw88dy04rr3swb0hcl6k6gafwqrpv3i79";

9185+ revision = "3";

9186+ editedCabalFile = "08wrl9ihmn12fjy9b0aqk7ihp40dpvg4r1q9rch941yfsfj6js0h";

9187+ configureFlags = [

9188+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9189+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9190+ "-fsplitbase" "-f-test-hlint"

9191+ ];

9192+ isLibrary = true;

9193+ isExecutable = true;

9194+ libraryHaskellDepends = [

9195+ aeson array async attoparsec base blaze-builder bytestring

9196+ case-insensitive conduit conduit-extra containers data-default

9197+ directory filepath fsnotify http-client http-conduit

9198+ http-reverse-proxy http-types lifted-base mtl network

9199+ network-conduit-tls process random regex-tdfa stm system-fileio

9200+ system-filepath tar template-haskell text time transformers unix

9201+ unix-compat unordered-containers vector wai wai-app-static

9202+ wai-extra warp warp-tls yaml zlib

9203+ ];

9204+ executableHaskellDepends = [

9205+ base bytestring data-default directory http-types system-filepath

9206+ transformers wai wai-extra warp

9207+ ];

9208+ testHaskellDepends = [

9209+ base bytestring conduit hspec transformers unix

9210+ ];

9211+ homepage = "http://www.yesodweb.com/";

9212+ description = "Web application deployment manager, focusing on Haskell web frameworks";

9213+ license = stdenv.lib.licenses.mit;

9214+ }) {};

9215+ "keys" = callPackage

9216+ ({ mkDerivation, array, base, comonad, containers, free

9217+ , semigroupoids, semigroups, transformers

9218+ }:

9219+ mkDerivation {

9220+ pname = "keys";

9221+ version = "3.10.1";

9222+ sha256 = "007lbpfan5n1cgswsrzc4xjv0kjmjr9vn4lpqm3gwk3lnfpg8i4n";

9223+ configureFlags = [

9224+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9225+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9226+ "-fsplitbase" "-f-test-hlint"

9227+ ];

9228+ libraryHaskellDepends = [

9229+ array base comonad containers free semigroupoids semigroups

9230+ transformers

9231+ ];

9232+ homepage = "http://github.com/ekmett/keys/";

9233+ description = "Keyed functors and containers";

9234+ license = stdenv.lib.licenses.bsd3;

9235+ }) {};

9236+ "kure" = callPackage

9237+ ({ mkDerivation, base }:

9238+ mkDerivation {

9239+ pname = "kure";

9240+ version = "2.4.10";

9241+ sha256 = "1pr3yv115asrrap46glzw16651abr4bx1aknlma6cbaihpgy8r9h";

9242+ configureFlags = [

9243+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9244+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9245+ "-fsplitbase" "-f-test-hlint"

9246+ ];

9247+ libraryHaskellDepends = [ base ];

9248+ homepage = "http://www.ittc.ku.edu/csdl/fpg/Tools/KURE";

9249+ description = "Combinators for Strategic Programming";

9250+ license = stdenv.lib.licenses.bsd3;

9251+ }) {};

9252+ "language-c" = callPackage

9253+ ({ mkDerivation, alex, array, base, bytestring, containers

9254+ , directory, filepath, happy, pretty, process, syb

9255+ }:

9256+ mkDerivation {

9257+ pname = "language-c";

9258+ version = "0.4.7";

9259+ sha256 = "1r0jlncv6d6ai8kblrdq9gz8abx57b24y6hfh30xx20zdgccjvaz";

9260+ configureFlags = [

9261+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9262+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9263+ "-fsplitbase" "-f-test-hlint"

9264+ ];

9265+ libraryHaskellDepends = [

9266+ array base bytestring containers directory filepath pretty process

9267+ syb

9268+ ];

9269+ libraryToolDepends = [ alex happy ];

9270+ homepage = "http://www.sivity.net/projects/language.c/";

9271+ description = "Analysis and generation of C code";

9272+ license = stdenv.lib.licenses.bsd3;

9273+ }) {};

9274+ "language-ecmascript" = callPackage

9275+ ({ mkDerivation, base, containers, data-default-class, Diff

9276+ , directory, filepath, HUnit, mtl, parsec, QuickCheck

9277+ , template-haskell, test-framework, test-framework-hunit

9278+ , test-framework-quickcheck2, testing-feat, uniplate, wl-pprint

9279+ }:

9280+ mkDerivation {

9281+ pname = "language-ecmascript";

9282+ version = "0.16.2";

9283+ sha256 = "15jvq3wblx67hhvgblqzfdnks6x17hfnivifps5wfs9v1ljkiq1k";

9284+ revision = "1";

9285+ editedCabalFile = "171x5g1dy3fx4zj9kqxm1cdb3mi6awwwbvlbxn8mhlmd96h143a5";

9286+ configureFlags = [

9287+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9288+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9289+ "-fsplitbase" "-f-test-hlint"

9290+ ];

9291+ libraryHaskellDepends = [

9292+ base containers data-default-class Diff mtl parsec QuickCheck

9293+ template-haskell testing-feat uniplate wl-pprint

9294+ ];

9295+ testHaskellDepends = [

9296+ base containers data-default-class Diff directory filepath HUnit

9297+ mtl parsec QuickCheck test-framework test-framework-hunit

9298+ test-framework-quickcheck2 uniplate wl-pprint

9299+ ];

9300+ doHaddock = false;

9301+ doCheck = false;

9302+ homepage = "http://github.com/jswebtools/language-ecmascript";

9303+ description = "JavaScript parser and pretty-printer library";

9304+ license = stdenv.lib.licenses.bsd3;

9305+ }) {};

9306+ "language-glsl" = callPackage

9307+ ({ mkDerivation, base, HUnit, parsec, pretty, prettyclass

9308+ , test-framework, test-framework-hunit

9309+ }:

9310+ mkDerivation {

9311+ pname = "language-glsl";

9312+ version = "0.1.1";

9313+ sha256 = "06dc339a2cddzgjda3nzprgr0v2clbhlpl8j81m04i66bbj2l15y";

9314+ configureFlags = [

9315+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9316+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9317+ "-fsplitbase" "-f-test-hlint"

9318+ ];

9319+ isLibrary = true;

9320+ isExecutable = true;

9321+ libraryHaskellDepends = [ base parsec prettyclass ];

9322+ executableHaskellDepends = [ base parsec pretty prettyclass ];

9323+ testHaskellDepends = [

9324+ base HUnit parsec prettyclass test-framework test-framework-hunit

9325+ ];

9326+ description = "GLSL abstract syntax tree, parser, and pretty-printer";

9327+ license = stdenv.lib.licenses.bsd3;

9328+ }) {};

9329+ "language-haskell-extract" = callPackage

9330+ ({ mkDerivation, base, regex-posix, template-haskell }:

9331+ mkDerivation {

9332+ pname = "language-haskell-extract";

9333+ version = "0.2.4";

9334+ sha256 = "1nxcs7g8a1sp91bzpy4cj6s31k5pvc3gvig04cbrggv5cvjidnhl";

9335+ configureFlags = [

9336+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9337+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9338+ "-fsplitbase" "-f-test-hlint"

9339+ ];

9340+ libraryHaskellDepends = [ base regex-posix template-haskell ];

9341+ homepage = "http://github.com/finnsson/template-helper";

9342+ description = "Module to automatically extract functions from the local code";

9343+ license = stdenv.lib.licenses.bsd3;

9344+ }) {};

9345+ "language-java" = callPackage

9346+ ({ mkDerivation, alex, array, base, cpphs, directory, filepath

9347+ , HUnit, mtl, parsec, pretty, QuickCheck, test-framework

9348+ , test-framework-hunit, test-framework-quickcheck2

9349+ }:

9350+ mkDerivation {

9351+ pname = "language-java";

9352+ version = "0.2.7";

9353+ sha256 = "1519grsjw0f4skldxs563qz07mmj1cg72ma0plmvzpas7inkikyf";

9354+ configureFlags = [

9355+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9356+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9357+ "-fsplitbase" "-f-test-hlint"

9358+ ];

9359+ libraryHaskellDepends = [ array base cpphs parsec pretty ];

9360+ libraryToolDepends = [ alex ];

9361+ testHaskellDepends = [

9362+ base directory filepath HUnit mtl QuickCheck test-framework

9363+ test-framework-hunit test-framework-quickcheck2

9364+ ];

9365+ doHaddock = false;

9366+ doCheck = false;

9367+ homepage = "http://github.com/vincenthz/language-java";

9368+ description = "Manipulating Java source: abstract syntax, lexer, parser, and pretty-printer";

9369+ license = stdenv.lib.licenses.bsd3;

9370+ }) {};

9371+ "language-javascript" = callPackage

9372+ ({ mkDerivation, alex, array, base, blaze-builder, bytestring

9373+ , Cabal, containers, happy, HUnit, mtl, QuickCheck, test-framework

9374+ , test-framework-hunit, utf8-light, utf8-string

9375+ }:

9376+ mkDerivation {

9377+ pname = "language-javascript";

9378+ version = "0.5.13";

9379+ sha256 = "0h46wfh5xi3gbiaplx3ikmj7mfcwm1d37i5c9n3qfsmmkac29n2w";

9380+ configureFlags = [

9381+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9382+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9383+ "-fsplitbase" "-f-test-hlint"

9384+ ];

9385+ libraryHaskellDepends = [

9386+ array base blaze-builder bytestring containers mtl utf8-string

9387+ ];

9388+ libraryToolDepends = [ alex happy ];

9389+ testHaskellDepends = [

9390+ array base blaze-builder bytestring Cabal containers HUnit mtl

9391+ QuickCheck test-framework test-framework-hunit utf8-light

9392+ utf8-string

9393+ ];

9394+ homepage = "http://github.com/alanz/language-javascript";

9395+ description = "Parser for JavaScript";

9396+ license = stdenv.lib.licenses.bsd3;

9397+ }) {};

9398+ "lazy-csv" = callPackage

9399+ ({ mkDerivation, base, bytestring }:

9400+ mkDerivation {

9401+ pname = "lazy-csv";

9402+ version = "0.5";

9403+ sha256 = "0xm5j3why2wfajcn7r8my63ranq2mm7jlj15dj153n2izgvd1dh0";

9404+ configureFlags = [

9405+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9406+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9407+ "-fsplitbase" "-f-test-hlint"

9408+ ];

9409+ isLibrary = true;

9410+ isExecutable = true;

9411+ libraryHaskellDepends = [ base bytestring ];

9412+ executableHaskellDepends = [ base bytestring ];

9413+ homepage = "http://code.haskell.org/lazy-csv";

9414+ description = "Efficient lazy parsers for CSV (comma-separated values)";

9415+ license = stdenv.lib.licenses.bsd3;

9416+ }) {};

9417+ "lca" = callPackage

9418+ ({ mkDerivation, base, doctest }:

9419+ mkDerivation {

9420+ pname = "lca";

9421+ version = "0.2.4";

9422+ sha256 = "0dj7qz5wnrgqipmxim8y8jwgkwn8skkqxbd2w2kiy9s380pfdbsi";

9423+ revision = "1";

9424+ editedCabalFile = "08mjkpjrnccvzdpp4g0p0li33lnkk15g0b7lh83v56sz36ckmz59";

9425+ configureFlags = [

9426+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9427+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9428+ "-fsplitbase" "-f-test-hlint"

9429+ ];

9430+ libraryHaskellDepends = [ base ];

9431+ testHaskellDepends = [ base doctest ];

9432+ homepage = "http://github.com/ekmett/lca/";

9433+ description = "O(log n) persistent on-line lowest common ancestor calculation without preprocessing";

9434+ license = stdenv.lib.licenses.bsd3;

9435+ }) {};

9436+ "lens" = callPackage

9437+ ({ mkDerivation, array, base, bifunctors, bytestring, comonad

9438+ , comonads-fd, containers, contravariant, criterion, deepseq

9439+ , directory, distributive, doctest, exceptions, filepath, free

9440+ , generic-deriving, ghc-prim, hashable, HUnit, mtl, nats, parallel

9441+ , primitive, profunctors, QuickCheck, reflection, semigroupoids

9442+ , semigroups, simple-reflect, split, tagged, template-haskell

9443+ , test-framework, test-framework-hunit, test-framework-quickcheck2

9444+ , test-framework-th, text, transformers, transformers-compat

9445+ , unordered-containers, vector, void

9446+ }:

9447+ mkDerivation {

9448+ pname = "lens";

9449+ version = "4.6.0.1";

9450+ sha256 = "099hhkca39zxfj9xavd2rafzgm2r4nm8clngcsgcrn1qsy8knvz2";

9451+ revision = "3";

9452+ editedCabalFile = "0jnyqfm4fy5iqwwharaxigzd6rffwnmxqgizlpyijkkd57lilf8z";

9453+ configureFlags = [

9454+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9455+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9456+ "-fsplitbase" "-f-test-hlint"

9457+ ];

9458+ libraryHaskellDepends = [

9459+ array base bifunctors bytestring comonad containers contravariant

9460+ distributive exceptions filepath free ghc-prim hashable mtl

9461+ parallel primitive profunctors reflection semigroupoids semigroups

9462+ split tagged template-haskell text transformers transformers-compat

9463+ unordered-containers vector void

9464+ ];

9465+ testHaskellDepends = [

9466+ base bytestring containers deepseq directory doctest filepath

9467+ generic-deriving HUnit mtl nats parallel QuickCheck semigroups

9468+ simple-reflect split test-framework test-framework-hunit

9469+ test-framework-quickcheck2 test-framework-th text transformers

9470+ unordered-containers vector

9471+ ];

9472+ benchmarkHaskellDepends = [

9473+ base comonad comonads-fd criterion deepseq generic-deriving

9474+ transformers

9475+ ];

9476+ doHaddock = false;

9477+ doCheck = false;

9478+ homepage = "http://github.com/ekmett/lens/";

9479+ description = "Lenses, Folds and Traversals";

9480+ license = stdenv.lib.licenses.bsd3;

9481+ }) {};

9482+ "lens-aeson" = callPackage

9483+ ({ mkDerivation, aeson, attoparsec, base, bytestring, directory

9484+ , doctest, filepath, generic-deriving, lens, scientific, semigroups

9485+ , simple-reflect, text, unordered-containers, vector

9486+ }:

9487+ mkDerivation {

9488+ pname = "lens-aeson";

9489+ version = "1.0.0.3";

9490+ sha256 = "0wfbnazarwcza5dn3icsdvsmkyf9ki5lr5d5yidmgijhs63ak7ac";

9491+ configureFlags = [

9492+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9493+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9494+ "-fsplitbase" "-f-test-hlint"

9495+ ];

9496+ libraryHaskellDepends = [

9497+ aeson attoparsec base bytestring lens scientific text

9498+ unordered-containers vector

9499+ ];

9500+ testHaskellDepends = [

9501+ base directory doctest filepath generic-deriving semigroups

9502+ simple-reflect

9503+ ];

9504+ homepage = "http://github.com/lens/lens-aeson/";

9505+ description = "Law-abiding lenses for aeson";

9506+ license = stdenv.lib.licenses.bsd3;

9507+ }) {};

9508+ "lens-family-th" = callPackage

9509+ ({ mkDerivation, base, template-haskell }:

9510+ mkDerivation {

9511+ pname = "lens-family-th";

9512+ version = "0.4.0.0";

9513+ sha256 = "02fc3kppb7y2c6j22wi2mzcxffj4k3dl3x09vjllqchfpfcpwbm5";

9514+ revision = "1";

9515+ editedCabalFile = "1pbqxw0xz8sqk3kwww4k7jh2vrmn97j0ig2q8jafy1gp7dlnw8xj";

9516+ configureFlags = [

9517+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9518+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9519+ "-fsplitbase" "-f-test-hlint"

9520+ ];

9521+ libraryHaskellDepends = [ base template-haskell ];

9522+ homepage = "http://github.com/DanBurton/lens-family-th#readme";

9523+ description = "Generate lens-family style lenses";

9524+ license = stdenv.lib.licenses.bsd3;

9525+ }) {};

9526+ "lhs2tex" = callPackage

9527+ ({ mkDerivation, base, directory, filepath, mtl, process

9528+ , regex-compat

9529+ }:

9530+ mkDerivation {

9531+ pname = "lhs2tex";

9532+ version = "1.18.1";

9533+ sha256 = "0j4n7vkabsggn94gbwixy1vmckdck2nggdiqvk6n9nx164if5jnw";

9534+ configureFlags = [

9535+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9536+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9537+ "-fsplitbase" "-f-test-hlint"

9538+ ];

9539+ isLibrary = false;

9540+ isExecutable = true;

9541+ executableHaskellDepends = [

9542+ base directory filepath mtl process regex-compat

9543+ ];

9544+ doHaddock = false;

9545+ homepage = "http://www.andres-loeh.de/lhs2tex/";

9546+ description = "Preprocessor for typesetting Haskell sources with LaTeX";

9547+ license = "GPL";

9548+ }) {};

9549+ "libgit" = callPackage

9550+ ({ mkDerivation, base, mtl, process }:

9551+ mkDerivation {

9552+ pname = "libgit";

9553+ version = "0.3.0";

9554+ sha256 = "0k2287d84s0p73md1mfcyg1qy1l5ncgrvmkaa7607d8zlk9b8ci6";

9555+ configureFlags = [

9556+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9557+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9558+ "-fsplitbase" "-f-test-hlint"

9559+ ];

9560+ enableSeparateDataOutput = true;

9561+ libraryHaskellDepends = [ base mtl process ];

9562+ homepage = "http://github.com/vincenthz/hs-tls";

9563+ description = "Simple Git Wrapper";

9564+ license = stdenv.lib.licenses.bsd3;

9565+ }) {};

9566+ "libnotify" = callPackage

9567+ ({ mkDerivation, base, bytestring, glib, gtk, libnotify }:

9568+ mkDerivation {

9569+ pname = "libnotify";

9570+ version = "0.1.1.0";

9571+ sha256 = "1wc19v14agadj7dzi81lm3qzk2x33apaj5ylmg7x232k56xzfvr0";

9572+ configureFlags = [

9573+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9574+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9575+ "-fsplitbase" "-f-test-hlint"

9576+ ];

9577+ libraryHaskellDepends = [ base bytestring glib gtk ];

9578+ librarySystemDepends = [ libnotify ];

9579+ description = "Bindings to libnotify library";

9580+ license = stdenv.lib.licenses.mit;

9581+ }) {inherit (pkgs) libnotify;};

9582+ "lifted-async" = callPackage

9583+ ({ mkDerivation, async, base, criterion, deepseq, HUnit

9584+ , lifted-base, monad-control, mtl, tasty, tasty-hunit, tasty-th

9585+ , transformers-base

9586+ }:

9587+ mkDerivation {

9588+ pname = "lifted-async";

9589+ version = "0.2.0.2";

9590+ sha256 = "07sqgd3lxplfwrpys4jhz0068sx99765lpx8n4nj3k117z32slgf";

9591+ revision = "1";

9592+ editedCabalFile = "1rlk35fgk5403kizfqf4jy7vmv08kx2xwjayma1y4v0q4zygf6d5";

9593+ configureFlags = [

9594+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9595+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9596+ "-fsplitbase" "-f-test-hlint"

9597+ ];

9598+ libraryHaskellDepends = [

9599+ async base lifted-base monad-control transformers-base

9600+ ];

9601+ testHaskellDepends = [

9602+ async base HUnit lifted-base monad-control mtl tasty tasty-hunit

9603+ tasty-th

9604+ ];

9605+ benchmarkHaskellDepends = [ async base criterion deepseq ];

9606+ homepage = "https://github.com/maoe/lifted-async";

9607+ description = "Run lifted IO operations asynchronously and wait for their results";

9608+ license = stdenv.lib.licenses.bsd3;

9609+ }) {};

9610+ "lifted-base" = callPackage

9611+ ({ mkDerivation, base, base-unicode-symbols, HUnit, monad-control

9612+ , test-framework, test-framework-hunit, transformers

9613+ , transformers-base

9614+ }:

9615+ mkDerivation {

9616+ pname = "lifted-base";

9617+ version = "0.2.2.1";

9618+ sha256 = "13w1y67wng5rv90fsikkwpvx2ajmq5ybnxrx9b2x0y0zbcy7pzk8";

9619+ configureFlags = [

9620+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9621+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9622+ "-fsplitbase" "-f-test-hlint"

9623+ ];

9624+ libraryHaskellDepends = [

9625+ base base-unicode-symbols monad-control transformers-base

9626+ ];

9627+ testHaskellDepends = [

9628+ base HUnit monad-control test-framework test-framework-hunit

9629+ transformers transformers-base

9630+ ];

9631+ homepage = "https://github.com/basvandijk/lifted-base";

9632+ description = "lifted IO operations from the base library";

9633+ license = stdenv.lib.licenses.bsd3;

9634+ }) {};

9635+ "linear" = callPackage

9636+ ({ mkDerivation, adjunctions, base, binary, bytestring, containers

9637+ , directory, distributive, doctest, filepath, ghc-prim, hashable

9638+ , HUnit, lens, reflection, semigroupoids, semigroups

9639+ , simple-reflect, tagged, template-haskell, test-framework

9640+ , test-framework-hunit, transformers, unordered-containers, vector

9641+ , void

9642+ }:

9643+ mkDerivation {

9644+ pname = "linear";

9645+ version = "1.15.5";

9646+ sha256 = "17fxz49zj6vklgfs583zpn7naqgp5mv2zsvmxrv80ym8r52mp5mi";

9647+ revision = "1";

9648+ editedCabalFile = "0s6zj8gi6vrxk0a239s6nc5lnmfrcjx2idccl436xd6c6a8fd6c2";

9649+ configureFlags = [

9650+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9651+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9652+ "-fsplitbase" "-f-test-hlint"

9653+ ];

9654+ libraryHaskellDepends = [

9655+ adjunctions base binary containers distributive ghc-prim hashable

9656+ lens reflection semigroupoids semigroups tagged template-haskell

9657+ transformers unordered-containers vector void

9658+ ];

9659+ testHaskellDepends = [

9660+ base binary bytestring directory doctest filepath HUnit lens

9661+ simple-reflect test-framework test-framework-hunit

9662+ ];

9663+ homepage = "http://github.com/ekmett/linear/";

9664+ description = "Linear Algebra";

9665+ license = stdenv.lib.licenses.bsd3;

9666+ }) {};

9667+ "linear-accelerate" = callPackage

9668+ ({ mkDerivation, accelerate, base, lens, linear }:

9669+ mkDerivation {

9670+ pname = "linear-accelerate";

9671+ version = "0.2";

9672+ sha256 = "0433mzw2cswk86nmj3gnygn3d07yq0sbmv2ylxbw8ri35yddjap6";

9673+ configureFlags = [

9674+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9675+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9676+ "-fsplitbase" "-f-test-hlint"

9677+ ];

9678+ libraryHaskellDepends = [ accelerate base lens linear ];

9679+ homepage = "http://github.com/ekmett/linear-accelerate/";

9680+ description = "Instances to use linear vector spaces on accelerate backends";

9681+ license = stdenv.lib.licenses.bsd3;

9682+ }) {};

9683+ "list-t" = callPackage

9684+ ({ mkDerivation, base-prelude, HTF, mmorph, monad-control

9685+ , mtl-prelude, transformers, transformers-base

9686+ }:

9687+ mkDerivation {

9688+ pname = "list-t";

9689+ version = "0.3.0";

9690+ sha256 = "091gz47gisajd2p0iwx0mw99bivfl7wpyddg1ypsvjv2qax94cm9";

9691+ configureFlags = [

9692+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9693+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9694+ "-fsplitbase" "-f-test-hlint"

9695+ ];

9696+ libraryHaskellDepends = [

9697+ base-prelude mmorph monad-control transformers transformers-base

9698+ ];

9699+ testHaskellDepends = [ base-prelude HTF mtl-prelude ];

9700+ doHaddock = false;

9701+ doCheck = false;

9702+ homepage = "https://github.com/nikita-volkov/list-t";

9703+ description = "ListT done right";

9704+ license = stdenv.lib.licenses.mit;

9705+ }) {};

9706+ "loch-th" = callPackage

9707+ ({ mkDerivation, base, pretty, template-haskell }:

9708+ mkDerivation {

9709+ pname = "loch-th";

9710+ version = "0.2.1";

9711+ sha256 = "1kfrjsgzq6wl749n2wm1fhwwigjxcd9lww7whiwjrbmhiz5ism3p";

9712+ configureFlags = [

9713+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9714+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9715+ "-fsplitbase" "-f-test-hlint"

9716+ ];

9717+ libraryHaskellDepends = [ base pretty template-haskell ];

9718+ homepage = "https://github.com/liskin/loch-th";

9719+ description = "Support for precise error locations in source files (Template Haskell version)";

9720+ license = stdenv.lib.licenses.bsd3;

9721+ }) {};

9722+ "log-domain" = callPackage

9723+ ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq

9724+ , directory, distributive, doctest, filepath, generic-deriving

9725+ , hashable, hashable-extras, safecopy, semigroupoids, semigroups

9726+ , simple-reflect, vector

9727+ }:

9728+ mkDerivation {

9729+ pname = "log-domain";

9730+ version = "0.9.3";

9731+ sha256 = "1l07pi7lnwyk3y747f7bgr1200p6apyfn7bch5v30kh7dy0wyi8m";

9732+ configureFlags = [

9733+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9734+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9735+ "-fsplitbase" "-f-test-hlint"

9736+ ];

9737+ libraryHaskellDepends = [

9738+ base binary bytes cereal comonad deepseq distributive

9739+ generic-deriving hashable hashable-extras safecopy semigroupoids

9740+ semigroups vector

9741+ ];

9742+ testHaskellDepends = [

9743+ base directory doctest filepath generic-deriving semigroups

9744+ simple-reflect

9745+ ];

9746+ homepage = "http://github.com/analytics/log-domain/";

9747+ description = "Log-domain arithmetic";

9748+ license = stdenv.lib.licenses.bsd3;

9749+ }) {};

9750+ "logfloat" = callPackage

9751+ ({ mkDerivation, array, base }:

9752+ mkDerivation {

9753+ pname = "logfloat";

9754+ version = "0.12.1";

9755+ sha256 = "1k13jjqv4df341hcj9hzrlisfx9wrsmyqvzi6ricx341d9z4ch05";

9756+ revision = "1";

9757+ editedCabalFile = "06d4dlwvmr7akcf4cxg1xhq41zgacbalflvbhq7aj0v3pw2rs7as";

9758+ configureFlags = [

9759+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9760+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9761+ "-fsplitbase" "-f-test-hlint"

9762+ ];

9763+ libraryHaskellDepends = [ array base ];

9764+ homepage = "http://code.haskell.org/~wren/";

9765+ description = "Log-domain floating point numbers";

9766+ license = stdenv.lib.licenses.bsd3;

9767+ }) {};

9768+ "logict" = callPackage

9769+ ({ mkDerivation, base, mtl }:

9770+ mkDerivation {

9771+ pname = "logict";

9772+ version = "0.6.0.2";

9773+ sha256 = "07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi";

9774+ configureFlags = [

9775+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9776+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9777+ "-fsplitbase" "-f-test-hlint"

9778+ ];

9779+ libraryHaskellDepends = [ base mtl ];

9780+ homepage = "http://code.haskell.org/~dolio/";

9781+ description = "A backtracking logic-programming monad";

9782+ license = stdenv.lib.licenses.bsd3;

9783+ }) {};

9784+ "loop" = callPackage

9785+ ({ mkDerivation, base, criterion, hspec, mtl, random, vector }:

9786+ mkDerivation {

9787+ pname = "loop";

9788+ version = "0.2.0";

9789+ sha256 = "11ifqahlg9ky5klid1fhsyfvfb6w8yb0dsy43s0cxcmldbw3qv5x";

9790+ configureFlags = [

9791+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9792+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9793+ "-fsplitbase" "-f-test-hlint"

9794+ ];

9795+ libraryHaskellDepends = [ base ];

9796+ testHaskellDepends = [ base hspec mtl ];

9797+ benchmarkHaskellDepends = [ base criterion mtl random vector ];

9798+ homepage = "https://github.com/nh2/loop";

9799+ description = "Fast loops (for when GHC can't optimize forM_)";

9800+ license = stdenv.lib.licenses.mit;

9801+ }) {};

9802+ "lucid" = callPackage

9803+ ({ mkDerivation, base, bifunctors, blaze-builder, bytestring

9804+ , containers, criterion, deepseq, hspec, HUnit, mtl, parsec, text

9805+ , transformers, unordered-containers

9806+ }:

9807+ mkDerivation {

9808+ pname = "lucid";

9809+ version = "2.5";

9810+ sha256 = "0q6jkz4czjr4bdwjdv5yvkiq1dhkjcn3zc1y4xj5yrlbn93708zj";

9811+ revision = "1";

9812+ editedCabalFile = "061cxf8vz2gxsw604kjnzy8wh79605hfqlb2gy34nb3zqdni8ag0";

9813+ configureFlags = [

9814+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9815+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9816+ "-fsplitbase" "-f-test-hlint"

9817+ ];

9818+ libraryHaskellDepends = [

9819+ base blaze-builder bytestring containers mtl text transformers

9820+ unordered-containers

9821+ ];

9822+ testHaskellDepends = [

9823+ base bifunctors hspec HUnit mtl parsec text

9824+ ];

9825+ benchmarkHaskellDepends = [

9826+ base blaze-builder bytestring criterion deepseq text

9827+ ];

9828+ homepage = "https://github.com/chrisdone/lucid";

9829+ description = "Clear to write, read and edit DSL for HTML";

9830+ license = stdenv.lib.licenses.bsd3;

9831+ }) {};

9832+ "machines" = callPackage

9833+ ({ mkDerivation, base, comonad, containers, directory, doctest

9834+ , filepath, free, mtl, pointed, profunctors, semigroups

9835+ , transformers, void

9836+ }:

9837+ mkDerivation {

9838+ pname = "machines";

9839+ version = "0.4.1";

9840+ sha256 = "1wripnvpzfdnf7i2aygjyh33cp7srkb5638snwyn700bjbi2j7gb";

9841+ revision = "2";

9842+ editedCabalFile = "0afl8xydl9n29wysznrfwbx64y12243nnji6vzqvdarfwgv5h06i";

9843+ configureFlags = [

9844+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9845+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9846+ "-fsplitbase" "-f-test-hlint"

9847+ ];

9848+ libraryHaskellDepends = [

9849+ base comonad containers free mtl pointed profunctors semigroups

9850+ transformers void

9851+ ];

9852+ testHaskellDepends = [ base directory doctest filepath ];

9853+ homepage = "http://github.com/ekmett/machines/";

9854+ description = "Networked stream transducers";

9855+ license = stdenv.lib.licenses.bsd3;

9856+ }) {};

9857+ "map-syntax" = callPackage

9858+ ({ mkDerivation, base, containers, deepseq, HUnit, mtl, QuickCheck

9859+ , test-framework, test-framework-hunit, test-framework-quickcheck2

9860+ , transformers

9861+ }:

9862+ mkDerivation {

9863+ pname = "map-syntax";

9864+ version = "0.2";

9865+ sha256 = "02v1dvq86qzbfbwbza4myj3a6a6a5p059fi5m3g548hmqk3v2p1r";

9866+ configureFlags = [

9867+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9868+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9869+ "-fsplitbase" "-f-test-hlint"

9870+ ];

9871+ libraryHaskellDepends = [ base containers mtl ];

9872+ testHaskellDepends = [

9873+ base containers deepseq HUnit mtl QuickCheck test-framework

9874+ test-framework-hunit test-framework-quickcheck2 transformers

9875+ ];

9876+ description = "Syntax sugar for defining maps";

9877+ license = stdenv.lib.licenses.bsd3;

9878+ }) {};

9879+ "markdown" = callPackage

9880+ ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup

9881+ , conduit, conduit-extra, containers, data-default, hspec

9882+ , system-fileio, system-filepath, text, transformers, xss-sanitize

9883+ }:

9884+ mkDerivation {

9885+ pname = "markdown";

9886+ version = "0.1.13";

9887+ sha256 = "1r04h641d9y8p88h59isrz9g42gq7vdykx3n8bhk499ici800134";

9888+ configureFlags = [

9889+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9890+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9891+ "-fsplitbase" "-f-test-hlint"

9892+ ];

9893+ libraryHaskellDepends = [

9894+ attoparsec base blaze-html blaze-markup conduit conduit-extra

9895+ containers data-default text transformers xss-sanitize

9896+ ];

9897+ testHaskellDepends = [

9898+ base blaze-html conduit conduit-extra containers hspec

9899+ system-fileio system-filepath text transformers

9900+ ];

9901+ homepage = "https://github.com/snoyberg/markdown";

9902+ description = "Convert Markdown to HTML, with XSS protection";

9903+ license = stdenv.lib.licenses.bsd3;

9904+ }) {};

9905+ "markdown-unlit" = callPackage

9906+ ({ mkDerivation, base, directory, hspec, QuickCheck, silently

9907+ , stringbuilder

9908+ }:

9909+ mkDerivation {

9910+ pname = "markdown-unlit";

9911+ version = "0.2.0.1";

9912+ sha256 = "1bc3vcifv2xcddh8liq380c6sxarrs5pf21pfs9i4dx9rfl3hvhq";

9913+ configureFlags = [

9914+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9915+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9916+ "-fsplitbase" "-f-test-hlint"

9917+ ];

9918+ isLibrary = true;

9919+ isExecutable = true;

9920+ libraryHaskellDepends = [ base ];

9921+ executableHaskellDepends = [ base ];

9922+ testHaskellDepends = [

9923+ base directory hspec QuickCheck silently stringbuilder

9924+ ];

9925+ description = "Literate Haskell support for Markdown";

9926+ license = stdenv.lib.licenses.mit;

9927+ }) {};

9928+ "math-functions" = callPackage

9929+ ({ mkDerivation, base, deepseq, erf, HUnit, ieee754, QuickCheck

9930+ , test-framework, test-framework-hunit, test-framework-quickcheck2

9931+ , vector, vector-th-unbox

9932+ }:

9933+ mkDerivation {

9934+ pname = "math-functions";

9935+ version = "0.1.5.2";

9936+ sha256 = "12cznf7gwia1ki7xhvlhk5p8d09zrdvfgn07pkp4sfrwsc4vijcy";

9937+ revision = "1";

9938+ editedCabalFile = "1zb582xpxpybfvxnivkf7l4mr2sbds4673h89gb1slqxgq7haary";

9939+ configureFlags = [

9940+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9941+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9942+ "-fsplitbase" "-f-test-hlint"

9943+ ];

9944+ libraryHaskellDepends = [

9945+ base deepseq erf vector vector-th-unbox

9946+ ];

9947+ testHaskellDepends = [

9948+ base HUnit ieee754 QuickCheck test-framework test-framework-hunit

9949+ test-framework-quickcheck2 vector

9950+ ];

9951+ doHaddock = false;

9952+ doCheck = false;

9953+ homepage = "https://github.com/bos/math-functions";

9954+ description = "Special functions and Chebyshev polynomials";

9955+ license = stdenv.lib.licenses.bsd3;

9956+ }) {};

9957+ "matrix" = callPackage

9958+ ({ mkDerivation, base, criterion, deepseq, loop, primitive

9959+ , QuickCheck, tasty, tasty-quickcheck, vector

9960+ }:

9961+ mkDerivation {

9962+ pname = "matrix";

9963+ version = "0.3.4.0";

9964+ sha256 = "16a633llf7nh70s92cn8i8sdish9vryy4xh62rimvmn91ivvjay1";

9965+ revision = "1";

9966+ editedCabalFile = "08myk3z552dzd1n9f3vkzz2kygkm19ik74apdrqabak6lbp349cn";

9967+ configureFlags = [

9968+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9969+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9970+ "-fsplitbase" "-f-test-hlint"

9971+ ];

9972+ libraryHaskellDepends = [ base deepseq loop primitive vector ];

9973+ testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];

9974+ benchmarkHaskellDepends = [ base criterion ];

9975+ description = "A native implementation of matrix operations";

9976+ license = stdenv.lib.licenses.bsd3;

9977+ }) {};

9978+ "mersenne-random-pure64" = callPackage

9979+ ({ mkDerivation, base, old-time, random }:

9980+ mkDerivation {

9981+ pname = "mersenne-random-pure64";

9982+ version = "0.2.0.4";

9983+ sha256 = "0qh72ynfg1k4c70qxdzsa6f1x9wyxil2d9gi85c879wrc41k899h";

9984+ configureFlags = [

9985+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9986+ "-f-network-uri" "-fnew-base" "-fold-locale" "-f-small_base"

9987+ "-fsplitbase" "-f-test-hlint"

9988+ ];

9989+ libraryHaskellDepends = [ base old-time random ];

9990+ homepage = "http://code.haskell.org/~dons/code/mersenne-random-pure64/";

9991+ description = "Generate high quality pseudorandom numbers purely using a Mersenne Twister";

9992+ license = stdenv.lib.licenses.bsd3;

9993+ }) {};

9994+ "messagepack" = callPackage

9995+ ({ mkDerivation, attoparsec, base, bytestring, cereal, containers

9996+ , QuickCheck, test-framework, test-framework-quickcheck2

9997+ , test-framework-th, text

9998+ }:

9999+ mkDerivation {

10000+ pname = "messagepack";

10001+ version = "0.3.0";

10002+ sha256 = "1icl40fh9glzr105aha3971gnbnzw528sgdia8kwlj751v3nnpa0";

10003+ configureFlags = [

10004+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10005+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10006+ "-fsplitbase" "-f-test-hlint"

10007+ ];

10008+ libraryHaskellDepends = [

10009+ attoparsec base bytestring cereal containers text

10010+ ];

10011+ testHaskellDepends = [

10012+ base bytestring cereal containers QuickCheck test-framework

10013+ test-framework-quickcheck2 test-framework-th text

10014+ ];

10015+ homepage = "https://github.com/rodrigosetti/messagepack";

10016+ description = "Serialize instance for Message Pack Object";

10017+ license = stdenv.lib.licenses.mit;

10018+ }) {};

10019+ "messagepack-rpc" = callPackage

10020+ ({ mkDerivation, base, bytestring, cereal, containers, messagepack

10021+ , network-simple, text

10022+ }:

10023+ mkDerivation {

10024+ pname = "messagepack-rpc";

10025+ version = "0.1.0.3";

10026+ sha256 = "0g9lj3fb81gng3z4kdikwa9vgz73hjdqygzhcqd8fphcynv8j6m1";

10027+ configureFlags = [

10028+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10029+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10030+ "-fsplitbase" "-f-test-hlint"

10031+ ];

10032+ libraryHaskellDepends = [

10033+ base bytestring cereal containers messagepack network-simple text

10034+ ];

10035+ homepage = "http://github.com/rodrigosetti/messagepack-rpc";

10036+ description = "Message Pack RPC over TCP";

10037+ license = stdenv.lib.licenses.mit;

10038+ }) {};

10039+ "mime-mail" = callPackage

10040+ ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring

10041+ , filepath, hspec, process, random, text

10042+ }:

10043+ mkDerivation {

10044+ pname = "mime-mail";

10045+ version = "0.4.6";

10046+ sha256 = "051mqpzypg4r6rd06qb75pl3nq9p68r1sl73r0pwl1imcp158aw6";

10047+ configureFlags = [

10048+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10049+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10050+ "-fsplitbase" "-f-test-hlint"

10051+ ];

10052+ libraryHaskellDepends = [

10053+ base base64-bytestring blaze-builder bytestring filepath process

10054+ random text

10055+ ];

10056+ testHaskellDepends = [ base blaze-builder bytestring hspec text ];

10057+ homepage = "http://github.com/snoyberg/mime-mail";

10058+ description = "Compose MIME email messages";

10059+ license = stdenv.lib.licenses.bsd3;

10060+ }) {};

10061+ "mime-mail-ses" = callPackage

10062+ ({ mkDerivation, base, base64-bytestring, byteable, bytestring

10063+ , conduit, cryptohash, http-client, http-conduit, http-types

10064+ , mime-mail, old-locale, text, time, transformers, xml-conduit

10065+ , xml-types

10066+ }:

10067+ mkDerivation {

10068+ pname = "mime-mail-ses";

10069+ version = "0.3.2";

10070+ sha256 = "19jdmfwlak50sw75gba5a2c91rs8694b2y6wl8zxc3xx4bkq6ldz";

10071+ configureFlags = [

10072+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10073+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10074+ "-fsplitbase" "-f-test-hlint"

10075+ ];

10076+ libraryHaskellDepends = [

10077+ base base64-bytestring byteable bytestring conduit cryptohash

10078+ http-client http-conduit http-types mime-mail old-locale text time

10079+ transformers xml-conduit xml-types

10080+ ];

10081+ homepage = "http://github.com/snoyberg/mime-mail";

10082+ description = "Send mime-mail messages via Amazon SES";

10083+ license = stdenv.lib.licenses.mit;

10084+ }) {};

10085+ "mime-types" = callPackage

10086+ ({ mkDerivation, base, bytestring, containers, text }:

10087+ mkDerivation {

10088+ pname = "mime-types";

10089+ version = "0.1.0.4";

10090+ sha256 = "0bxhkwz8p7mhg5kspbpc5zm4k50pc0r5pzjr6807y88x8vjpvj2x";

10091+ configureFlags = [

10092+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10093+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10094+ "-fsplitbase" "-f-test-hlint"

10095+ ];

10096+ libraryHaskellDepends = [ base bytestring containers text ];

10097+ homepage = "https://github.com/yesodweb/wai";

10098+ description = "Basic mime-type handling types and functions";

10099+ license = stdenv.lib.licenses.mit;

10100+ }) {};

10101+ "missing-foreign" = callPackage

10102+ ({ mkDerivation, base }:

10103+ mkDerivation {

10104+ pname = "missing-foreign";

10105+ version = "0.1.1";

10106+ sha256 = "11f8pknbarlj956nmalqhd2v704z7d7xbi61hs1q8vb2p36kc6wy";

10107+ configureFlags = [

10108+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10109+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10110+ "-fsplitbase" "-f-test-hlint"

10111+ ];

10112+ libraryHaskellDepends = [ base ];

10113+ description = "Convenience functions for FFI work";

10114+ license = stdenv.lib.licenses.bsd3;

10115+ }) {};

10116+ "mmap" = callPackage

10117+ ({ mkDerivation, base, bytestring }:

10118+ mkDerivation {

10119+ pname = "mmap";

10120+ version = "0.5.9";

10121+ sha256 = "1y5mk3yf4b8r6rzmlx1xqn4skaigrqnv08sqq0v7r3nbw42bpz2q";

10122+ configureFlags = [

10123+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10124+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10125+ "-fsplitbase" "-f-test-hlint"

10126+ ];

10127+ isLibrary = true;

10128+ isExecutable = true;

10129+ libraryHaskellDepends = [ base bytestring ];

10130+ description = "Memory mapped files for POSIX and Windows";

10131+ license = stdenv.lib.licenses.bsd3;

10132+ }) {};

10133+ "mmorph" = callPackage

10134+ ({ mkDerivation, base, transformers }:

10135+ mkDerivation {

10136+ pname = "mmorph";

10137+ version = "1.0.4";

10138+ sha256 = "0k5zlzmnixfwcjrqvhgi3i6xg532b0gsjvc39v5jigw69idndqr2";

10139+ configureFlags = [

10140+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10141+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10142+ "-fsplitbase" "-f-test-hlint"

10143+ ];

10144+ libraryHaskellDepends = [ base transformers ];

10145+ description = "Monad morphisms";

10146+ license = stdenv.lib.licenses.bsd3;

10147+ }) {};

10148+ "monad-control" = callPackage

10149+ ({ mkDerivation, base, transformers, transformers-base }:

10150+ mkDerivation {

10151+ pname = "monad-control";

10152+ version = "0.3.3.0";

10153+ sha256 = "0vjff64iwnd9vplqfjyylbd900qmsr92h62hnh715wk06yacji7g";

10154+ configureFlags = [

10155+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10156+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10157+ "-fsplitbase" "-f-test-hlint"

10158+ ];

10159+ libraryHaskellDepends = [ base transformers transformers-base ];

10160+ doHaddock = false;

10161+ doCheck = false;

10162+ homepage = "https://github.com/basvandijk/monad-control";

10163+ description = "Lift control operations, like exception catching, through monad transformers";

10164+ license = stdenv.lib.licenses.bsd3;

10165+ }) {};

10166+ "monad-coroutine" = callPackage

10167+ ({ mkDerivation, base, monad-parallel, transformers }:

10168+ mkDerivation {

10169+ pname = "monad-coroutine";

10170+ version = "0.8";

10171+ sha256 = "0nirp5c3vi529ap142zs29j10j9m609ippi3chv6a87h51avkhzx";

10172+ configureFlags = [

10173+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10174+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10175+ "-fsplitbase" "-f-test-hlint"

10176+ ];

10177+ libraryHaskellDepends = [ base monad-parallel transformers ];

10178+ homepage = "http://trac.haskell.org/SCC/wiki/monad-coroutine";

10179+ description = "Coroutine monad transformer for suspending and resuming monadic computations";

10180+ license = "GPL";

10181+ }) {};

10182+ "monad-extras" = callPackage

10183+ ({ mkDerivation, base, mmorph, monad-control, stm, transformers

10184+ , transformers-base

10185+ }:

10186+ mkDerivation {

10187+ pname = "monad-extras";

10188+ version = "0.5.9";

10189+ sha256 = "1y24yz635brllfygia1mbln4d8xiwb0pq0izh5pil7511gijhs0s";

10190+ configureFlags = [

10191+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10192+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10193+ "-fsplitbase" "-f-test-hlint"

10194+ ];

10195+ libraryHaskellDepends = [

10196+ base mmorph monad-control stm transformers transformers-base

10197+ ];

10198+ homepage = "http://github.com/jwiegley/monad-extras";

10199+ description = "Extra utility functions for working with monads";

10200+ license = stdenv.lib.licenses.bsd3;

10201+ }) {};

10202+ "monad-journal" = callPackage

10203+ ({ mkDerivation, base, either, monad-control, mtl, transformers

10204+ , transformers-base

10205+ }:

10206+ mkDerivation {

10207+ pname = "monad-journal";

10208+ version = "0.5.0.1";

10209+ sha256 = "1rxmz6hx8kh8sw497h4kpxkvhgaa7jbzif7qssjqijyfmghsxh80";

10210+ configureFlags = [

10211+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10212+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10213+ "-fsplitbase" "-f-test-hlint"

10214+ ];

10215+ libraryHaskellDepends = [

10216+ base either monad-control mtl transformers transformers-base

10217+ ];

10218+ homepage = "http://github.com/phaazon/monad-journal";

10219+ description = "Pure logger typeclass and monad transformer";

10220+ license = stdenv.lib.licenses.bsd3;

10221+ }) {};

10222+ "monad-logger" = callPackage

10223+ ({ mkDerivation, base, blaze-builder, bytestring, conduit

10224+ , conduit-extra, exceptions, fast-logger, lifted-base

10225+ , monad-control, monad-loops, mtl, resourcet, stm, stm-chans

10226+ , template-haskell, text, transformers, transformers-base

10227+ }:

10228+ mkDerivation {

10229+ pname = "monad-logger";

10230+ version = "0.3.11";

10231+ sha256 = "0ydxv4pdq660dh3cdmsd5lgjkfhh7c62kb5vcl8jl6qmjf8kvmdq";

10232+ revision = "1";

10233+ editedCabalFile = "1f10rkspnbgiw8017v41c7q0i2l6ng1n8wzzy33zcky6ap3w4a7r";

10234+ configureFlags = [

10235+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10236+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10237+ "-fsplitbase" "-f-test-hlint"

10238+ ];

10239+ libraryHaskellDepends = [

10240+ base blaze-builder bytestring conduit conduit-extra exceptions

10241+ fast-logger lifted-base monad-control monad-loops mtl resourcet stm

10242+ stm-chans template-haskell text transformers transformers-base

10243+ ];

10244+ homepage = "https://github.com/kazu-yamamoto/logger";

10245+ description = "A class of monads which can log messages";

10246+ license = stdenv.lib.licenses.mit;

10247+ }) {};

10248+ "monad-loops" = callPackage

10249+ ({ mkDerivation, base }:

10250+ mkDerivation {

10251+ pname = "monad-loops";

10252+ version = "0.4.2.1";

10253+ sha256 = "1dprwndc0bxzpmrkj1xb9kzjrg3i06zsg43yaabn5x5gcaj8is56";

10254+ configureFlags = [

10255+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10256+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10257+ "-fsplitbase" "-f-test-hlint"

10258+ ];

10259+ libraryHaskellDepends = [ base ];

10260+ homepage = "https://github.com/mokus0/monad-loops";

10261+ description = "Monadic loops";

10262+ license = stdenv.lib.licenses.publicDomain;

10263+ }) {};

10264+ "monad-par" = callPackage

10265+ ({ mkDerivation, abstract-deque, abstract-par, array, base

10266+ , containers, deepseq, HUnit, monad-par-extras, mtl, mwc-random

10267+ , parallel, QuickCheck, test-framework, test-framework-hunit

10268+ , test-framework-quickcheck2, test-framework-th, time

10269+ }:

10270+ mkDerivation {

10271+ pname = "monad-par";

10272+ version = "0.3.4.7";

10273+ sha256 = "12n27hs274nrfkpa6hx0gdkrc76wxzliqf53x6689idl363sdf13";

10274+ configureFlags = [

10275+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10276+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10277+ "-fsplitbase" "-f-test-hlint"

10278+ ];

10279+ libraryHaskellDepends = [

10280+ abstract-deque abstract-par array base containers deepseq

10281+ monad-par-extras mtl mwc-random parallel

10282+ ];

10283+ testHaskellDepends = [

10284+ abstract-deque abstract-par array base containers deepseq HUnit

10285+ monad-par-extras mtl mwc-random QuickCheck test-framework

10286+ test-framework-hunit test-framework-quickcheck2 test-framework-th

10287+ time

10288+ ];

10289+ doHaddock = false;

10290+ doCheck = false;

10291+ homepage = "https://github.com/simonmar/monad-par";

10292+ description = "A library for parallel programming based on a monad";

10293+ license = stdenv.lib.licenses.bsd3;

10294+ }) {};

10295+ "monad-par-extras" = callPackage

10296+ ({ mkDerivation, abstract-par, base, cereal, deepseq, mtl, random

10297+ , transformers

10298+ }:

10299+ mkDerivation {

10300+ pname = "monad-par-extras";

10301+ version = "0.3.3";

10302+ sha256 = "0bl4bd6jzdc5zm20q1g67ppkfh6j6yn8fwj6msjayj621cck67p2";

10303+ configureFlags = [

10304+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10305+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10306+ "-fsplitbase" "-f-test-hlint"

10307+ ];

10308+ libraryHaskellDepends = [

10309+ abstract-par base cereal deepseq mtl random transformers

10310+ ];

10311+ homepage = "https://github.com/simonmar/monad-par";

10312+ description = "Combinators and extra features for Par monads";

10313+ license = stdenv.lib.licenses.bsd3;

10314+ }) {};

10315+ "monad-parallel" = callPackage

10316+ ({ mkDerivation, base, parallel, transformers, transformers-compat

10317+ }:

10318+ mkDerivation {

10319+ pname = "monad-parallel";

10320+ version = "0.7.1.3";

10321+ sha256 = "150ich9fzpmwdvvhsd7ri97nm8zsqn86gr3bh0aqb0wgrg4hbmkx";

10322+ configureFlags = [

10323+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10324+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10325+ "-fsplitbase" "-f-test-hlint"

10326+ ];

10327+ libraryHaskellDepends = [

10328+ base parallel transformers transformers-compat

10329+ ];

10330+ homepage = "http://trac.haskell.org/SCC/wiki/monad-parallel";

10331+ description = "Parallel execution of monadic computations";

10332+ license = stdenv.lib.licenses.bsd3;

10333+ }) {};

10334+ "monad-primitive" = callPackage

10335+ ({ mkDerivation, base, primitive, transformers }:

10336+ mkDerivation {

10337+ pname = "monad-primitive";

10338+ version = "0.1";

10339+ sha256 = "1vi6g65hdyq5vq78mfag0qljxgzb6vq83m82x3cpgjl7dr9k5h1x";

10340+ configureFlags = [

10341+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10342+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10343+ "-fsplitbase" "-f-test-hlint"

10344+ ];

10345+ libraryHaskellDepends = [ base primitive transformers ];

10346+ homepage = "http://bitbucket.org/Shimuuar/monad-primitive";

10347+ description = "Type class for monad transformers stack with pirimitive base monad";

10348+ license = stdenv.lib.licenses.bsd3;

10349+ }) {};

10350+ "monad-products" = callPackage

10351+ ({ mkDerivation, base, semigroupoids }:

10352+ mkDerivation {

10353+ pname = "monad-products";

10354+ version = "4.0.0.1";

10355+ sha256 = "017cxiavxfw0f08sr0d6m3avla1lplmdj51rxpf1103ripq20r53";

10356+ revision = "1";

10357+ editedCabalFile = "03kif3rrx24a5xj83jk1rqz6pypsfyvrjb1558ziy26k1aphfkgv";

10358+ configureFlags = [

10359+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10360+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10361+ "-fsplitbase" "-f-test-hlint"

10362+ ];

10363+ libraryHaskellDepends = [ base semigroupoids ];

10364+ homepage = "http://github.com/ekmett/monad-products";

10365+ description = "Monad products";

10366+ license = stdenv.lib.licenses.bsd3;

10367+ }) {};

10368+ "monad-st" = callPackage

10369+ ({ mkDerivation, base, transformers }:

10370+ mkDerivation {

10371+ pname = "monad-st";

10372+ version = "0.2.4";

10373+ sha256 = "1j67s07p5lsr81cjl0ch5d1q7zarmpak5kmnwckhavihg3l5m3bi";

10374+ configureFlags = [

10375+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10376+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10377+ "-fsplitbase" "-f-test-hlint"

10378+ ];

10379+ libraryHaskellDepends = [ base transformers ];

10380+ homepage = "http://github.com/ekmett/monad-st";

10381+ description = "Provides a MonadST class";

10382+ license = stdenv.lib.licenses.bsd3;

10383+ }) {};

10384+ "monadcryptorandom" = callPackage

10385+ ({ mkDerivation, base, bytestring, crypto-api, mtl, tagged

10386+ , transformers

10387+ }:

10388+ mkDerivation {

10389+ pname = "monadcryptorandom";

10390+ version = "0.6.1";

10391+ sha256 = "0j99j0f2qwhslimfgslsdlv0xihsddas3i69pfnjwnsd9zg5pgj2";

10392+ configureFlags = [

10393+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10394+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10395+ "-fsplitbase" "-f-test-hlint"

10396+ ];

10397+ libraryHaskellDepends = [

10398+ base bytestring crypto-api mtl tagged transformers

10399+ ];

10400+ homepage = "https://github.com/TomMD/monadcryptorandom";

10401+ description = "A monad for using CryptoRandomGen";

10402+ license = stdenv.lib.licenses.bsd3;

10403+ }) {};

10404+ "monadic-arrays" = callPackage

10405+ ({ mkDerivation, array, base, stm, transformers }:

10406+ mkDerivation {

10407+ pname = "monadic-arrays";

10408+ version = "0.2.1.3";

10409+ sha256 = "0qqf640zzv4dn0b1mpz54pdirdz3scc8z72vz884x88gzvdpr025";

10410+ configureFlags = [

10411+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10412+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10413+ "-fsplitbase" "-f-test-hlint"

10414+ ];

10415+ libraryHaskellDepends = [ array base stm transformers ];

10416+ homepage = "http://github.com/ekmett/monadic-arrays/";

10417+ description = "Boxed and unboxed arrays for monad transformers";

10418+ license = stdenv.lib.licenses.bsd3;

10419+ }) {};

10420+ "monads-tf" = callPackage

10421+ ({ mkDerivation, base, transformers }:

10422+ mkDerivation {

10423+ pname = "monads-tf";

10424+ version = "0.1.0.2";

10425+ sha256 = "0z07z2lfm3l93fx0qhfd98j76d1rksi5llq67l5v09pm8da4jvyb";

10426+ configureFlags = [

10427+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10428+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10429+ "-fsplitbase" "-f-test-hlint"

10430+ ];

10431+ libraryHaskellDepends = [ base transformers ];

10432+ description = "Monad classes, using type families";

10433+ license = stdenv.lib.licenses.bsd3;

10434+ }) {};

10435+ "mongoDB" = callPackage

10436+ ({ mkDerivation, array, base, binary, bson, bytestring, containers

10437+ , cryptohash, hashtables, lifted-base, monad-control, mtl, network

10438+ , parsec, random, random-shuffle, text, transformers-base

10439+ }:

10440+ mkDerivation {

10441+ pname = "mongoDB";

10442+ version = "2.0.3";

10443+ sha256 = "1blqd30mw9fl861f07zn7az4psl9byjjbd986884p6rx07m28abk";

10444+ configureFlags = [

10445+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10446+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10447+ "-fsplitbase" "-f-test-hlint"

10448+ ];

10449+ libraryHaskellDepends = [

10450+ array base binary bson bytestring containers cryptohash hashtables

10451+ lifted-base monad-control mtl network parsec random random-shuffle

10452+ text transformers-base

10453+ ];

10454+ homepage = "https://github.com/mongodb-haskell/mongodb";

10455+ description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";

10456+ license = "unknown";

10457+ }) {};

10458+ "mono-traversable" = callPackage

10459+ ({ mkDerivation, base, bytestring, comonad, containers, criterion

10460+ , dlist, dlist-instances, foldl, hashable, hspec, mwc-random

10461+ , QuickCheck, semigroupoids, semigroups, text, transformers

10462+ , unordered-containers, vector, vector-algorithms, vector-instances

10463+ }:

10464+ mkDerivation {

10465+ pname = "mono-traversable";

10466+ version = "0.6.3";

10467+ sha256 = "026qii2i6l8lsvhvb9l8gkzybrvf87skg6mjam2bxc3i1bjx1lkr";

10468+ revision = "2";

10469+ editedCabalFile = "0vnrf7zg3y10s2dnh7q6k0hyfc7sav2n465h726wwf41yjwd1ldn";

10470+ configureFlags = [

10471+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10472+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10473+ "-fsplitbase" "-f-test-hlint"

10474+ ];

10475+ libraryHaskellDepends = [

10476+ base bytestring comonad containers dlist dlist-instances hashable

10477+ semigroupoids semigroups text transformers unordered-containers

10478+ vector vector-algorithms vector-instances

10479+ ];

10480+ testHaskellDepends = [

10481+ base bytestring containers foldl hspec QuickCheck semigroups text

10482+ transformers unordered-containers vector

10483+ ];

10484+ benchmarkHaskellDepends = [ base criterion mwc-random vector ];

10485+ homepage = "https://github.com/snoyberg/mono-traversable";

10486+ description = "Type classes for mapping, folding, and traversing monomorphic containers";

10487+ license = stdenv.lib.licenses.mit;

10488+ }) {};

10489+ "monoid-extras" = callPackage

10490+ ({ mkDerivation, base, groups, semigroupoids, semigroups }:

10491+ mkDerivation {

10492+ pname = "monoid-extras";

10493+ version = "0.3.3.5";

10494+ sha256 = "07xll4pz0ijjxj75z0s0bz1lia2f65hsm61snlx0jv3aybrnw280";

10495+ configureFlags = [

10496+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10497+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10498+ "-fsplitbase" "-f-test-hlint"

10499+ ];

10500+ libraryHaskellDepends = [ base groups semigroupoids semigroups ];

10501+ description = "Various extra monoid-related definitions and utilities";

10502+ license = stdenv.lib.licenses.bsd3;

10503+ }) {};

10504+ "monoid-subclasses" = callPackage

10505+ ({ mkDerivation, base, bytestring, containers, primes, QuickCheck

10506+ , quickcheck-instances, test-framework, test-framework-quickcheck2

10507+ , text, vector

10508+ }:

10509+ mkDerivation {

10510+ pname = "monoid-subclasses";

10511+ version = "0.3.6.2";

10512+ sha256 = "1v9mahl8w0q8ink7qx0flfm2aplqidkgxx5fm091b69g612qlz0j";

10513+ revision = "1";

10514+ editedCabalFile = "0cxd2x2l19yznxcpwwagy5s144jqffz777v1jlpd1gbjqi48lcs2";

10515+ configureFlags = [

10516+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10517+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10518+ "-fsplitbase" "-f-test-hlint"

10519+ ];

10520+ libraryHaskellDepends = [

10521+ base bytestring containers primes text vector

10522+ ];

10523+ testHaskellDepends = [

10524+ base bytestring containers primes QuickCheck quickcheck-instances

10525+ test-framework test-framework-quickcheck2 text vector

10526+ ];

10527+ homepage = "https://github.com/blamario/monoid-subclasses/";

10528+ description = "Subclasses of Monoid";

10529+ license = stdenv.lib.licenses.bsd3;

10530+ }) {};

10531+ "mtl" = callPackage

10532+ ({ mkDerivation, base, transformers }:

10533+ mkDerivation {

10534+ pname = "mtl";

10535+ version = "2.1.3.1";

10536+ sha256 = "1xpn2wjmqbh2cg1yssc6749xpgcqlrrg4iilwqgkcjgvaxlpdbvp";

10537+ configureFlags = [

10538+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10539+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10540+ "-fsplitbase" "-f-test-hlint"

10541+ ];

10542+ libraryHaskellDepends = [ base transformers ];

10543+ homepage = "http://github.com/ekmett/mtl";

10544+ description = "Monad classes, using functional dependencies";

10545+ license = stdenv.lib.licenses.bsd3;

10546+ }) {};

10547+ "mtl-prelude" = callPackage

10548+ ({ mkDerivation, mtl, transformers }:

10549+ mkDerivation {

10550+ pname = "mtl-prelude";

10551+ version = "1.0.1";

10552+ sha256 = "09zdsgh4y4b5chl847n1dz4vys2sdyxmf0v39ad449s5rv5l92hj";

10553+ configureFlags = [

10554+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10555+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10556+ "-fsplitbase" "-f-test-hlint"

10557+ ];

10558+ libraryHaskellDepends = [ mtl transformers ];

10559+ doHaddock = false;

10560+ doCheck = false;

10561+ homepage = "https://github.com/nikita-volkov/mtl-prelude";

10562+ description = "Reexports of most definitions from \"mtl\" and \"transformers\"";

10563+ license = stdenv.lib.licenses.mit;

10564+ }) {};

10565+ "mtlparse" = callPackage

10566+ ({ mkDerivation, base, mtl }:

10567+ mkDerivation {

10568+ pname = "mtlparse";

10569+ version = "0.1.2";

10570+ sha256 = "0hnixpchgzrlx83cqykmqnahk8llf18gz8jkq2ql5y7gwj2xk1fd";

10571+ configureFlags = [

10572+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10573+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10574+ "-fsplitbase" "-f-test-hlint"

10575+ ];

10576+ libraryHaskellDepends = [ base mtl ];

10577+ homepage = "http://homepage3.nifty.com/salamander/second/projects/mtlparse/";

10578+ description = "parse library using mtl package";

10579+ license = "LGPL";

10580+ }) {};

10581+ "multimap" = callPackage

10582+ ({ mkDerivation, base, containers }:

10583+ mkDerivation {

10584+ pname = "multimap";

10585+ version = "1.2.1";

10586+ sha256 = "0d3l5q4yvmywl6i9ip96zz0fvhjdh00mfbbniphbjxsi8wlwack3";

10587+ configureFlags = [

10588+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10589+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10590+ "-fsplitbase" "-f-test-hlint"

10591+ ];

10592+ libraryHaskellDepends = [ base containers ];

10593+ homepage = "http://hub.darcs.net/scravy/multimap";

10594+ description = "A multimap";

10595+ license = stdenv.lib.licenses.mit;

10596+ }) {};

10597+ "multipart" = callPackage

10598+ ({ mkDerivation, base, bytestring, parsec }:

10599+ mkDerivation {

10600+ pname = "multipart";

10601+ version = "0.1.2";

10602+ sha256 = "0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5";

10603+ configureFlags = [

10604+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10605+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10606+ "-fsplitbase" "-f-test-hlint"

10607+ ];

10608+ libraryHaskellDepends = [ base bytestring parsec ];

10609+ homepage = "http://www.github.com/silkapp/multipart";

10610+ description = "HTTP multipart split out of the cgi package";

10611+ license = stdenv.lib.licenses.bsd3;

10612+ }) {};

10613+ "mwc-random" = callPackage

10614+ ({ mkDerivation, base, HUnit, primitive, QuickCheck, statistics

10615+ , test-framework, test-framework-hunit, test-framework-quickcheck2

10616+ , time, vector

10617+ }:

10618+ mkDerivation {

10619+ pname = "mwc-random";

10620+ version = "0.13.2.2";

10621+ sha256 = "1rsrvadaih66xn8zr8kfvrr65g7wpj6i9jnzkmlik9lqrvz4axcp";

10622+ revision = "1";

10623+ editedCabalFile = "1bl303kklx5swajkvzmyfnyg65m47xrvpli3w6299ijp2bdl1f92";

10624+ configureFlags = [

10625+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10626+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10627+ "-fsplitbase" "-f-test-hlint"

10628+ ];

10629+ libraryHaskellDepends = [ base primitive time vector ];

10630+ testHaskellDepends = [

10631+ base HUnit QuickCheck statistics test-framework

10632+ test-framework-hunit test-framework-quickcheck2 vector

10633+ ];

10634+ homepage = "https://github.com/bos/mwc-random";

10635+ description = "Fast, high quality pseudo random number generation";

10636+ license = stdenv.lib.licenses.bsd3;

10637+ }) {};

10638+ "mysql" = callPackage

10639+ ({ mkDerivation, base, bytestring, containers, mysql }:

10640+ mkDerivation {

10641+ pname = "mysql";

10642+ version = "0.1.1.7";

10643+ sha256 = "0hl8z8ynadvvhn4garjrax2b59iqddj884mv3s6804lcjjyc49d0";

10644+ configureFlags = [

10645+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10646+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10647+ "-fsplitbase" "-f-test-hlint"

10648+ ];

10649+ libraryHaskellDepends = [ base bytestring containers ];

10650+ librarySystemDepends = [ mysql ];

10651+ homepage = "https://github.com/bos/mysql";

10652+ description = "A low-level MySQL client library";

10653+ license = stdenv.lib.licenses.bsd3;

10654+ }) {inherit (pkgs) mysql;};

10655+ "mysql-simple" = callPackage

10656+ ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder

10657+ , blaze-textual, bytestring, mysql, old-locale, pcre-light, text

10658+ , time

10659+ }:

10660+ mkDerivation {

10661+ pname = "mysql-simple";

10662+ version = "0.2.2.4";

10663+ sha256 = "044grjly1gyrgba2bfrii2pa14ff7v14ncyk3kj01g1zdxnwqjh6";

10664+ revision = "2";

10665+ editedCabalFile = "05jg79ciz5xfhx8ba818kv67376rkmqbhyahrrbcjfd447lfkk8q";

10666+ configureFlags = [

10667+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10668+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10669+ "-fsplitbase" "-f-test-hlint"

10670+ ];

10671+ libraryHaskellDepends = [

10672+ attoparsec base base16-bytestring blaze-builder blaze-textual

10673+ bytestring mysql old-locale pcre-light text time

10674+ ];

10675+ homepage = "https://github.com/bos/mysql-simple";

10676+ description = "A mid-level MySQL client library";

10677+ license = stdenv.lib.licenses.bsd3;

10678+ }) {};

10679+ "nanospec" = callPackage

10680+ ({ mkDerivation, base, hspec, silently }:

10681+ mkDerivation {

10682+ pname = "nanospec";

10683+ version = "0.2.0";

10684+ sha256 = "0g10l86cv33r58zxn2bprqlm80i7g86bwzhn9jqg9s81xc0aw2qv";

10685+ configureFlags = [

10686+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10687+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10688+ "-fsplitbase" "-f-test-hlint"

10689+ ];

10690+ libraryHaskellDepends = [ base ];

10691+ testHaskellDepends = [ base hspec silently ];

10692+ description = "A lightweight implementation of a subset of Hspec's API";

10693+ license = stdenv.lib.licenses.mit;

10694+ }) {};

10695+ "nats" = callPackage

10696+ ({ mkDerivation, base, hashable }:

10697+ mkDerivation {

10698+ pname = "nats";

10699+ version = "1";

10700+ sha256 = "0r6s8l4s0yq3x2crrkv0b8zac13magfasr9v8hnq6rn1icsfhic0";

10701+ revision = "1";

10702+ editedCabalFile = "0wjbskzx423pq0lv1j66913xgrp7s1i9bn7b60qvcvi9g7l96bpa";

10703+ configureFlags = [

10704+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10705+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10706+ "-fsplitbase" "-f-test-hlint"

10707+ ];

10708+ libraryHaskellDepends = [ base hashable ];

10709+ homepage = "http://github.com/ekmett/nats/";

10710+ description = "Natural numbers";

10711+ license = stdenv.lib.licenses.bsd3;

10712+ }) {};

10713+ "neat-interpolation" = callPackage

10714+ ({ mkDerivation, base, base-prelude, HTF, parsec, template-haskell

10715+ }:

10716+ mkDerivation {

10717+ pname = "neat-interpolation";

10718+ version = "0.2.2";

10719+ sha256 = "0hjv33gpikfiwfhzna35bxiqh62d54776d3ahfb98dxfrjijl20c";

10720+ configureFlags = [

10721+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10722+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10723+ "-fsplitbase" "-f-test-hlint"

10724+ ];

10725+ libraryHaskellDepends = [

10726+ base base-prelude parsec template-haskell

10727+ ];

10728+ testHaskellDepends = [ base-prelude HTF ];

10729+ doHaddock = false;

10730+ doCheck = false;

10731+ homepage = "https://github.com/nikita-volkov/neat-interpolation";

10732+ description = "A quasiquoter for neat and simple multiline text interpolation";

10733+ license = stdenv.lib.licenses.mit;

10734+ }) {};

10735+ "nettle" = callPackage

10736+ ({ mkDerivation, array, base, byteable, bytestring

10737+ , crypto-cipher-tests, crypto-cipher-types, HUnit, nettle

10738+ , QuickCheck, securemem, tagged, test-framework

10739+ , test-framework-hunit, test-framework-quickcheck2

10740+ }:

10741+ mkDerivation {

10742+ pname = "nettle";

10743+ version = "0.1.0";

10744+ sha256 = "1ms96laa9d2ns39ymw6mlwm0mj03vss7855cs9npymhb4fmqkcas";

10745+ configureFlags = [

10746+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10747+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10748+ "-fsplitbase" "-f-test-hlint"

10749+ ];

10750+ libraryHaskellDepends = [

10751+ base byteable bytestring crypto-cipher-types securemem tagged

10752+ ];

10753+ libraryPkgconfigDepends = [ nettle ];

10754+ testHaskellDepends = [

10755+ array base bytestring crypto-cipher-tests crypto-cipher-types HUnit

10756+ QuickCheck tagged test-framework test-framework-hunit

10757+ test-framework-quickcheck2

10758+ ];

10759+ doHaddock = false;

10760+ doCheck = false;

10761+ homepage = "https://github.com/stbuehler/haskell-nettle";

10762+ description = "safe nettle binding";

10763+ license = stdenv.lib.licenses.mit;

10764+ }) {inherit (pkgs) nettle;};

10765+ "network" = callPackage

10766+ ({ mkDerivation, base, bytestring, HUnit, parsec, test-framework

10767+ , test-framework-hunit, test-framework-quickcheck2, unix

10768+ }:

10769+ mkDerivation {

10770+ pname = "network";

10771+ version = "2.5.0.0";

10772+ sha256 = "1x90fdzfigqq2vbjqg73p4vyy7p1z0apj79cpl7i9v9amxa6y5mj";

10773+ configureFlags = [

10774+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10775+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10776+ "-fsplitbase" "-f-test-hlint"

10777+ ];

10778+ libraryHaskellDepends = [ base bytestring parsec unix ];

10779+ testHaskellDepends = [

10780+ base bytestring HUnit test-framework test-framework-hunit

10781+ test-framework-quickcheck2

10782+ ];

10783+ doHaddock = false;

10784+ doCheck = false;

10785+ homepage = "https://github.com/haskell/network";

10786+ description = "Low-level networking interface";

10787+ license = stdenv.lib.licenses.bsd3;

10788+ }) {};

10789+ "network-conduit-tls" = callPackage

10790+ ({ mkDerivation, base, bytestring, conduit, conduit-extra

10791+ , connection, cprng-aes, data-default, HUnit, monad-control, mtl

10792+ , network, streaming-commons, system-fileio, system-filepath, tls

10793+ , transformers

10794+ }:

10795+ mkDerivation {

10796+ pname = "network-conduit-tls";

10797+ version = "1.1.0.2";

10798+ sha256 = "1jgv2g3fsfp0rym4g0d9w5hm5ws0sfisj07hcfk2711rm107zaax";

10799+ revision = "1";

10800+ editedCabalFile = "16dfn5qkmijgfz6fq6zy4ddmdd5psf0az5ybxa85jqa1318h750f";

10801+ configureFlags = [

10802+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10803+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10804+ "-fsplitbase" "-f-test-hlint"

10805+ ];

10806+ libraryHaskellDepends = [

10807+ base bytestring conduit conduit-extra connection cprng-aes

10808+ data-default monad-control network streaming-commons system-fileio

10809+ system-filepath tls transformers

10810+ ];

10811+ testHaskellDepends = [

10812+ base bytestring conduit conduit-extra connection HUnit mtl

10813+ ];

10814+ homepage = "https://github.com/snoyberg/conduit";

10815+ description = "Create TLS-aware network code with conduits";

10816+ license = stdenv.lib.licenses.mit;

10817+ }) {};

10818+ "network-info" = callPackage

10819+ ({ mkDerivation, base }:

10820+ mkDerivation {

10821+ pname = "network-info";

10822+ version = "0.2.0.5";

10823+ sha256 = "0ggxnkjkbspynma0wjrc1wwwb9ygx2dhl0n9lfaq7l8r69z7pqwf";

10824+ configureFlags = [

10825+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10826+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10827+ "-fsplitbase" "-f-test-hlint"

10828+ ];

10829+ libraryHaskellDepends = [ base ];

10830+ homepage = "http://github.com/jystic/network-info";

10831+ description = "Access the local computer's basic network configuration";

10832+ license = stdenv.lib.licenses.bsd3;

10833+ }) {};

10834+ "network-multicast" = callPackage

10835+ ({ mkDerivation, base, network }:

10836+ mkDerivation {

10837+ pname = "network-multicast";

10838+ version = "0.0.11";

10839+ sha256 = "0fgscv9crk2lx99rh234ipgl5psbrjili95inxj23drvwmsj3135";

10840+ configureFlags = [

10841+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10842+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10843+ "-fsplitbase" "-f-test-hlint"

10844+ ];

10845+ libraryHaskellDepends = [ base network ];

10846+ description = "Simple multicast library";

10847+ license = stdenv.lib.licenses.publicDomain;

10848+ }) {};

10849+ "network-simple" = callPackage

10850+ ({ mkDerivation, base, bytestring, exceptions, network

10851+ , transformers

10852+ }:

10853+ mkDerivation {

10854+ pname = "network-simple";

10855+ version = "0.4.0.2";

10856+ sha256 = "0k155m1s7k157rpsz8ww9cs7jyw3faybwfmw97agvskhb4axw6hf";

10857+ configureFlags = [

10858+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10859+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10860+ "-fsplitbase" "-f-test-hlint"

10861+ ];

10862+ libraryHaskellDepends = [

10863+ base bytestring exceptions network transformers

10864+ ];

10865+ homepage = "https://github.com/k0001/network-simple";

10866+ description = "Simple network sockets usage patterns";

10867+ license = stdenv.lib.licenses.bsd3;

10868+ }) {};

10869+ "network-transport" = callPackage

10870+ ({ mkDerivation, base, binary, bytestring, hashable, transformers

10871+ }:

10872+ mkDerivation {

10873+ pname = "network-transport";

10874+ version = "0.4.1.0";

10875+ sha256 = "0xn879ngrbnm71i1wsbxxiih22sdb6csy6aip6fgqyafqlpc1c93";

10876+ configureFlags = [

10877+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10878+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10879+ "-fsplitbase" "-f-test-hlint"

10880+ ];

10881+ libraryHaskellDepends = [

10882+ base binary bytestring hashable transformers

10883+ ];

10884+ homepage = "http://haskell-distributed.github.com";

10885+ description = "Network abstraction layer";

10886+ license = stdenv.lib.licenses.bsd3;

10887+ }) {};

10888+ "network-transport-tcp" = callPackage

10889+ ({ mkDerivation, base, bytestring, containers, data-accessor

10890+ , network, network-transport, network-transport-tests

10891+ }:

10892+ mkDerivation {

10893+ pname = "network-transport-tcp";

10894+ version = "0.4.1";

10895+ sha256 = "11fj0f2yrvdqn3sivfb4p0chs74bx26a0yc49fh160kkcmk42yaf";

10896+ configureFlags = [

10897+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10898+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10899+ "-fsplitbase" "-f-test-hlint"

10900+ ];

10901+ libraryHaskellDepends = [

10902+ base bytestring containers data-accessor network network-transport

10903+ ];

10904+ testHaskellDepends = [

10905+ base network network-transport network-transport-tests

10906+ ];

10907+ doHaddock = false;

10908+ doCheck = false;

10909+ homepage = "http://haskell-distributed.github.com";

10910+ description = "TCP instantiation of Network.Transport";

10911+ license = stdenv.lib.licenses.bsd3;

10912+ }) {};

10913+ "network-transport-tests" = callPackage

10914+ ({ mkDerivation, ansi-terminal, base, bytestring, containers, mtl

10915+ , network-transport, random

10916+ }:

10917+ mkDerivation {

10918+ pname = "network-transport-tests";

10919+ version = "0.2.1.0";

10920+ sha256 = "17qf52a76an9ignhb85alz92j9vk3p0ydmaqys8b1ss5mkqipm64";

10921+ configureFlags = [

10922+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10923+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10924+ "-fsplitbase" "-f-test-hlint"

10925+ ];

10926+ libraryHaskellDepends = [

10927+ ansi-terminal base bytestring containers mtl network-transport

10928+ random

10929+ ];

10930+ homepage = "http://haskell-distributed.github.com";

10931+ description = "Unit tests for Network.Transport implementations";

10932+ license = stdenv.lib.licenses.bsd3;

10933+ }) {};

10934+ "network-uri" = callPackage

10935+ ({ mkDerivation }:

10936+ mkDerivation {

10937+ pname = "network-uri";

10938+ version = "2.5.0.0";

10939+ sha256 = "0ki2iyvgvwwdj42z3biqz4680axn62qjv8ahx05i7n23g78cbv63";

10940+ configureFlags = [

10941+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10942+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10943+ "-fsplitbase" "-f-test-hlint"

10944+ ];

10945+ doHaddock = false;

10946+ doCheck = false;

10947+ homepage = "https://github.com/haskell/network-uri";

10948+ description = "URI manipulation";

10949+ license = stdenv.lib.licenses.bsd3;

10950+ }) {};

10951+ "newtype" = callPackage

10952+ ({ mkDerivation, base }:

10953+ mkDerivation {

10954+ pname = "newtype";

10955+ version = "0.2";

10956+ sha256 = "0ng4i5r73256gzwl6bw57h0abqixj783c3ggph1hk2wsplx0655p";

10957+ configureFlags = [

10958+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10959+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10960+ "-fsplitbase" "-f-test-hlint"

10961+ ];

10962+ libraryHaskellDepends = [ base ];

10963+ description = "A typeclass and set of functions for working with newtypes";

10964+ license = stdenv.lib.licenses.bsd3;

10965+ }) {};

10966+ "nsis" = callPackage

10967+ ({ mkDerivation, base, process, transformers, uniplate }:

10968+ mkDerivation {

10969+ pname = "nsis";

10970+ version = "0.2.4";

10971+ sha256 = "17jl5s48msa6c5rb9lvlcsjmv6kzml3yrfmz7h1ipxsdl0yf7nd3";

10972+ configureFlags = [

10973+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10974+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10975+ "-fsplitbase" "-f-test-hlint"

10976+ ];

10977+ libraryHaskellDepends = [ base transformers uniplate ];

10978+ testHaskellDepends = [ base process transformers uniplate ];

10979+ homepage = "https://github.com/ndmitchell/nsis#readme";

10980+ description = "DSL for producing Windows Installer using NSIS";

10981+ license = stdenv.lib.licenses.bsd3;

10982+ }) {};

10983+ "numbers" = callPackage

10984+ ({ mkDerivation, base, QuickCheck, test-framework

10985+ , test-framework-quickcheck2

10986+ }:

10987+ mkDerivation {

10988+ pname = "numbers";

10989+ version = "3000.2.0.1";

10990+ sha256 = "10z1bi5qbc81z5xx2v1ylwcpmcfl1ci7lxrswkgi0dd1wi8havbk";

10991+ configureFlags = [

10992+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10993+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10994+ "-fsplitbase" "-f-test-hlint"

10995+ ];

10996+ libraryHaskellDepends = [ base ];

10997+ testHaskellDepends = [

10998+ base QuickCheck test-framework test-framework-quickcheck2

10999+ ];

11000+ homepage = "https://github.com/jwiegley/numbers#readme";

11001+ description = "Various number types";

11002+ license = stdenv.lib.licenses.bsd3;

11003+ }) {};

11004+ "numeric-extras" = callPackage

11005+ ({ mkDerivation, base }:

11006+ mkDerivation {

11007+ pname = "numeric-extras";

11008+ version = "0.0.3";

11009+ sha256 = "18jyjrk6iizz3sgkwgbh1rxf6zdf166bkgs7wia8b4z7f6261nzg";

11010+ configureFlags = [

11011+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11012+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11013+ "-fsplitbase" "-f-test-hlint"

11014+ ];

11015+ libraryHaskellDepends = [ base ];

11016+ homepage = "http://github.com/ekmett/numeric-extras";

11017+ description = "Useful tools from the C standard library";

11018+ license = stdenv.lib.licenses.bsd3;

11019+ }) {};

11020+ "numtype" = callPackage

11021+ ({ mkDerivation, base }:

11022+ mkDerivation {

11023+ pname = "numtype";

11024+ version = "1.1";

11025+ sha256 = "1az10xcfl6qpyy9qnh8g2iqx53rxnjxzc1h8kl1gira6yv7g6857";

11026+ configureFlags = [

11027+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11028+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11029+ "-fsplitbase" "-f-test-hlint"

11030+ ];

11031+ libraryHaskellDepends = [ base ];

11032+ homepage = "http://dimensional.googlecode.com/";

11033+ description = "Type-level (low cardinality) integers";

11034+ license = stdenv.lib.licenses.bsd3;

11035+ }) {};

11036+ "openpgp-asciiarmor" = callPackage

11037+ ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring

11038+ , cereal, HUnit, test-framework, test-framework-hunit

11039+ }:

11040+ mkDerivation {

11041+ pname = "openpgp-asciiarmor";

11042+ version = "0.1";

11043+ sha256 = "1xrv0n7n1n8izvxvqm8wmj6mkn5l6wcq18bxs9zd1q5riynmmm2w";

11044+ configureFlags = [

11045+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11046+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11047+ "-fsplitbase" "-f-test-hlint"

11048+ ];

11049+ libraryHaskellDepends = [

11050+ attoparsec base base64-bytestring bytestring cereal

11051+ ];

11052+ testHaskellDepends = [

11053+ attoparsec base base64-bytestring bytestring cereal HUnit

11054+ test-framework test-framework-hunit

11055+ ];

11056+ homepage = "http://floss.scru.org/openpgp-asciiarmor";

11057+ description = "OpenPGP (RFC4880) ASCII Armor codec";

11058+ license = "unknown";

11059+ }) {};

11060+ "operational" = callPackage

11061+ ({ mkDerivation, base, mtl, random }:

11062+ mkDerivation {

11063+ pname = "operational";

11064+ version = "0.2.3.2";

11065+ sha256 = "1aj3jhiyz4190b0qmyp684b8lbzrp8jn56s898892rvbp0hxa0pd";

11066+ configureFlags = [

11067+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11068+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11069+ "-fsplitbase" "-f-test-hlint"

11070+ ];

11071+ isLibrary = true;

11072+ isExecutable = true;

11073+ libraryHaskellDepends = [ base mtl ];

11074+ executableHaskellDepends = [ random ];

11075+ homepage = "http://haskell.org/haskellwiki/Operational";

11076+ description = "Implementation of difficult monads made easy with operational semantics";

11077+ license = stdenv.lib.licenses.bsd3;

11078+ }) {};

11079+ "options" = callPackage

11080+ ({ mkDerivation, base, containers, monads-tf, transformers }:

11081+ mkDerivation {

11082+ pname = "options";

11083+ version = "1.2";

11084+ sha256 = "14qrkwd8h50wf6972p0ylvhnc8mh11fqk9l8q0h9lapj7ywm74vx";

11085+ revision = "1";

11086+ editedCabalFile = "0fxzmp52xliiqf65w991qw47k2sggqdw8vwjg1jaa9lnr1npvs9h";

11087+ configureFlags = [

11088+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11089+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11090+ "-fsplitbase" "-f-test-hlint"

11091+ ];

11092+ libraryHaskellDepends = [ base containers monads-tf transformers ];

11093+ doHaddock = false;

11094+ doCheck = false;

11095+ homepage = "https://john-millikin.com/software/haskell-options/";

11096+ description = "A powerful and easy-to-use command-line option parser";

11097+ license = stdenv.lib.licenses.mit;

11098+ }) {};

11099+ "optparse-applicative" = callPackage

11100+ ({ mkDerivation, ansi-wl-pprint, base, process, transformers

11101+ , transformers-compat

11102+ }:

11103+ mkDerivation {

11104+ pname = "optparse-applicative";

11105+ version = "0.11.0.1";

11106+ sha256 = "0jdzajj9w0dghv751m59l3imzm2x9lx9cqb6094mncnx8k6cf6f9";

11107+ configureFlags = [

11108+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11109+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11110+ "-fsplitbase" "-f-test-hlint"

11111+ ];

11112+ libraryHaskellDepends = [

11113+ ansi-wl-pprint base process transformers transformers-compat

11114+ ];

11115+ homepage = "https://github.com/pcapriotti/optparse-applicative";

11116+ description = "Utilities and combinators for parsing command line options";

11117+ license = stdenv.lib.licenses.bsd3;

11118+ }) {};

11119+ "osdkeys" = callPackage

11120+ ({ mkDerivation, base, bytestring, conduit, conduit-extra

11121+ , containers, libnotify, process, resourcet, time, transformers

11122+ }:

11123+ mkDerivation {

11124+ pname = "osdkeys";

11125+ version = "0.0";

11126+ sha256 = "18pc2r5acb3b6dr7niib4fn8x2la6y3f5zlj3ibrxhl5c1q35j6y";

11127+ configureFlags = [

11128+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11129+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11130+ "-fsplitbase" "-f-test-hlint"

11131+ ];

11132+ isLibrary = true;

11133+ isExecutable = true;

11134+ libraryHaskellDepends = [

11135+ base bytestring conduit conduit-extra containers libnotify

11136+ resourcet time transformers

11137+ ];

11138+ executableHaskellDepends = [ base process ];

11139+ description = "Show keys pressed with an on-screen display (Linux only)";

11140+ license = stdenv.lib.licenses.bsd3;

11141+ }) {};

11142+ "pandoc" = callPackage

11143+ ({ mkDerivation, aeson, ansi-terminal, array, base

11144+ , base64-bytestring, binary, blaze-html, blaze-markup, bytestring

11145+ , containers, data-default, deepseq-generics, Diff, directory

11146+ , executable-path, extensible-exceptions, filepath, haddock-library

11147+ , highlighting-kate, hslua, HTTP, http-client, http-client-tls

11148+ , http-types, HUnit, JuicyPixels, mtl, network, old-locale

11149+ , old-time, pandoc-types, parsec, process, QuickCheck, random

11150+ , scientific, SHA, syb, tagsoup, temporary, test-framework

11151+ , test-framework-hunit, test-framework-quickcheck2, texmath, text

11152+ , time, unordered-containers, vector, xml, yaml, zip-archive, zlib

11153+ }:

11154+ mkDerivation {

11155+ pname = "pandoc";

11156+ version = "1.13.1";

11157+ sha256 = "0vvysa70xp4pskxrvslmddwdsalc479zb8wn6z1vmpvfssvvj6vv";

11158+ revision = "1";

11159+ editedCabalFile = "1i57yk1pql4gv97cs86fk82hkwncics1wkzjqd9iz866204y4wrg";

11160+ configureFlags = [

11161+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11162+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11163+ "-fsplitbase" "-f-test-hlint"

11164+ ];

11165+ isLibrary = true;

11166+ isExecutable = true;

11167+ enableSeparateDataOutput = true;

11168+ libraryHaskellDepends = [

11169+ aeson array base base64-bytestring binary blaze-html blaze-markup

11170+ bytestring containers data-default deepseq-generics directory

11171+ extensible-exceptions filepath haddock-library highlighting-kate

11172+ hslua HTTP http-client http-client-tls http-types JuicyPixels mtl

11173+ network old-locale old-time pandoc-types parsec process random

11174+ scientific SHA syb tagsoup temporary texmath text time

11175+ unordered-containers vector xml yaml zip-archive zlib

11176+ ];

11177+ executableHaskellDepends = [

11178+ aeson base bytestring containers directory extensible-exceptions

11179+ filepath highlighting-kate HTTP network old-time pandoc-types text

11180+ time yaml

11181+ ];

11182+ testHaskellDepends = [

11183+ ansi-terminal base bytestring containers Diff directory

11184+ executable-path filepath highlighting-kate HUnit pandoc-types

11185+ process QuickCheck syb test-framework test-framework-hunit

11186+ test-framework-quickcheck2 text zip-archive

11187+ ];

11188+ doHaddock = false;

11189+ doCheck = false;

11190+ homepage = "http://johnmacfarlane.net/pandoc";

11191+ description = "Conversion between markup formats";

11192+ license = "GPL";

11193+ }) {};

11194+ "pandoc-citeproc" = callPackage

11195+ ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring

11196+ , containers, data-default, directory, filepath, hs-bibutils, mtl

11197+ , old-locale, pandoc, pandoc-types, parsec, process, rfc5051, split

11198+ , syb, tagsoup, temporary, text, time, vector, xml-conduit, yaml

11199+ }:

11200+ mkDerivation {

11201+ pname = "pandoc-citeproc";

11202+ version = "0.6";

11203+ sha256 = "1whi8mrbhfi8wr3qbj1lkgc1pngn8151jjri409hshl1mng4aq5b";

11204+ configureFlags = [

11205+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11206+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11207+ "-fsplitbase" "-f-test-hlint"

11208+ ];

11209+ isLibrary = true;

11210+ isExecutable = true;

11211+ enableSeparateDataOutput = true;

11212+ libraryHaskellDepends = [

11213+ aeson base bytestring containers data-default directory filepath

11214+ hs-bibutils mtl old-locale pandoc pandoc-types parsec rfc5051 split

11215+ syb tagsoup text time vector xml-conduit yaml

11216+ ];

11217+ executableHaskellDepends = [

11218+ aeson aeson-pretty attoparsec base bytestring containers directory

11219+ filepath pandoc pandoc-types process syb temporary text vector yaml

11220+ ];

11221+ testHaskellDepends = [

11222+ aeson base bytestring directory filepath pandoc pandoc-types

11223+ process temporary text yaml

11224+ ];

11225+ doHaddock = false;

11226+ doCheck = false;

11227+ description = "Supports using pandoc with citeproc";

11228+ license = stdenv.lib.licenses.bsd3;

11229+ }) {};

11230+ "pandoc-types" = callPackage

11231+ ({ mkDerivation, aeson, base, bytestring, containers

11232+ , deepseq-generics, ghc-prim, syb

11233+ }:

11234+ mkDerivation {

11235+ pname = "pandoc-types";

11236+ version = "1.12.4.1";

11237+ sha256 = "1wbgm0s45smi8gix0byapkiarbb416fv765fc329qsvl295xlyqq";

11238+ configureFlags = [

11239+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11240+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11241+ "-fsplitbase" "-f-test-hlint"

11242+ ];

11243+ libraryHaskellDepends = [

11244+ aeson base bytestring containers deepseq-generics ghc-prim syb

11245+ ];

11246+ homepage = "http://johnmacfarlane.net/pandoc";

11247+ description = "Types for representing a structured document";

11248+ license = "GPL";

11249+ }) {};

11250+ "pango" = callPackage

11251+ ({ mkDerivation, array, base, cairo, containers, directory, glib

11252+ , gtk2hs-buildtools, mtl, pango, pretty, process, text

11253+ }:

11254+ mkDerivation {

11255+ pname = "pango";

11256+ version = "0.13.0.4";

11257+ sha256 = "1fglwywac36abpjjpgdsk62f4sndgr5nf29fmana0yac7hxsm1sq";

11258+ configureFlags = [

11259+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11260+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11261+ "-fsplitbase" "-f-test-hlint"

11262+ ];

11263+ enableSeparateDataOutput = true;

11264+ libraryHaskellDepends = [

11265+ array base cairo containers directory glib mtl pretty process text

11266+ ];

11267+ libraryPkgconfigDepends = [ pango ];

11268+ libraryToolDepends = [ gtk2hs-buildtools ];

11269+ doHaddock = false;

11270+ doCheck = false;

11271+ homepage = "http://projects.haskell.org/gtk2hs/";

11272+ description = "Binding to the Pango text rendering engine";

11273+ license = stdenv.lib.licenses.lgpl21;

11274+ }) {inherit (pkgs.gnome2) pango;};

11275+ "parallel" = callPackage

11276+ ({ mkDerivation, array, base, containers, deepseq }:

11277+ mkDerivation {

11278+ pname = "parallel";

11279+ version = "3.2.0.5";

11280+ sha256 = "16hhsi8pr29qqg9ssks0y9j0vmnvpyy1qk46s0c0vgj3pyzl38mm";

11281+ revision = "1";

11282+ editedCabalFile = "0qhqzpazf72sg947hkfxnvz4m9nwz7bknna1nfal55iybyb87mnb";

11283+ configureFlags = [

11284+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11285+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11286+ "-fsplitbase" "-f-test-hlint"

11287+ ];

11288+ libraryHaskellDepends = [ array base containers deepseq ];

11289+ description = "Parallel programming library";

11290+ license = stdenv.lib.licenses.bsd3;

11291+ }) {};

11292+ "parallel-io" = callPackage

11293+ ({ mkDerivation, base, containers, extensible-exceptions, random }:

11294+ mkDerivation {

11295+ pname = "parallel-io";

11296+ version = "0.3.3";

11297+ sha256 = "0i86x3bf8pjlg6mdg1zg5lcrjpg75pbqs2mrgrbp4z4bkcmw051s";

11298+ revision = "1";

11299+ editedCabalFile = "1vlb2x1ghih4l64031rmh7h643c3knh5r5mwilf7g8izb58ypvkm";

11300+ configureFlags = [

11301+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11302+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11303+ "-fsplitbase" "-f-test-hlint"

11304+ ];

11305+ isLibrary = true;

11306+ isExecutable = true;

11307+ libraryHaskellDepends = [

11308+ base containers extensible-exceptions random

11309+ ];

11310+ homepage = "http://batterseapower.github.com/parallel-io";

11311+ description = "Combinators for executing IO actions in parallel on a thread pool";

11312+ license = stdenv.lib.licenses.bsd3;

11313+ }) {};

11314+ "parseargs" = callPackage

11315+ ({ mkDerivation, base, containers }:

11316+ mkDerivation {

11317+ pname = "parseargs";

11318+ version = "0.1.5.2";

11319+ sha256 = "0pzw7w1kr2rv6ffqgn93rypn37wy2r5k01p3y5256laaplm575am";

11320+ configureFlags = [

11321+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11322+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11323+ "-fsplitbase" "-f-test-hlint"

11324+ ];

11325+ isLibrary = true;

11326+ isExecutable = true;

11327+ libraryHaskellDepends = [ base containers ];

11328+ executableHaskellDepends = [ base ];

11329+ homepage = "http://github.com/BartMassey/parseargs";

11330+ description = "Command-line argument parsing library for Haskell programs";

11331+ license = stdenv.lib.licenses.bsd3;

11332+ }) {};

11333+ "parsec" = callPackage

11334+ ({ mkDerivation, base, bytestring, HUnit, mtl, test-framework

11335+ , test-framework-hunit, text

11336+ }:

11337+ mkDerivation {

11338+ pname = "parsec";

11339+ version = "3.1.7";

11340+ sha256 = "12h7n367gaw9ifd19yd3ppi4j6kghf7rryacl0ips0fwlxw1x8wa";

11341+ configureFlags = [

11342+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11343+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11344+ "-fsplitbase" "-f-test-hlint"

11345+ ];

11346+ libraryHaskellDepends = [ base bytestring mtl text ];

11347+ testHaskellDepends = [

11348+ base HUnit test-framework test-framework-hunit

11349+ ];

11350+ homepage = "http://www.cs.uu.nl/~daan/parsec.html";

11351+ description = "Monadic parser combinators";

11352+ license = stdenv.lib.licenses.bsd3;

11353+ }) {};

11354+ "parsers" = callPackage

11355+ ({ mkDerivation, attoparsec, base, bytestring, charset, containers

11356+ , directory, doctest, filepath, parsec, QuickCheck

11357+ , quickcheck-instances, text, transformers, unordered-containers

11358+ }:

11359+ mkDerivation {

11360+ pname = "parsers";

11361+ version = "0.12.1.1";

11362+ sha256 = "1yx75xbmg3lms0hj79r5w9fl81g5cbsm842lijhd9jnnbli2mzfw";

11363+ configureFlags = [

11364+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11365+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11366+ "-fsplitbase" "-f-test-hlint"

11367+ ];

11368+ libraryHaskellDepends = [

11369+ attoparsec base charset containers parsec text transformers

11370+ unordered-containers

11371+ ];

11372+ testHaskellDepends = [

11373+ attoparsec base bytestring containers directory doctest filepath

11374+ parsec QuickCheck quickcheck-instances

11375+ ];

11376+ homepage = "http://github.com/ekmett/parsers/";

11377+ description = "Parsing combinators";

11378+ license = stdenv.lib.licenses.bsd3;

11379+ }) {};

11380+ "partial-handler" = callPackage

11381+ ({ mkDerivation, base }:

11382+ mkDerivation {

11383+ pname = "partial-handler";

11384+ version = "0.1.0";

11385+ sha256 = "07dhsm2r89iviz481r9wxw0scq40dgfzw0mi6klky78xn8r9x4ds";

11386+ revision = "1";

11387+ editedCabalFile = "121jkr036ilsiamjg1pszd48q2v2nf5s9gz96p69nxqd37sbgp1h";

11388+ configureFlags = [

11389+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11390+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11391+ "-fsplitbase" "-f-test-hlint"

11392+ ];

11393+ libraryHaskellDepends = [ base ];

11394+ doHaddock = false;

11395+ doCheck = false;

11396+ homepage = "https://github.com/nikita-volkov/partial-handler";

11397+ description = "A composable exception handler";

11398+ license = stdenv.lib.licenses.mit;

11399+ }) {};

11400+ "path-pieces" = callPackage

11401+ ({ mkDerivation, base, hspec, HUnit, QuickCheck, text, time }:

11402+ mkDerivation {

11403+ pname = "path-pieces";

11404+ version = "0.1.4";

11405+ sha256 = "1fxhp4bk88km7z1rdpify7l38li5k21qxw3vgcmq9b6bblvz6y2v";

11406+ configureFlags = [

11407+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11408+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11409+ "-fsplitbase" "-f-test-hlint"

11410+ ];

11411+ libraryHaskellDepends = [ base text time ];

11412+ testHaskellDepends = [ base hspec HUnit QuickCheck text ];

11413+ description = "Components of paths";

11414+ license = stdenv.lib.licenses.bsd3;

11415+ }) {};

11416+ "patience" = callPackage

11417+ ({ mkDerivation, base, containers }:

11418+ mkDerivation {

11419+ pname = "patience";

11420+ version = "0.1.1";

11421+ sha256 = "0qyv20gqy9pb1acy700ahv70lc6vprcwb26cc7fcpcs4scsc7irm";

11422+ configureFlags = [

11423+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11424+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11425+ "-fsplitbase" "-f-test-hlint"

11426+ ];

11427+ libraryHaskellDepends = [ base containers ];

11428+ description = "Patience diff and longest increasing subsequence";

11429+ license = stdenv.lib.licenses.bsd3;

11430+ }) {};

11431+ "pcre-light" = callPackage

11432+ ({ mkDerivation, base, bytestring, pcre }:

11433+ mkDerivation {

11434+ pname = "pcre-light";

11435+ version = "0.4.0.3";

11436+ sha256 = "0l1df2sk5qwf424bvb8mbdkr2xjg43fi92n5r22yd7vm1zz0jqvf";

11437+ configureFlags = [

11438+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11439+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11440+ "-fsplitbase" "-f-test-hlint"

11441+ ];

11442+ libraryHaskellDepends = [ base bytestring ];

11443+ librarySystemDepends = [ pcre ];

11444+ homepage = "https://github.com/Daniel-Diaz/pcre-light";

11445+ description = "A small, efficient and portable regex library for Perl 5 compatible regular expressions";

11446+ license = stdenv.lib.licenses.bsd3;

11447+ }) {inherit (pkgs) pcre;};

11448+ "pdfinfo" = callPackage

11449+ ({ mkDerivation, base, mtl, old-locale, process-extras, text, time

11450+ }:

11451+ mkDerivation {

11452+ pname = "pdfinfo";

11453+ version = "1.5.1";

11454+ sha256 = "1xhznh9pqx4yvzfnypjkmgrsv5z1949vnrix101y6iy0y1zk4r5x";

11455+ configureFlags = [

11456+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11457+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11458+ "-fsplitbase" "-f-test-hlint"

11459+ ];

11460+ libraryHaskellDepends = [

11461+ base mtl old-locale process-extras text time

11462+ ];

11463+ homepage = "https://github.com/chrisdone/pdfinfo";

11464+ description = "Wrapper around the pdfinfo command";

11465+ license = stdenv.lib.licenses.bsd3;

11466+ }) {};

11467+ "pem" = callPackage

11468+ ({ mkDerivation, base, base64-bytestring, bytestring, HUnit, mtl

11469+ , QuickCheck, test-framework, test-framework-hunit

11470+ , test-framework-quickcheck2

11471+ }:

11472+ mkDerivation {

11473+ pname = "pem";

11474+ version = "0.2.2";

11475+ sha256 = "162sk5sg22w21wqz5qv8kx6ibxp99v5p20g3nknhm1kddk3hha1p";

11476+ configureFlags = [

11477+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11478+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11479+ "-fsplitbase" "-f-test-hlint"

11480+ ];

11481+ enableSeparateDataOutput = true;

11482+ libraryHaskellDepends = [ base base64-bytestring bytestring mtl ];

11483+ testHaskellDepends = [

11484+ base bytestring HUnit QuickCheck test-framework

11485+ test-framework-hunit test-framework-quickcheck2

11486+ ];

11487+ homepage = "http://github.com/vincenthz/hs-pem";

11488+ description = "Privacy Enhanced Mail (PEM) format reader and writer";

11489+ license = stdenv.lib.licenses.bsd3;

11490+ }) {};

11491+ "persistent" = callPackage

11492+ ({ mkDerivation, aeson, attoparsec, base, base64-bytestring

11493+ , blaze-html, blaze-markup, bytestring, conduit, containers

11494+ , exceptions, fast-logger, hspec, lifted-base, monad-control

11495+ , monad-logger, mtl, path-pieces, resource-pool, resourcet

11496+ , scientific, silently, tagged, template-haskell, text, time

11497+ , transformers, transformers-base, unordered-containers, vector

11498+ }:

11499+ mkDerivation {

11500+ pname = "persistent";

11501+ version = "2.1.1";

11502+ sha256 = "0wmvjizz0zx5i9q5sh8hvsks14q6if4s0dnk63f9mw03jb8jpdd1";

11503+ revision = "1";

11504+ editedCabalFile = "1m7kpg01kvg9r9lgb3ns3r7n18pblwl3ynd2vhgcazvr5qd8j1ac";

11505+ configureFlags = [

11506+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11507+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11508+ "-fsplitbase" "-f-test-hlint"

11509+ ];

11510+ libraryHaskellDepends = [

11511+ aeson attoparsec base base64-bytestring blaze-html blaze-markup

11512+ bytestring conduit containers exceptions fast-logger lifted-base

11513+ monad-control monad-logger mtl path-pieces resource-pool resourcet

11514+ scientific silently tagged template-haskell text time transformers

11515+ transformers-base unordered-containers vector

11516+ ];

11517+ testHaskellDepends = [

11518+ aeson attoparsec base base64-bytestring blaze-html bytestring

11519+ conduit containers hspec monad-control monad-logger path-pieces

11520+ resourcet scientific text time transformers unordered-containers

11521+ vector

11522+ ];

11523+ homepage = "http://www.yesodweb.com/book/persistent";

11524+ description = "Type-safe, multi-backend data serialization";

11525+ license = stdenv.lib.licenses.mit;

11526+ }) {};

11527+ "persistent-mongoDB" = callPackage

11528+ ({ mkDerivation, aeson, attoparsec, base, bson, bytestring, cereal

11529+ , conduit, containers, monad-control, mongoDB, network, path-pieces

11530+ , persistent, pool-conduit, resourcet, text, time, transformers

11531+ }:

11532+ mkDerivation {

11533+ pname = "persistent-mongoDB";

11534+ version = "2.1.2";

11535+ sha256 = "0xqskvqn4lxqpya6cd1k90sqyz5wm0c9kgxa793kaak7dlyvdvf8";

11536+ configureFlags = [

11537+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11538+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11539+ "-fsplitbase" "-f-test-hlint"

11540+ ];

11541+ libraryHaskellDepends = [

11542+ aeson attoparsec base bson bytestring cereal conduit containers

11543+ monad-control mongoDB network path-pieces persistent pool-conduit

11544+ resourcet text time transformers

11545+ ];

11546+ homepage = "http://www.yesodweb.com/book/persistent";

11547+ description = "Backend for the persistent library using mongoDB";

11548+ license = stdenv.lib.licenses.mit;

11549+ }) {};

11550+ "persistent-mysql" = callPackage

11551+ ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit

11552+ , containers, monad-control, monad-logger, mysql, mysql-simple

11553+ , persistent, resourcet, text, transformers

11554+ }:

11555+ mkDerivation {

11556+ pname = "persistent-mysql";

11557+ version = "2.1.2";

11558+ sha256 = "06i2wcrqvk216bq3853acqi6wgrdzkz3wzah231gv3yz348lr6sv";

11559+ configureFlags = [

11560+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11561+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11562+ "-fsplitbase" "-f-test-hlint"

11563+ ];

11564+ libraryHaskellDepends = [

11565+ aeson base blaze-builder bytestring conduit containers

11566+ monad-control monad-logger mysql mysql-simple persistent resourcet

11567+ text transformers

11568+ ];

11569+ homepage = "http://www.yesodweb.com/book/persistent";

11570+ description = "Backend for the persistent library using MySQL database server";

11571+ license = stdenv.lib.licenses.mit;

11572+ }) {};

11573+ "persistent-postgresql" = callPackage

11574+ ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit

11575+ , containers, monad-control, monad-logger, persistent

11576+ , postgresql-libpq, postgresql-simple, resourcet, text, time

11577+ , transformers

11578+ }:

11579+ mkDerivation {

11580+ pname = "persistent-postgresql";

11581+ version = "2.1.1";

11582+ sha256 = "0mfvzd62qn7ffx6nrgkr52qzl3prjq8xkahvb6j5akb6azdmzg80";

11583+ configureFlags = [

11584+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11585+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11586+ "-fsplitbase" "-f-test-hlint"

11587+ ];

11588+ libraryHaskellDepends = [

11589+ aeson base blaze-builder bytestring conduit containers

11590+ monad-control monad-logger persistent postgresql-libpq

11591+ postgresql-simple resourcet text time transformers

11592+ ];

11593+ homepage = "http://www.yesodweb.com/book/persistent";

11594+ description = "Backend for the persistent library using postgresql";

11595+ license = stdenv.lib.licenses.mit;

11596+ }) {};

11597+ "persistent-sqlite" = callPackage

11598+ ({ mkDerivation, aeson, base, bytestring, conduit, containers

11599+ , monad-control, monad-logger, persistent, resourcet, text

11600+ , transformers

11601+ }:

11602+ mkDerivation {

11603+ pname = "persistent-sqlite";

11604+ version = "2.1.1";

11605+ sha256 = "1hypaixwp6q10gfwbg0xfqfw7vz9j56max5i0k1mklan6js7wy9w";

11606+ configureFlags = [

11607+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11608+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11609+ "-fsplitbase" "-f-test-hlint"

11610+ ];

11611+ isLibrary = true;

11612+ isExecutable = true;

11613+ libraryHaskellDepends = [

11614+ aeson base bytestring conduit containers monad-control monad-logger

11615+ persistent resourcet text transformers

11616+ ];

11617+ executableHaskellDepends = [ base ];

11618+ homepage = "http://www.yesodweb.com/book/persistent";

11619+ description = "Backend for the persistent library using sqlite3";

11620+ license = stdenv.lib.licenses.mit;

11621+ }) {};

11622+ "persistent-template" = callPackage

11623+ ({ mkDerivation, aeson, base, bytestring, containers, ghc-prim

11624+ , hspec, monad-control, monad-logger, path-pieces, persistent

11625+ , QuickCheck, tagged, template-haskell, text, transformers

11626+ , unordered-containers

11627+ }:

11628+ mkDerivation {

11629+ pname = "persistent-template";

11630+ version = "2.1";

11631+ sha256 = "0rj3yqm38kg7lvj9hi4c5yaypvxj6pwb47b0kg8h2hsa0rshhrdy";

11632+ configureFlags = [

11633+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11634+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11635+ "-fsplitbase" "-f-test-hlint"

11636+ ];

11637+ libraryHaskellDepends = [

11638+ aeson base bytestring containers ghc-prim monad-control

11639+ monad-logger path-pieces persistent tagged template-haskell text

11640+ transformers unordered-containers

11641+ ];

11642+ testHaskellDepends = [

11643+ aeson base bytestring hspec persistent QuickCheck text transformers

11644+ ];

11645+ homepage = "http://www.yesodweb.com/book/persistent";

11646+ description = "Type-safe, non-relational, multi-backend persistence";

11647+ license = stdenv.lib.licenses.mit;

11648+ }) {};

11649+ "phantom-state" = callPackage

11650+ ({ mkDerivation, base, criterion, transformers, vector }:

11651+ mkDerivation {

11652+ pname = "phantom-state";

11653+ version = "0.2.0.2";

11654+ sha256 = "04fg0j79nkajsiw8n2yy62mwiw1r4fjy2jln5ng07h64pwyncdnm";

11655+ configureFlags = [

11656+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11657+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11658+ "-fsplitbase" "-f-test-hlint"

11659+ ];

11660+ libraryHaskellDepends = [ base transformers ];

11661+ benchmarkHaskellDepends = [ base criterion transformers vector ];

11662+ description = "Phantom State Transformer. Like State Monad, but without values.";

11663+ license = stdenv.lib.licenses.bsd3;

11664+ }) {};

11665+ "pipes" = callPackage

11666+ ({ mkDerivation, base, criterion, deepseq, mmorph, mtl, QuickCheck

11667+ , test-framework, test-framework-quickcheck2, transformers

11668+ }:

11669+ mkDerivation {

11670+ pname = "pipes";

11671+ version = "4.1.4";

11672+ sha256 = "0bv7i18lf15mvfscnif4hkwgm4anw8b7bbqhzdw4wbjqcvrrsppb";

11673+ revision = "1";

11674+ editedCabalFile = "01c4ygz08srjcs3svg044hadj3rdi3vdyhgq8zaxdii8iy6yrhmq";

11675+ configureFlags = [

11676+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11677+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11678+ "-fsplitbase" "-f-test-hlint"

11679+ ];

11680+ libraryHaskellDepends = [ base mmorph mtl transformers ];

11681+ testHaskellDepends = [

11682+ base mtl QuickCheck test-framework test-framework-quickcheck2

11683+ transformers

11684+ ];

11685+ benchmarkHaskellDepends = [

11686+ base criterion deepseq mtl transformers

11687+ ];

11688+ description = "Compositional pipelines";

11689+ license = stdenv.lib.licenses.bsd3;

11690+ }) {};

11691+ "pipes-concurrency" = callPackage

11692+ ({ mkDerivation, async, base, pipes, stm }:

11693+ mkDerivation {

11694+ pname = "pipes-concurrency";

11695+ version = "2.0.2";

11696+ sha256 = "0g4fbh8dk8ph2ga0vyanqj52rxk9c1zi6g4yk3a1g6bnf4bklhm8";

11697+ configureFlags = [

11698+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11699+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11700+ "-fsplitbase" "-f-test-hlint"

11701+ ];

11702+ libraryHaskellDepends = [ base pipes stm ];

11703+ testHaskellDepends = [ async base pipes stm ];

11704+ description = "Concurrency for the pipes ecosystem";

11705+ license = stdenv.lib.licenses.bsd3;

11706+ }) {};

11707+ "pipes-parse" = callPackage

11708+ ({ mkDerivation, base, pipes, transformers }:

11709+ mkDerivation {

11710+ pname = "pipes-parse";

11711+ version = "3.0.2";

11712+ sha256 = "1d5lhh8knk0hmvd9wv2ihs5z9ybyvhd1n7qaazqkazqkyl14pd08";

11713+ configureFlags = [

11714+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11715+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11716+ "-fsplitbase" "-f-test-hlint"

11717+ ];

11718+ libraryHaskellDepends = [ base pipes transformers ];

11719+ description = "Parsing infrastructure for the pipes ecosystem";

11720+ license = stdenv.lib.licenses.bsd3;

11721+ }) {};

11722+ "placeholders" = callPackage

11723+ ({ mkDerivation, base, template-haskell }:

11724+ mkDerivation {

11725+ pname = "placeholders";

11726+ version = "0.1";

11727+ sha256 = "0ih35n2pw5gr9ggj2xz5zfcs4bdk200fdw6q9hdy3xna7maphak5";

11728+ configureFlags = [

11729+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11730+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11731+ "-fsplitbase" "-f-test-hlint"

11732+ ];

11733+ libraryHaskellDepends = [ base template-haskell ];

11734+ homepage = "http://github.com/ahammar/placeholders";

11735+ description = "Placeholders for use while developing Haskell code";

11736+ license = stdenv.lib.licenses.bsd3;

11737+ }) {};

11738+ "pointed" = callPackage

11739+ ({ mkDerivation, base, comonad, containers, data-default-class

11740+ , semigroupoids, semigroups, stm, tagged, transformers

11741+ }:

11742+ mkDerivation {

11743+ pname = "pointed";

11744+ version = "4.1";

11745+ sha256 = "1l40nl1sx16hbqz1kv70g6jp2igvvj93p5db8b6bsgjxx9ibck6g";

11746+ configureFlags = [

11747+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11748+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11749+ "-fsplitbase" "-f-test-hlint"

11750+ ];

11751+ libraryHaskellDepends = [

11752+ base comonad containers data-default-class semigroupoids semigroups

11753+ stm tagged transformers

11754+ ];

11755+ homepage = "http://github.com/ekmett/pointed/";

11756+ description = "Pointed and copointed data";

11757+ license = stdenv.lib.licenses.bsd3;

11758+ }) {};

11759+ "polyparse" = callPackage

11760+ ({ mkDerivation, base, bytestring, text }:

11761+ mkDerivation {

11762+ pname = "polyparse";

11763+ version = "1.9";

11764+ sha256 = "12khjhv1dvs4j1jyh3law7m1gmkad8s6q7clh7w6l5ll2n1dc4lz";

11765+ revision = "2";

11766+ editedCabalFile = "00ywnin9r8dharxn89950hv8b6w3v6v8564ii31qilwx6in0bb92";

11767+ configureFlags = [

11768+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11769+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11770+ "-fsplitbase" "-f-test-hlint"

11771+ ];

11772+ libraryHaskellDepends = [ base bytestring text ];

11773+ homepage = "http://code.haskell.org/~malcolm/polyparse/";

11774+ description = "A variety of alternative parser combinator libraries";

11775+ license = "LGPL";

11776+ }) {};

11777+ "pool-conduit" = callPackage

11778+ ({ mkDerivation, base, monad-control, resource-pool, resourcet

11779+ , transformers

11780+ }:

11781+ mkDerivation {

11782+ pname = "pool-conduit";

11783+ version = "0.1.2.3";

11784+ sha256 = "1myjbmbh0jm89ycx9d961mpgw8hp7al8wgnsls4p19gvr73gcbfv";

11785+ revision = "1";

11786+ editedCabalFile = "19dgfhd4392vc9b6v77siv21sz5wxxrq4gkm0l54m0mkah8gg55q";

11787+ configureFlags = [

11788+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11789+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11790+ "-fsplitbase" "-f-test-hlint"

11791+ ];

11792+ libraryHaskellDepends = [

11793+ base monad-control resource-pool resourcet transformers

11794+ ];

11795+ homepage = "http://www.yesodweb.com/book/persistent";

11796+ description = "Resource pool allocations via ResourceT. (deprecated)";

11797+ license = stdenv.lib.licenses.mit;

11798+ }) {};

11799+ "postgresql-binary" = callPackage

11800+ ({ mkDerivation, attoparsec, base, base-prelude, bytestring

11801+ , criterion, deepseq, HTF, loch-th, mtl-prelude, placeholders

11802+ , postgresql-libpq, QuickCheck, quickcheck-instances, scientific

11803+ , text, time, transformers, uuid

11804+ }:

11805+ mkDerivation {

11806+ pname = "postgresql-binary";

11807+ version = "0.5.0";

11808+ sha256 = "0n067ns0k86ibjy2sqzjjds761l608167lwjzgpp5jhicv1by6hs";

11809+ configureFlags = [

11810+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11811+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11812+ "-fsplitbase" "-f-test-hlint"

11813+ ];

11814+ libraryHaskellDepends = [

11815+ attoparsec base base-prelude bytestring loch-th placeholders

11816+ scientific text time transformers uuid

11817+ ];

11818+ testHaskellDepends = [

11819+ base base-prelude bytestring HTF postgresql-libpq QuickCheck

11820+ quickcheck-instances scientific text time uuid

11821+ ];

11822+ benchmarkHaskellDepends = [

11823+ base base-prelude bytestring criterion deepseq mtl-prelude

11824+ scientific text time

11825+ ];

11826+ doHaddock = false;

11827+ doCheck = false;

11828+ homepage = "https://github.com/nikita-volkov/postgresql-binary";

11829+ description = "Encoders and decoders for the PostgreSQL's binary format";

11830+ license = stdenv.lib.licenses.mit;

11831+ }) {};

11832+ "postgresql-libpq" = callPackage

11833+ ({ mkDerivation, base, bytestring, postgresql }:

11834+ mkDerivation {

11835+ pname = "postgresql-libpq";

11836+ version = "0.9.0.1";

11837+ sha256 = "0fdz9pkmrajqm026s6d5ib9kqg5ph93fw7l2xrgf22zagl53rzx3";

11838+ configureFlags = [

11839+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11840+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11841+ "-fsplitbase" "-f-test-hlint"

11842+ ];

11843+ libraryHaskellDepends = [ base bytestring ];

11844+ librarySystemDepends = [ postgresql ];

11845+ homepage = "http://github.com/lpsmith/postgresql-libpq";

11846+ description = "low-level binding to libpq";

11847+ license = stdenv.lib.licenses.bsd3;

11848+ }) {inherit (pkgs) postgresql;};

11849+ "postgresql-simple" = callPackage

11850+ ({ mkDerivation, aeson, attoparsec, base, base16-bytestring

11851+ , blaze-builder, blaze-textual, bytestring, case-insensitive

11852+ , containers, cryptohash, hashable, HUnit, postgresql-libpq

11853+ , scientific, template-haskell, text, time, transformers, uuid

11854+ , vector

11855+ }:

11856+ mkDerivation {

11857+ pname = "postgresql-simple";

11858+ version = "0.4.8.0";

11859+ sha256 = "09mflczxjm7a8nixi4a989nq1ijhpikl4j9kqvzcpmfgb8sx38nm";

11860+ configureFlags = [

11861+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11862+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11863+ "-fsplitbase" "-f-test-hlint"

11864+ ];

11865+ libraryHaskellDepends = [

11866+ aeson attoparsec base blaze-builder blaze-textual bytestring

11867+ case-insensitive containers hashable postgresql-libpq scientific

11868+ template-haskell text time transformers uuid vector

11869+ ];

11870+ testHaskellDepends = [

11871+ aeson base base16-bytestring bytestring containers cryptohash HUnit

11872+ text time vector

11873+ ];

11874+ doHaddock = false;

11875+ doCheck = false;

11876+ description = "Mid-Level PostgreSQL client library";

11877+ license = stdenv.lib.licenses.bsd3;

11878+ }) {};

11879+ "pqueue" = callPackage

11880+ ({ mkDerivation, base, deepseq }:

11881+ mkDerivation {

11882+ pname = "pqueue";

11883+ version = "1.2.1";

11884+ sha256 = "1fily60f4njby7zknmik7a2wxsm3y77ckr69w9bb3fgq22gbzky6";

11885+ revision = "1";

11886+ editedCabalFile = "18szw5gxjvws2ygg2g18mysabqh9hib0p4c9n5pb3f62i6my47ga";

11887+ configureFlags = [

11888+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11889+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11890+ "-fsplitbase" "-f-test-hlint"

11891+ ];

11892+ libraryHaskellDepends = [ base deepseq ];

11893+ description = "Reliable, persistent, fast priority queues";

11894+ license = stdenv.lib.licenses.bsd3;

11895+ }) {};

11896+ "prefix-units" = callPackage

11897+ ({ mkDerivation, base, Cabal, HUnit, QuickCheck, test-framework

11898+ , test-framework-hunit, test-framework-quickcheck2

11899+ }:

11900+ mkDerivation {

11901+ pname = "prefix-units";

11902+ version = "0.1.0.2";

11903+ sha256 = "07b5s2bsqlaad06dgr5psidfgi1nmgc5c16j6kzayw9f4najjrav";

11904+ revision = "1";

11905+ editedCabalFile = "02mh9m5yx7n25zl4vggjqckysphp60n2gic0m128wrsj7aannba9";

11906+ configureFlags = [

11907+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11908+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11909+ "-fsplitbase" "-f-test-hlint"

11910+ ];

11911+ libraryHaskellDepends = [ base ];

11912+ testHaskellDepends = [

11913+ base Cabal HUnit QuickCheck test-framework test-framework-hunit

11914+ test-framework-quickcheck2

11915+ ];

11916+ homepage = "https://github.com/iustin/prefix-units";

11917+ description = "A basic library for SI/binary prefix units";

11918+ license = stdenv.lib.licenses.bsd3;

11919+ }) {};

11920+ "prelude-extras" = callPackage

11921+ ({ mkDerivation, base }:

11922+ mkDerivation {

11923+ pname = "prelude-extras";

11924+ version = "0.4";

11925+ sha256 = "0mzsc9pzcamaa7i3g9hkajy35sbpqdjrflv6r98r8hhlr0yrdjan";

11926+ configureFlags = [

11927+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11928+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11929+ "-fsplitbase" "-f-test-hlint"

11930+ ];

11931+ libraryHaskellDepends = [ base ];

11932+ homepage = "http://github.com/ekmett/prelude-extras";

11933+ description = "Haskell 98 - higher order versions of Prelude classes";

11934+ license = stdenv.lib.licenses.bsd3;

11935+ }) {};

11936+ "present" = callPackage

11937+ ({ mkDerivation, aeson, atto-lisp, base, bytestring, data-default

11938+ , mtl, semigroups, text

11939+ }:

11940+ mkDerivation {

11941+ pname = "present";

11942+ version = "2.2";

11943+ sha256 = "1z9zvmszda7h1h4inq4b6ig9bd205mskqq85ns3rzsffxaj471p4";

11944+ revision = "1";

11945+ editedCabalFile = "1hb9symzrc8f447rgni8rndnka0qpcg4p7n4khd49qipdaxm3947";

11946+ configureFlags = [

11947+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11948+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11949+ "-fsplitbase" "-f-test-hlint"

11950+ ];

11951+ libraryHaskellDepends = [

11952+ aeson atto-lisp base bytestring data-default mtl semigroups text

11953+ ];

11954+ description = "Make presentations for data types";

11955+ license = stdenv.lib.licenses.bsd3;

11956+ }) {};

11957+ "pretty-class" = callPackage

11958+ ({ mkDerivation, base, pretty }:

11959+ mkDerivation {

11960+ pname = "pretty-class";

11961+ version = "1.0.1.1";

11962+ sha256 = "1qdfp2kpahzflq9a3idwmb0pqs4l7almxn5rbw5gp2pmdx81p3am";

11963+ configureFlags = [

11964+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11965+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11966+ "-fsplitbase" "-f-test-hlint"

11967+ ];

11968+ libraryHaskellDepends = [ base pretty ];

11969+ homepage = "https://github.com/ddssff/pretty-class";

11970+ description = "Pretty printing class similar to Show";

11971+ license = stdenv.lib.licenses.bsd3;

11972+ }) {};

11973+ "pretty-show" = callPackage

11974+ ({ mkDerivation, array, base, filepath, ghc-prim, happy

11975+ , haskell-lexer, pretty

11976+ }:

11977+ mkDerivation {

11978+ pname = "pretty-show";

11979+ version = "1.6.8";

11980+ sha256 = "0vfb712dvbb91659sch62d06vm0451b9l4l0hdwnlbhzjymmh2rs";

11981+ revision = "1";

11982+ editedCabalFile = "0s8w6dyrv53iy72md081c9rb4wcbxhangmm6gi61ibqax9mn5mvy";

11983+ configureFlags = [

11984+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11985+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11986+ "-fsplitbase" "-f-test-hlint"

11987+ ];

11988+ isLibrary = true;

11989+ isExecutable = true;

11990+ enableSeparateDataOutput = true;

11991+ libraryHaskellDepends = [

11992+ array base filepath ghc-prim haskell-lexer pretty

11993+ ];

11994+ libraryToolDepends = [ happy ];

11995+ executableHaskellDepends = [ base ];

11996+ homepage = "http://wiki.github.com/yav/pretty-show";

11997+ description = "Tools for working with derived `Show` instances and generic inspection of values";

11998+ license = stdenv.lib.licenses.bsd3;

11999+ }) {};

12000+ "prettyclass" = callPackage

12001+ ({ mkDerivation, base, pretty }:

12002+ mkDerivation {

12003+ pname = "prettyclass";

12004+ version = "1.0.0.0";

12005+ sha256 = "11l9ajci7nh1r547hx8hgxrhq8mh5gdq30pdf845wvilg9p48dz5";

12006+ configureFlags = [

12007+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12008+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12009+ "-fsplitbase" "-f-test-hlint"

12010+ ];

12011+ libraryHaskellDepends = [ base pretty ];

12012+ description = "Pretty printing class similar to Show";

12013+ license = stdenv.lib.licenses.bsd3;

12014+ }) {};

12015+ "primes" = callPackage

12016+ ({ mkDerivation, base }:

12017+ mkDerivation {

12018+ pname = "primes";

12019+ version = "0.2.1.0";

12020+ sha256 = "0ny6fzr967d1fifk050k95j9snnbjjif2bxf3v9s93k3zdc6bmkl";

12021+ configureFlags = [

12022+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12023+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12024+ "-fsplitbase" "-f-test-hlint"

12025+ ];

12026+ libraryHaskellDepends = [ base ];

12027+ homepage = "http://github.com/sebfisch/primes";

12028+ description = "Efficient, purely functional generation of prime numbers";

12029+ license = stdenv.lib.licenses.bsd3;

12030+ }) {};

12031+ "primitive" = callPackage

12032+ ({ mkDerivation, base, ghc-prim }:

12033+ mkDerivation {

12034+ pname = "primitive";

12035+ version = "0.5.4.0";

12036+ sha256 = "05gdgj383xdrdkhxh26imlvs8ji0z28ny38ms9snpvv5i8l2lg10";

12037+ revision = "1";

12038+ editedCabalFile = "17pgp8vyqhwg9fr7lvff9hjhn78v13g9hf0j09ma0qcc2sf142nz";

12039+ configureFlags = [

12040+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12041+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12042+ "-fsplitbase" "-f-test-hlint"

12043+ ];

12044+ libraryHaskellDepends = [ base ghc-prim ];

12045+ testHaskellDepends = [ base ghc-prim ];

12046+ homepage = "https://github.com/haskell/primitive";

12047+ description = "Primitive memory-related operations";

12048+ license = stdenv.lib.licenses.bsd3;

12049+ }) {};

12050+ "process-conduit" = callPackage

12051+ ({ mkDerivation, base, bytestring, conduit, conduit-extra

12052+ , control-monad-loop, hspec, mtl, process, resourcet, shakespeare

12053+ , shakespeare-text, template-haskell, text

12054+ }:

12055+ mkDerivation {

12056+ pname = "process-conduit";

12057+ version = "1.2.0.1";

12058+ sha256 = "0hnbywmjvk3y26sc9a0jfqzm04pg08zd2bflld1mvni02s89lvc8";

12059+ configureFlags = [

12060+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12061+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12062+ "-fsplitbase" "-f-test-hlint"

12063+ ];

12064+ libraryHaskellDepends = [

12065+ base bytestring conduit control-monad-loop mtl process resourcet

12066+ shakespeare shakespeare-text template-haskell text

12067+ ];

12068+ testHaskellDepends = [

12069+ base bytestring conduit conduit-extra hspec resourcet

12070+ ];

12071+ homepage = "http://github.com/snoyberg/process-conduit";

12072+ description = "Conduits for processes (deprecated)";

12073+ license = stdenv.lib.licenses.bsd3;

12074+ }) {};

12075+ "process-extras" = callPackage

12076+ ({ mkDerivation, base, bytestring, deepseq, process, text }:

12077+ mkDerivation {

12078+ pname = "process-extras";

12079+ version = "0.2.0";

12080+ sha256 = "0mr4f2v19qz6d6jhffz9gky0ykdqwl8c11adbdm04wm2a3xsvf7g";

12081+ configureFlags = [

12082+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12083+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12084+ "-fsplitbase" "-f-test-hlint"

12085+ ];

12086+ libraryHaskellDepends = [ base bytestring deepseq process text ];

12087+ homepage = "https://github.com/davidlazar/process-extras";

12088+ description = "Process extras";

12089+ license = stdenv.lib.licenses.mit;

12090+ }) {};

12091+ "profunctor-extras" = callPackage

12092+ ({ mkDerivation, base, profunctors }:

12093+ mkDerivation {

12094+ pname = "profunctor-extras";

12095+ version = "4.0";

12096+ sha256 = "10j458liqlyz5s9gkg95c6aq7ap5fa7d8pc7hygy71nn87pm2g4a";

12097+ configureFlags = [

12098+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12099+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12100+ "-fsplitbase" "-f-test-hlint"

12101+ ];

12102+ libraryHaskellDepends = [ base profunctors ];

12103+ doHaddock = false;

12104+ doCheck = false;

12105+ homepage = "http://github.com/ekmett/profunctor-extras/";

12106+ description = "This package has been absorbed into profunctors 4.0";

12107+ license = stdenv.lib.licenses.bsd3;

12108+ }) {};

12109+ "profunctors" = callPackage

12110+ ({ mkDerivation, base, comonad, distributive, semigroupoids, tagged

12111+ , transformers

12112+ }:

12113+ mkDerivation {

12114+ pname = "profunctors";

12115+ version = "4.3.2";

12116+ sha256 = "06dv9bjz2hsm32kzfqqm6z54197dfjm3wycnbbgl9pib711w484v";

12117+ revision = "2";

12118+ editedCabalFile = "0galplr91gxb3n8z5l3l6sbvlwkcxnlg1144m459h5qyngklww19";

12119+ configureFlags = [

12120+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12121+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12122+ "-fsplitbase" "-f-test-hlint"

12123+ ];

12124+ libraryHaskellDepends = [

12125+ base comonad distributive semigroupoids tagged transformers

12126+ ];

12127+ homepage = "http://github.com/ekmett/profunctors/";

12128+ description = "Profunctors";

12129+ license = stdenv.lib.licenses.bsd3;

12130+ }) {};

12131+ "project-template" = callPackage

12132+ ({ mkDerivation, base, base64-bytestring, bytestring, conduit

12133+ , conduit-extra, containers, hspec, mtl, QuickCheck, resourcet

12134+ , system-fileio, system-filepath, text, transformers

12135+ }:

12136+ mkDerivation {

12137+ pname = "project-template";

12138+ version = "0.1.4.2";

12139+ sha256 = "10n23s6g7fv0l42hsb804z0qqcyxqw32kwzg1f0w3c6gka844akr";

12140+ configureFlags = [

12141+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12142+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12143+ "-fsplitbase" "-f-test-hlint"

12144+ ];

12145+ libraryHaskellDepends = [

12146+ base base64-bytestring bytestring conduit conduit-extra containers

12147+ mtl resourcet system-fileio system-filepath text transformers

12148+ ];

12149+ testHaskellDepends = [

12150+ base base64-bytestring bytestring conduit containers hspec

12151+ QuickCheck resourcet system-filepath text transformers

12152+ ];

12153+ homepage = "https://github.com/fpco/haskell-ide";

12154+ description = "Specify Haskell project templates and generate files";

12155+ license = stdenv.lib.licenses.bsd3;

12156+ }) {};

12157+ "publicsuffixlist" = callPackage

12158+ ({ mkDerivation, base, bytestring, cereal, containers, data-default

12159+ , HUnit, idna, text, utf8-string

12160+ }:

12161+ mkDerivation {

12162+ pname = "publicsuffixlist";

12163+ version = "0.1";

12164+ sha256 = "0mbrmhgyjp8jms3fd3nq4knc4j97sw8ijrmnlfjs7qj8jw4vwzxk";

12165+ configureFlags = [

12166+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12167+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12168+ "-fsplitbase" "-f-test-hlint"

12169+ ];

12170+ libraryHaskellDepends = [

12171+ base bytestring cereal containers data-default text utf8-string

12172+ ];

12173+ testHaskellDepends = [

12174+ base bytestring cereal containers data-default HUnit idna text

12175+ utf8-string

12176+ ];

12177+ homepage = "https://github.com/litherum/publicsuffixlist";

12178+ description = "Is a given string a domain suffix?";

12179+ license = stdenv.lib.licenses.bsd3;

12180+ }) {};

12181+ "punycode" = callPackage

12182+ ({ mkDerivation, base, bytestring, cereal, mtl, text }:

12183+ mkDerivation {

12184+ pname = "punycode";

12185+ version = "2.0";

12186+ sha256 = "192jgfixnpxdj6jiiz92kx5bi6ij3c389b76q9f4vyfmvcajj1sr";

12187+ configureFlags = [

12188+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12189+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12190+ "-fsplitbase" "-f-test-hlint"

12191+ ];

12192+ libraryHaskellDepends = [ base bytestring cereal mtl text ];

12193+ doHaddock = false;

12194+ doCheck = false;

12195+ homepage = "https://github.com/litherum/punycode";

12196+ description = "Encode unicode strings to ascii forms according to RFC 3492";

12197+ license = stdenv.lib.licenses.bsd3;

12198+ }) {};

12199+ "pure-io" = callPackage

12200+ ({ mkDerivation, base, containers, mtl, safe }:

12201+ mkDerivation {

12202+ pname = "pure-io";

12203+ version = "0.2.1";

12204+ sha256 = "0pzvkd8jxw859s187n972yaq5wmwi00cxwhivgffr7z29hr0zvx9";

12205+ configureFlags = [

12206+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12207+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12208+ "-fsplitbase" "-f-test-hlint"

12209+ ];

12210+ libraryHaskellDepends = [ base containers mtl safe ];

12211+ description = "Pure IO monad";

12212+ license = stdenv.lib.licenses.bsd3;

12213+ }) {};

12214+ "pureMD5" = callPackage

12215+ ({ mkDerivation, base, binary, bytestring, cereal, crypto-api

12216+ , tagged

12217+ }:

12218+ mkDerivation {

12219+ pname = "pureMD5";

12220+ version = "2.1.2.1";

12221+ sha256 = "1zsn949qk95bwx1fbyv84q0lhb4k18bgixl7nivfzsnmhr31fs37";

12222+ configureFlags = [

12223+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12224+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12225+ "-fsplitbase" "-f-test-hlint"

12226+ ];

12227+ libraryHaskellDepends = [

12228+ base binary bytestring cereal crypto-api tagged

12229+ ];

12230+ description = "A Haskell-only implementation of the MD5 digest (hash) algorithm";

12231+ license = stdenv.lib.licenses.bsd3;

12232+ }) {};

12233+ "pwstore-fast" = callPackage

12234+ ({ mkDerivation, base, base64-bytestring, binary, byteable

12235+ , bytestring, cryptohash, random

12236+ }:

12237+ mkDerivation {

12238+ pname = "pwstore-fast";

12239+ version = "2.4.4";

12240+ sha256 = "1cpvlwzg3qznhygrr78f75p65mnljd9v5cvnagfxjqppnrkay6bj";

12241+ configureFlags = [

12242+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12243+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12244+ "-fsplitbase" "-f-test-hlint"

12245+ ];

12246+ libraryHaskellDepends = [

12247+ base base64-bytestring binary byteable bytestring cryptohash random

12248+ ];

12249+ homepage = "https://github.com/PeterScott/pwstore";

12250+ description = "Secure password storage";

12251+ license = stdenv.lib.licenses.bsd3;

12252+ }) {};

12253+ "quandl-api" = callPackage

12254+ ({ mkDerivation, aeson, base, blaze-builder, bytestring

12255+ , http-conduit, http-types, old-locale, syb, text, time

12256+ , unordered-containers

12257+ }:

12258+ mkDerivation {

12259+ pname = "quandl-api";

12260+ version = "0.2.0.0";

12261+ sha256 = "1h6gh9wssb8dw9r5f7caanxq542d0jw9shvp7wx0i1k47f54kb3k";

12262+ configureFlags = [

12263+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12264+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12265+ "-fsplitbase" "-f-test-hlint"

12266+ ];

12267+ libraryHaskellDepends = [

12268+ aeson base blaze-builder bytestring http-conduit http-types

12269+ old-locale syb text time unordered-containers

12270+ ];

12271+ homepage = "https://github.com/pvdbrand/quandl-api";

12272+ description = "Quandl.com API library";

12273+ license = stdenv.lib.licenses.bsd3;

12274+ }) {};

12275+ "quickcheck-assertions" = callPackage

12276+ ({ mkDerivation, base, hspec, ieee754, QuickCheck }:

12277+ mkDerivation {

12278+ pname = "quickcheck-assertions";

12279+ version = "0.1.1";

12280+ sha256 = "0hrnr17wafng7nc6d8w6pp1lygplri8xkb5380aq64zg9iik2s21";

12281+ configureFlags = [

12282+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12283+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12284+ "-fsplitbase" "-f-test-hlint"

12285+ ];

12286+ libraryHaskellDepends = [ base ieee754 QuickCheck ];

12287+ testHaskellDepends = [ base hspec ieee754 QuickCheck ];

12288+ homepage = "https://github.com/s9gf4ult/quickcheck-assertions";

12289+ description = "HUnit like assertions for QuickCheck";

12290+ license = stdenv.lib.licenses.lgpl3;

12291+ }) {};

12292+ "quickcheck-instances" = callPackage

12293+ ({ mkDerivation, array, base, bytestring, containers, hashable

12294+ , old-time, QuickCheck, text, time, unordered-containers

12295+ }:

12296+ mkDerivation {

12297+ pname = "quickcheck-instances";

12298+ version = "0.3.9";

12299+ sha256 = "1a0mbd1kga4qnamp80x2g4avjwcy8z0zrriqxdhb1525wyyb0656";

12300+ configureFlags = [

12301+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12302+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12303+ "-fsplitbase" "-f-test-hlint"

12304+ ];

12305+ libraryHaskellDepends = [

12306+ array base bytestring containers hashable old-time QuickCheck text

12307+ time unordered-containers

12308+ ];

12309+ homepage = "https://github.com/aslatter/qc-instances";

12310+ description = "Common quickcheck instances";

12311+ license = stdenv.lib.licenses.bsd3;

12312+ }) {};

12313+ "quickcheck-io" = callPackage

12314+ ({ mkDerivation, base, HUnit, QuickCheck }:

12315+ mkDerivation {

12316+ pname = "quickcheck-io";

12317+ version = "0.1.1";

12318+ sha256 = "16q3sqvxnaqmbb1zbda8f61mdlmmzxhrznqxab113lmg380nwfm2";

12319+ revision = "2";

12320+ editedCabalFile = "02c482j3h72qyc58xgwc7iwwh7wgxi3liqbc8gk9nb9sxciikd9j";

12321+ configureFlags = [

12322+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12323+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12324+ "-fsplitbase" "-f-test-hlint"

12325+ ];

12326+ libraryHaskellDepends = [ base HUnit QuickCheck ];

12327+ description = "Use HUnit assertions as QuickCheck properties";

12328+ license = stdenv.lib.licenses.mit;

12329+ }) {};

12330+ "quickpull" = callPackage

12331+ ({ mkDerivation, barecheck, base, directory, filepath, QuickCheck

12332+ }:

12333+ mkDerivation {

12334+ pname = "quickpull";

12335+ version = "0.4.0.0";

12336+ sha256 = "0qfzl7v7724fwfsxd5iwj3xbfz3isl8hphv6fd5a0c5zw01r54zn";

12337+ configureFlags = [

12338+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12339+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12340+ "-fsplitbase" "-f-test-hlint"

12341+ ];

12342+ isLibrary = true;

12343+ isExecutable = true;

12344+ libraryHaskellDepends = [ base directory filepath QuickCheck ];

12345+ executableHaskellDepends = [

12346+ barecheck base directory filepath QuickCheck

12347+ ];

12348+ testHaskellDepends = [ base directory filepath QuickCheck ];

12349+ homepage = "http://www.github.com/massysett/quickpull";

12350+ description = "Generate Main module with QuickCheck tests";

12351+ license = stdenv.lib.licenses.bsd3;

12352+ }) {};

12353+ "rainbow" = callPackage

12354+ ({ mkDerivation, base, terminfo, text }:

12355+ mkDerivation {

12356+ pname = "rainbow";

12357+ version = "0.20.0.4";

12358+ sha256 = "0myipv34pfyi71h1ni9hdi1662whjnl83g9jpag77a00sk0p3rkm";

12359+ configureFlags = [

12360+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12361+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12362+ "-fsplitbase" "-f-test-hlint"

12363+ ];

12364+ libraryHaskellDepends = [ base terminfo text ];

12365+ homepage = "http://www.github.com/massysett/rainbow";

12366+ description = "Print text to terminal with colors and effects";

12367+ license = stdenv.lib.licenses.bsd3;

12368+ }) {};

12369+ "rainbow-tests" = callPackage

12370+ ({ mkDerivation, barecheck, base, QuickCheck, rainbow, terminfo

12371+ , text

12372+ }:

12373+ mkDerivation {

12374+ pname = "rainbow-tests";

12375+ version = "0.20.0.4";

12376+ sha256 = "0cjq2m2zpk4j2f7gw65yqqvyc4kng1rsnq48fs4xcs6bdzw0zhlg";

12377+ configureFlags = [

12378+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12379+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12380+ "-fsplitbase" "-f-test-hlint"

12381+ ];

12382+ libraryHaskellDepends = [

12383+ barecheck base QuickCheck rainbow terminfo text

12384+ ];

12385+ homepage = "http://www.github.com/massysett/rainbow";

12386+ description = "Tests and QuickCheck generators to accompany rainbow";

12387+ license = stdenv.lib.licenses.bsd3;

12388+ }) {};

12389+ "random" = callPackage

12390+ ({ mkDerivation, base, time }:

12391+ mkDerivation {

12392+ pname = "random";

12393+ version = "1.0.1.1";

12394+ sha256 = "0n8m2744gg233s357vqzq3mfhhnbhynqvp4gxsi2gb70bm03nz6z";

12395+ configureFlags = [

12396+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12397+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12398+ "-fsplitbase" "-f-test-hlint"

12399+ ];

12400+ libraryHaskellDepends = [ base time ];

12401+ description = "random number library";

12402+ license = stdenv.lib.licenses.bsd3;

12403+ }) {};

12404+ "random-fu" = callPackage

12405+ ({ mkDerivation, base, erf, logfloat, math-functions, monad-loops

12406+ , mtl, random-shuffle, random-source, rvar, syb, template-haskell

12407+ , transformers, vector

12408+ }:

12409+ mkDerivation {

12410+ pname = "random-fu";

12411+ version = "0.2.6.1";

12412+ sha256 = "04fi92szpjyg0ffgxfayz00vpiqi67hzyahhin12wvw3pxbyyp9g";

12413+ configureFlags = [

12414+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12415+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12416+ "-fsplitbase" "-f-test-hlint"

12417+ ];

12418+ libraryHaskellDepends = [

12419+ base erf logfloat math-functions monad-loops mtl random-shuffle

12420+ random-source rvar syb template-haskell transformers vector

12421+ ];

12422+ homepage = "https://github.com/mokus0/random-fu";

12423+ description = "Random number generation";

12424+ license = stdenv.lib.licenses.publicDomain;

12425+ }) {};

12426+ "random-shuffle" = callPackage

12427+ ({ mkDerivation, base, MonadRandom, random }:

12428+ mkDerivation {

12429+ pname = "random-shuffle";

12430+ version = "0.0.4";

12431+ sha256 = "0586bnlh0g2isc44jbjvafkcl4yw6lp1db8x6vr0pza0y08l8w2j";

12432+ configureFlags = [

12433+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12434+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12435+ "-fsplitbase" "-f-test-hlint"

12436+ ];

12437+ libraryHaskellDepends = [ base MonadRandom random ];

12438+ description = "Random shuffle implementation";

12439+ license = stdenv.lib.licenses.bsd3;

12440+ }) {};

12441+ "random-source" = callPackage

12442+ ({ mkDerivation, base, flexible-defaults, mersenne-random-pure64

12443+ , mtl, mwc-random, random, stateref, syb, template-haskell

12444+ , th-extras

12445+ }:

12446+ mkDerivation {

12447+ pname = "random-source";

12448+ version = "0.3.0.6";

12449+ sha256 = "0wsv41kpswqml04ym5bq2nan4i637f7h3fmvda2zy506xwxfrpzk";

12450+ configureFlags = [

12451+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12452+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12453+ "-fsplitbase" "-f-test-hlint"

12454+ ];

12455+ libraryHaskellDepends = [

12456+ base flexible-defaults mersenne-random-pure64 mtl mwc-random random

12457+ stateref syb template-haskell th-extras

12458+ ];

12459+ homepage = "https://github.com/mokus0/random-fu";

12460+ description = "Generic basis for random number generators";

12461+ license = stdenv.lib.licenses.publicDomain;

12462+ }) {};

12463+ "rank1dynamic" = callPackage

12464+ ({ mkDerivation, base, binary, constraints, ghc-prim, HUnit

12465+ , test-framework, test-framework-hunit

12466+ }:

12467+ mkDerivation {

12468+ pname = "rank1dynamic";

12469+ version = "0.2.0.1";

12470+ sha256 = "1np3ghp7wdn0clsyslk5j6fhs4c5cd6y0xlvdg2jj6ydaglzcchl";

12471+ configureFlags = [

12472+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12473+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12474+ "-fsplitbase" "-f-test-hlint"

12475+ ];

12476+ libraryHaskellDepends = [ base binary ghc-prim ];

12477+ testHaskellDepends = [

12478+ base constraints HUnit test-framework test-framework-hunit

12479+ ];

12480+ homepage = "http://haskell-distributed.github.com";

12481+ description = "Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types";

12482+ license = stdenv.lib.licenses.bsd3;

12483+ }) {};

12484+ "reducers" = callPackage

12485+ ({ mkDerivation, array, base, bytestring, comonad, containers

12486+ , fingertree, hashable, keys, pointed, semigroupoids, semigroups

12487+ , text, transformers, unordered-containers

12488+ }:

12489+ mkDerivation {

12490+ pname = "reducers";

12491+ version = "3.10.3";

12492+ sha256 = "0hi77mgc2f38y0xfykn7x6gdl6xg710skpx4z76s8c0wwnd28pr6";

12493+ revision = "2";

12494+ editedCabalFile = "17dljgfkd72lbpx256z5s1rk1dy8vzglp17gwpd9iql67ph9ir8i";

12495+ configureFlags = [

12496+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12497+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12498+ "-fsplitbase" "-f-test-hlint"

12499+ ];

12500+ libraryHaskellDepends = [

12501+ array base bytestring comonad containers fingertree hashable keys

12502+ pointed semigroupoids semigroups text transformers

12503+ unordered-containers

12504+ ];

12505+ homepage = "http://github.com/ekmett/reducers/";

12506+ description = "Semigroups, specialized containers and a general map/reduce framework";

12507+ license = stdenv.lib.licenses.bsd3;

12508+ }) {};

12509+ "reflection" = callPackage

12510+ ({ mkDerivation, base, template-haskell }:

12511+ mkDerivation {

12512+ pname = "reflection";

12513+ version = "1.5.1";

12514+ sha256 = "18ail6j7rs5jff9zxphxd7vjkwanpv12dhi98s86r65425fdhjlx";

12515+ configureFlags = [

12516+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12517+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12518+ "-fsplitbase" "-f-test-hlint"

12519+ ];

12520+ libraryHaskellDepends = [ base template-haskell ];

12521+ homepage = "http://github.com/ekmett/reflection";

12522+ description = "Reifies arbitrary terms into types that can be reflected back into terms";

12523+ license = stdenv.lib.licenses.bsd3;

12524+ }) {};

12525+ "regex-applicative" = callPackage

12526+ ({ mkDerivation, base, containers, smallcheck, tasty, tasty-hunit

12527+ , tasty-smallcheck, transformers

12528+ }:

12529+ mkDerivation {

12530+ pname = "regex-applicative";

12531+ version = "0.3.0.3";

12532+ sha256 = "111j6x1j7bx5viz2hmgyvcdwfrv5x3f9mifx888hyd3hz850wpwc";

12533+ configureFlags = [

12534+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12535+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12536+ "-fsplitbase" "-f-test-hlint"

12537+ ];

12538+ libraryHaskellDepends = [ base containers transformers ];

12539+ testHaskellDepends = [

12540+ base containers smallcheck tasty tasty-hunit tasty-smallcheck

12541+ transformers

12542+ ];

12543+ homepage = "https://github.com/feuerbach/regex-applicative";

12544+ description = "Regex-based parsing with applicative interface";

12545+ license = stdenv.lib.licenses.mit;

12546+ }) {};

12547+ "regex-base" = callPackage

12548+ ({ mkDerivation, array, base, bytestring, containers, mtl }:

12549+ mkDerivation {

12550+ pname = "regex-base";

12551+ version = "0.93.2";

12552+ sha256 = "0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10";

12553+ configureFlags = [

12554+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12555+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12556+ "-fsplitbase" "-f-test-hlint"

12557+ ];

12558+ libraryHaskellDepends = [ array base bytestring containers mtl ];

12559+ homepage = "http://sourceforge.net/projects/lazy-regex";

12560+ description = "Replaces/Enhances Text.Regex";

12561+ license = stdenv.lib.licenses.bsd3;

12562+ }) {};

12563+ "regex-compat" = callPackage

12564+ ({ mkDerivation, array, base, regex-base, regex-posix }:

12565+ mkDerivation {

12566+ pname = "regex-compat";

12567+ version = "0.95.1";

12568+ sha256 = "0fwmima3f04p9y4h3c23493n1xj629ia2dxaisqm6rynljjv2z6m";

12569+ configureFlags = [

12570+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12571+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12572+ "-fsplitbase" "-f-test-hlint"

12573+ ];

12574+ libraryHaskellDepends = [ array base regex-base regex-posix ];

12575+ homepage = "http://sourceforge.net/projects/lazy-regex";

12576+ description = "Replaces/Enhances Text.Regex";

12577+ license = stdenv.lib.licenses.bsd3;

12578+ }) {};

12579+ "regex-pcre-builtin" = callPackage

12580+ ({ mkDerivation, array, base, bytestring, containers, regex-base }:

12581+ mkDerivation {

12582+ pname = "regex-pcre-builtin";

12583+ version = "0.94.4.8.8.35";

12584+ sha256 = "0y7as9wqlkykpipka2cfdhmcnin345q01pp0wsva8fwmvsavdl8b";

12585+ configureFlags = [

12586+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12587+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12588+ "-fsplitbase" "-f-test-hlint"

12589+ ];

12590+ libraryHaskellDepends = [

12591+ array base bytestring containers regex-base

12592+ ];

12593+ homepage = "http://hackage.haskell.org/package/regex-pcre";

12594+ description = "Replaces/Enhances Text.Regex";

12595+ license = stdenv.lib.licenses.bsd3;

12596+ }) {};

12597+ "regex-posix" = callPackage

12598+ ({ mkDerivation, array, base, bytestring, containers, regex-base }:

12599+ mkDerivation {

12600+ pname = "regex-posix";

12601+ version = "0.95.2";

12602+ sha256 = "0gkhzhj8nvfn1ija31c7xnl6p0gadwii9ihyp219ck2arlhrj0an";

12603+ configureFlags = [

12604+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12605+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12606+ "-fsplitbase" "-f-test-hlint"

12607+ ];

12608+ libraryHaskellDepends = [

12609+ array base bytestring containers regex-base

12610+ ];

12611+ homepage = "http://sourceforge.net/projects/lazy-regex";

12612+ description = "Replaces/Enhances Text.Regex";

12613+ license = stdenv.lib.licenses.bsd3;

12614+ }) {};

12615+ "regex-tdfa" = callPackage

12616+ ({ mkDerivation, array, base, bytestring, containers, ghc-prim, mtl

12617+ , parsec, regex-base

12618+ }:

12619+ mkDerivation {

12620+ pname = "regex-tdfa";

12621+ version = "1.2.0";

12622+ sha256 = "00gl9sx3hzd83lp38jlcj7wvzrda8kww7njwlm1way73m8aar0pw";

12623+ revision = "1";

12624+ editedCabalFile = "13j7a3xkaq0qb4y25i9l8a8lyaqfpc0dakqkwlg1i3hfkydvd2al";

12625+ configureFlags = [

12626+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12627+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12628+ "-fsplitbase" "-f-test-hlint"

12629+ ];

12630+ libraryHaskellDepends = [

12631+ array base bytestring containers ghc-prim mtl parsec regex-base

12632+ ];

12633+ homepage = "http://hackage.haskell.org/package/regex-tdfa";

12634+ description = "Replaces/Enhances Text.Regex";

12635+ license = stdenv.lib.licenses.bsd3;

12636+ }) {};

12637+ "regex-tdfa-rc" = callPackage

12638+ ({ mkDerivation, array, base, bytestring, containers, ghc-prim, mtl

12639+ , parsec, regex-base

12640+ }:

12641+ mkDerivation {

12642+ pname = "regex-tdfa-rc";

12643+ version = "1.1.8.3";

12644+ sha256 = "1vi11i23gkkjg6193ak90g55akj69bhahy542frkwb68haky4pp3";

12645+ configureFlags = [

12646+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12647+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12648+ "-fsplitbase" "-f-test-hlint"

12649+ ];

12650+ libraryHaskellDepends = [

12651+ array base bytestring containers ghc-prim mtl parsec regex-base

12652+ ];

12653+ homepage = "http://hackage.haskell.org/package/regex-tdfa";

12654+ description = "Replaces/Enhances Text.Regex";

12655+ license = stdenv.lib.licenses.bsd3;

12656+ }) {};

12657+ "regexpr" = callPackage

12658+ ({ mkDerivation, base, HUnit, mtl, mtlparse }:

12659+ mkDerivation {

12660+ pname = "regexpr";

12661+ version = "0.5.4";

12662+ sha256 = "0136wp6hrnmj6pbdhp3a131dzz8bp1pbd92bpagpv1r6gwj16y5z";

12663+ configureFlags = [

12664+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12665+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12666+ "-fsplitbase" "-f-test-hlint"

12667+ ];

12668+ libraryHaskellDepends = [ base HUnit mtl mtlparse ];

12669+ homepage = "http://homepage3.nifty.com/salamander/second/projects/regexpr/";

12670+ description = "regular expression like Perl/Ruby in Haskell";

12671+ license = "LGPL";

12672+ }) {};

12673+ "regular" = callPackage

12674+ ({ mkDerivation, base, template-haskell }:

12675+ mkDerivation {

12676+ pname = "regular";

12677+ version = "0.3.4.3";

12678+ sha256 = "12pc58agqb4fi0riwxjf0kykn1z12273q8dcdd0fh2x1ddxwgg2r";

12679+ configureFlags = [

12680+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12681+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12682+ "-fsplitbase" "-f-test-hlint"

12683+ ];

12684+ libraryHaskellDepends = [ base template-haskell ];

12685+ description = "Generic programming library for regular datatypes";

12686+ license = stdenv.lib.licenses.bsd3;

12687+ }) {};

12688+ "regular-xmlpickler" = callPackage

12689+ ({ mkDerivation, base, hxt, regular, text }:

12690+ mkDerivation {

12691+ pname = "regular-xmlpickler";

12692+ version = "0.2";

12693+ sha256 = "1qjx4xsidnpr2as3m2ir97ap5vc9cw6a0z332g53ifx9gskjli9f";

12694+ configureFlags = [

12695+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12696+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12697+ "-fsplitbase" "-f-test-hlint"

12698+ ];

12699+ libraryHaskellDepends = [ base hxt regular text ];

12700+ homepage = "http://github.com/silkapp/regular-xmlpickler";

12701+ description = "Generic generation of HXT XmlPickler instances using Regular";

12702+ license = stdenv.lib.licenses.bsd3;

12703+ }) {};

12704+ "repa" = callPackage

12705+ ({ mkDerivation, base, bytestring, ghc-prim, QuickCheck

12706+ , template-haskell, vector

12707+ }:

12708+ mkDerivation {

12709+ pname = "repa";

12710+ version = "3.3.1.2";

12711+ sha256 = "0rsahd6c1mxd8hq9zfx4jqgmcfs4di4askky87y71xy5v4k1x4ai";

12712+ configureFlags = [

12713+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12714+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12715+ "-fsplitbase" "-f-test-hlint"

12716+ ];

12717+ libraryHaskellDepends = [

12718+ base bytestring ghc-prim QuickCheck template-haskell vector

12719+ ];

12720+ homepage = "http://repa.ouroborus.net";

12721+ description = "High performance, regular, shape polymorphic parallel arrays";

12722+ license = stdenv.lib.licenses.bsd3;

12723+ }) {};

12724+ "repa-algorithms" = callPackage

12725+ ({ mkDerivation, base, repa, vector }:

12726+ mkDerivation {

12727+ pname = "repa-algorithms";

12728+ version = "3.3.1.2";

12729+ sha256 = "12fizvma877ws3xiz3k34jg5xh5yhnl0n5aq2za005l9i5angkk9";

12730+ configureFlags = [

12731+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12732+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12733+ "-fsplitbase" "-f-test-hlint"

12734+ ];

12735+ libraryHaskellDepends = [ base repa vector ];

12736+ homepage = "http://repa.ouroborus.net";

12737+ description = "Algorithms using the Repa array library";

12738+ license = stdenv.lib.licenses.bsd3;

12739+ }) {};

12740+ "repa-devil" = callPackage

12741+ ({ mkDerivation, base, libdevil, repa, transformers }:

12742+ mkDerivation {

12743+ pname = "repa-devil";

12744+ version = "0.3.2.2";

12745+ sha256 = "0p46ni9z8wymyk4qmcy04kwycxb31yyprd8ddxsxpjilhbw848lh";

12746+ configureFlags = [

12747+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12748+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12749+ "-fsplitbase" "-f-test-hlint"

12750+ ];

12751+ libraryHaskellDepends = [ base repa transformers ];

12752+ librarySystemDepends = [ libdevil ];

12753+ homepage = "https://github.com/RaphaelJ/repa-devil";

12754+ description = "Support for image reading and writing of Repa arrays using in-place FFI calls";

12755+ license = stdenv.lib.licenses.bsd3;

12756+ }) {inherit (pkgs) libdevil;};

12757+ "repa-io" = callPackage

12758+ ({ mkDerivation, base, binary, bmp, bytestring, old-time, repa

12759+ , vector

12760+ }:

12761+ mkDerivation {

12762+ pname = "repa-io";

12763+ version = "3.3.1.2";

12764+ sha256 = "1i58ysk44y7s6z1jmns2fi83flqma4k5nsjh1pblqb2rgl7x0z5p";

12765+ configureFlags = [

12766+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12767+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12768+ "-fsplitbase" "-f-test-hlint"

12769+ ];

12770+ libraryHaskellDepends = [

12771+ base binary bmp bytestring old-time repa vector

12772+ ];

12773+ homepage = "http://repa.ouroborus.net";

12774+ description = "Read and write Repa arrays in various formats";

12775+ license = stdenv.lib.licenses.bsd3;

12776+ }) {};

12777+ "reroute" = callPackage

12778+ ({ mkDerivation, base, criterion, deepseq, graph-core, hashable

12779+ , hspec, mtl, path-pieces, random, regex-compat, text, transformers

12780+ , unordered-containers, vector

12781+ }:

12782+ mkDerivation {

12783+ pname = "reroute";

12784+ version = "0.2.2.1";

12785+ sha256 = "1hrzbjvsdkz3c27lksxzxlhhdrwqbvq90xyawwsc8zh3fp1nzqpn";

12786+ configureFlags = [

12787+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12788+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12789+ "-fsplitbase" "-f-test-hlint"

12790+ ];

12791+ libraryHaskellDepends = [

12792+ base deepseq graph-core hashable mtl path-pieces regex-compat text

12793+ transformers unordered-containers vector

12794+ ];

12795+ testHaskellDepends = [

12796+ base hspec mtl text unordered-containers vector

12797+ ];

12798+ benchmarkHaskellDepends = [

12799+ base criterion deepseq graph-core hashable mtl path-pieces random

12800+ regex-compat text unordered-containers vector

12801+ ];

12802+ homepage = "http://github.com/agrafix/reroute";

12803+ description = "abstract implementation of typed and untyped web routing";

12804+ license = stdenv.lib.licenses.mit;

12805+ }) {};

12806+ "resource-pool" = callPackage

12807+ ({ mkDerivation, base, hashable, monad-control, stm, time

12808+ , transformers, transformers-base, vector

12809+ }:

12810+ mkDerivation {

12811+ pname = "resource-pool";

12812+ version = "0.2.3.1";

12813+ sha256 = "02fpw5jfzcdhijx8mfpb6j4c8sxl36f04i2nx3cbivh9yhbgqr92";

12814+ revision = "1";

12815+ editedCabalFile = "0vdrfhxral0w33n1vpv2qqzji1xsnd379872qs7ig0590n8srj38";

12816+ configureFlags = [

12817+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12818+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12819+ "-fsplitbase" "-f-test-hlint"

12820+ ];

12821+ libraryHaskellDepends = [

12822+ base hashable monad-control stm time transformers transformers-base

12823+ vector

12824+ ];

12825+ homepage = "http://github.com/bos/pool";

12826+ description = "A high-performance striped resource pooling implementation";

12827+ license = stdenv.lib.licenses.bsd3;

12828+ }) {};

12829+ "resourcet" = callPackage

12830+ ({ mkDerivation, base, containers, exceptions, hspec, lifted-base

12831+ , mmorph, monad-control, mtl, transformers, transformers-base

12832+ }:

12833+ mkDerivation {

12834+ pname = "resourcet";

12835+ version = "1.1.3.1";

12836+ sha256 = "13g8vj9hc59q8n696j0w79k5bhp3mgs923y4d2cffnd0p7yd8r8x";

12837+ revision = "1";

12838+ editedCabalFile = "01h9hqps2bs99qhlvff2z3r6w2az6i8wi0ffbrhggdl8nf1qs891";

12839+ configureFlags = [

12840+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12841+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12842+ "-fsplitbase" "-f-test-hlint"

12843+ ];

12844+ libraryHaskellDepends = [

12845+ base containers exceptions lifted-base mmorph monad-control mtl

12846+ transformers transformers-base

12847+ ];

12848+ testHaskellDepends = [ base hspec lifted-base transformers ];

12849+ homepage = "http://github.com/snoyberg/conduit";

12850+ description = "Deterministic allocation and freeing of scarce resources";

12851+ license = stdenv.lib.licenses.bsd3;

12852+ }) {};

12853+ "rest-client" = callPackage

12854+ ({ mkDerivation, aeson-utils, base, bytestring, case-insensitive

12855+ , data-default, exception-transformers, http-conduit, http-types

12856+ , hxt, hxt-pickle-utils, monad-control, mtl, primitive, resourcet

12857+ , rest-types, tostring, transformers-base, uri-encode, utf8-string

12858+ }:

12859+ mkDerivation {

12860+ pname = "rest-client";

12861+ version = "0.4.0.1";

12862+ sha256 = "1bn2kgyr6q0wxlp3kman20wn7jgz5dc6m8rq5xf0mknpbh8rrnpc";

12863+ configureFlags = [

12864+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12865+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12866+ "-fsplitbase" "-f-test-hlint"

12867+ ];

12868+ libraryHaskellDepends = [

12869+ aeson-utils base bytestring case-insensitive data-default

12870+ exception-transformers http-conduit http-types hxt hxt-pickle-utils

12871+ monad-control mtl primitive resourcet rest-types tostring

12872+ transformers-base uri-encode utf8-string

12873+ ];

12874+ description = "Utility library for use in generated API client libraries";

12875+ license = stdenv.lib.licenses.bsd3;

12876+ }) {};

12877+ "rest-core" = callPackage

12878+ ({ mkDerivation, aeson, aeson-utils, base, bytestring, either

12879+ , errors, fclabels, HUnit, hxt, hxt-pickle-utils, json-schema, mtl

12880+ , multipart, random, rest-stringmap, rest-types, safe, split

12881+ , test-framework, test-framework-hunit, text, transformers

12882+ , unordered-containers, uri-encode, utf8-string, uuid

12883+ }:

12884+ mkDerivation {

12885+ pname = "rest-core";

12886+ version = "0.33.1.2";

12887+ sha256 = "0axl6d28agyzklrnl264413a8hpfi7ih296i453r6fg4c63ma5h4";

12888+ configureFlags = [

12889+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12890+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12891+ "-fsplitbase" "-f-test-hlint"

12892+ ];

12893+ libraryHaskellDepends = [

12894+ aeson aeson-utils base bytestring either errors fclabels hxt

12895+ hxt-pickle-utils json-schema mtl multipart random rest-stringmap

12896+ rest-types safe split text transformers unordered-containers

12897+ uri-encode utf8-string uuid

12898+ ];

12899+ testHaskellDepends = [

12900+ base bytestring HUnit mtl test-framework test-framework-hunit

12901+ unordered-containers

12902+ ];

12903+ description = "Rest API library";

12904+ license = stdenv.lib.licenses.bsd3;

12905+ }) {};

12906+ "rest-gen" = callPackage

12907+ ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder

12908+ , directory, fclabels, filepath, hashable, haskell-src-exts

12909+ , hslogger, HStringTemplate, HUnit, hxt, json-schema, pretty

12910+ , process, rest-core, safe, scientific, semigroups, split, tagged

12911+ , test-framework, test-framework-hunit, text, uniplate

12912+ , unordered-containers, vector

12913+ }:

12914+ mkDerivation {

12915+ pname = "rest-gen";

12916+ version = "0.16.1.3";

12917+ sha256 = "1nh3rjnn36v13ikvvxc7xahrj3gsswhiq2w54xclrxjl2fzsqz3a";

12918+ configureFlags = [

12919+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12920+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12921+ "-fsplitbase" "-f-test-hlint"

12922+ ];

12923+ enableSeparateDataOutput = true;

12924+ libraryHaskellDepends = [

12925+ aeson base blaze-html Cabal code-builder directory fclabels

12926+ filepath hashable haskell-src-exts hslogger HStringTemplate hxt

12927+ json-schema pretty process rest-core safe scientific semigroups

12928+ split tagged text uniplate unordered-containers vector

12929+ ];

12930+ testHaskellDepends = [

12931+ base fclabels haskell-src-exts HUnit rest-core test-framework

12932+ test-framework-hunit

12933+ ];

12934+ description = "Documentation and client generation from rest definition";

12935+ license = stdenv.lib.licenses.bsd3;

12936+ }) {};

12937+ "rest-happstack" = callPackage

12938+ ({ mkDerivation, base, containers, happstack-server, mtl, rest-core

12939+ , rest-gen, utf8-string

12940+ }:

12941+ mkDerivation {

12942+ pname = "rest-happstack";

12943+ version = "0.2.10.3";

12944+ sha256 = "05sakr88j6rlwnghzd00g3c3895wpjxi36n9pdbpv0fpm0hh86yv";

12945+ revision = "1";

12946+ editedCabalFile = "1las5yg48v1diawsrb4pj3n1c91kj4y72pr2l038dqx26d8zl3k9";

12947+ configureFlags = [

12948+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12949+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12950+ "-fsplitbase" "-f-test-hlint"

12951+ ];

12952+ libraryHaskellDepends = [

12953+ base containers happstack-server mtl rest-core rest-gen utf8-string

12954+ ];

12955+ description = "Rest driver for Happstack";

12956+ license = stdenv.lib.licenses.bsd3;

12957+ }) {};

12958+ "rest-snap" = callPackage

12959+ ({ mkDerivation, base, bytestring, case-insensitive, rest-core

12960+ , safe, snap-core, unordered-containers, uri-encode, utf8-string

12961+ }:

12962+ mkDerivation {

12963+ pname = "rest-snap";

12964+ version = "0.1.17.14";

12965+ sha256 = "0fd6d85gzp9mr7y7bgfk9wscrhrych9q7cssps8m5l03n83d8asp";

12966+ configureFlags = [

12967+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12968+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12969+ "-fsplitbase" "-f-test-hlint"

12970+ ];

12971+ libraryHaskellDepends = [

12972+ base bytestring case-insensitive rest-core safe snap-core

12973+ unordered-containers uri-encode utf8-string

12974+ ];

12975+ description = "Rest driver for Snap";

12976+ license = stdenv.lib.licenses.bsd3;

12977+ }) {};

12978+ "rest-stringmap" = callPackage

12979+ ({ mkDerivation, aeson, base, containers, hashable, hxt

12980+ , json-schema, tagged, text, tostring, unordered-containers

12981+ }:

12982+ mkDerivation {

12983+ pname = "rest-stringmap";

12984+ version = "0.2.0.2";

12985+ sha256 = "0nzkc09679c2mz3amh1avk2kfjpqbhbxsr0r9zvgcs71gqkal2mz";

12986+ revision = "3";

12987+ editedCabalFile = "04rvx4f6pn1dm0k3p5jlj07m9dh4mvzpk05an86c0rngvwi89n3b";

12988+ configureFlags = [

12989+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12990+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12991+ "-fsplitbase" "-f-test-hlint"

12992+ ];

12993+ libraryHaskellDepends = [

12994+ aeson base containers hashable hxt json-schema tagged text tostring

12995+ unordered-containers

12996+ ];

12997+ description = "Maps with stringy keys that can be transcoded to JSON and XML";

12998+ license = stdenv.lib.licenses.bsd3;

12999+ }) {};

13000+ "rest-types" = callPackage

13001+ ({ mkDerivation, aeson, base, generic-aeson, hxt, json-schema, mtl

13002+ , regular, regular-xmlpickler, rest-stringmap, text, uuid

13003+ }:

13004+ mkDerivation {

13005+ pname = "rest-types";

13006+ version = "1.11.1.1";

13007+ sha256 = "0xr9h1bivw3miyg4xill0jwn95lybsbqgrnw2323pwxlbbnaa25a";

13008+ configureFlags = [

13009+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13010+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13011+ "-fsplitbase" "-f-test-hlint"

13012+ ];

13013+ libraryHaskellDepends = [

13014+ aeson base generic-aeson hxt json-schema mtl regular

13015+ regular-xmlpickler rest-stringmap text uuid

13016+ ];

13017+ description = "Silk Rest Framework Types";

13018+ license = stdenv.lib.licenses.bsd3;

13019+ }) {};

13020+ "rest-wai" = callPackage

13021+ ({ mkDerivation, base, bytestring, case-insensitive, containers

13022+ , http-types, mime-types, mtl, rest-core, text

13023+ , unordered-containers, utf8-string, wai

13024+ }:

13025+ mkDerivation {

13026+ pname = "rest-wai";

13027+ version = "0.1.0.4";

13028+ sha256 = "1pxjf0fmsfiywr81zl5xbl6si0x74a7zmz6d5vqv5pvxmpgwgcbg";

13029+ configureFlags = [

13030+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13031+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13032+ "-fsplitbase" "-f-test-hlint"

13033+ ];

13034+ libraryHaskellDepends = [

13035+ base bytestring case-insensitive containers http-types mime-types

13036+ mtl rest-core text unordered-containers utf8-string wai

13037+ ];

13038+ description = "Rest driver for WAI applications";

13039+ license = stdenv.lib.licenses.bsd3;

13040+ }) {};

13041+ "rev-state" = callPackage

13042+ ({ mkDerivation, base, mtl }:

13043+ mkDerivation {

13044+ pname = "rev-state";

13045+ version = "0.1";

13046+ sha256 = "1lsq7b225v86rwm2rnrnhn28asjh6r3zwbvdm5vl4sp46cr5i4cf";

13047+ configureFlags = [

13048+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13049+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13050+ "-fsplitbase" "-f-test-hlint"

13051+ ];

13052+ libraryHaskellDepends = [ base mtl ];

13053+ homepage = "https://github.com/DanBurton/rev-state#readme";

13054+ description = "Reverse State monad transformer";

13055+ license = stdenv.lib.licenses.bsd3;

13056+ }) {};

13057+ "rfc5051" = callPackage

13058+ ({ mkDerivation, base, bytestring, containers }:

13059+ mkDerivation {

13060+ pname = "rfc5051";

13061+ version = "0.1.0.3";

13062+ sha256 = "0av4c3qvwbkbzrjrrg601ay9pds7wscqqp2lc2z78mv2lllap3g3";

13063+ configureFlags = [

13064+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13065+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13066+ "-fsplitbase" "-f-test-hlint"

13067+ ];

13068+ isLibrary = true;

13069+ isExecutable = true;

13070+ libraryHaskellDepends = [ base bytestring containers ];

13071+ executableHaskellDepends = [ base bytestring containers ];

13072+ description = "Simple unicode collation as per RFC5051";

13073+ license = stdenv.lib.licenses.bsd3;

13074+ }) {};

13075+ "runmemo" = callPackage

13076+ ({ mkDerivation, base, data-memocombinators, time }:

13077+ mkDerivation {

13078+ pname = "runmemo";

13079+ version = "1.0.0.1";

13080+ sha256 = "12fn0lsil0rj0pj0ixzppsdw2fmj0cnzci4fh11z9rcggwbz6pms";

13081+ configureFlags = [

13082+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13083+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13084+ "-fsplitbase" "-f-test-hlint"

13085+ ];

13086+ testHaskellDepends = [ base data-memocombinators time ];

13087+ homepage = "https://github.com/DanBurton/runmemo";

13088+ description = "A simple memoization helper library";

13089+ license = stdenv.lib.licenses.bsd3;

13090+ }) {};

13091+ "rvar" = callPackage

13092+ ({ mkDerivation, base, MonadPrompt, mtl, random-source

13093+ , transformers

13094+ }:

13095+ mkDerivation {

13096+ pname = "rvar";

13097+ version = "0.2.0.2";

13098+ sha256 = "1n24fl27mrm7cndp8b646b9c5hjm3hf5m12y9ni0f850dd739jm4";

13099+ configureFlags = [

13100+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13101+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13102+ "-fsplitbase" "-f-test-hlint"

13103+ ];

13104+ libraryHaskellDepends = [

13105+ base MonadPrompt mtl random-source transformers

13106+ ];

13107+ homepage = "https://github.com/mokus0/random-fu";

13108+ description = "Random Variables";

13109+ license = stdenv.lib.licenses.publicDomain;

13110+ }) {};

13111+ "safe" = callPackage

13112+ ({ mkDerivation, base }:

13113+ mkDerivation {

13114+ pname = "safe";

13115+ version = "0.3.8";

13116+ sha256 = "0k5lk85z2y8kgk7dx7km32g8vi55vnwln8ys2gs174ljd136cjdf";

13117+ configureFlags = [

13118+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13119+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13120+ "-fsplitbase" "-f-test-hlint"

13121+ ];

13122+ libraryHaskellDepends = [ base ];

13123+ homepage = "http://community.haskell.org/~ndm/safe/";

13124+ description = "Library of safe (exception free) functions";

13125+ license = stdenv.lib.licenses.bsd3;

13126+ }) {};

13127+ "safecopy" = callPackage

13128+ ({ mkDerivation, array, base, bytestring, cereal, containers, lens

13129+ , old-time, quickcheck-instances, tasty, tasty-quickcheck

13130+ , template-haskell, text, time, vector

13131+ }:

13132+ mkDerivation {

13133+ pname = "safecopy";

13134+ version = "0.8.3";

13135+ sha256 = "10xd42a1i84fwiy3db0ji4bd8ssk9jqysqwc00wdcdjyp50c333n";

13136+ revision = "3";

13137+ editedCabalFile = "1b1xmq9ajw7ihff3nl2x4pd2wxbm4j7p90ds8iq6qz17zrn6r5js";

13138+ configureFlags = [

13139+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13140+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13141+ "-fsplitbase" "-f-test-hlint"

13142+ ];

13143+ libraryHaskellDepends = [

13144+ array base bytestring cereal containers old-time template-haskell

13145+ text time vector

13146+ ];

13147+ testHaskellDepends = [

13148+ array base cereal containers lens quickcheck-instances tasty

13149+ tasty-quickcheck template-haskell time vector

13150+ ];

13151+ homepage = "http://acid-state.seize.it/safecopy";

13152+ description = "Binary serialization with version control";

13153+ license = stdenv.lib.licenses.publicDomain;

13154+ }) {};

13155+ "scientific" = callPackage

13156+ ({ mkDerivation, array, base, bytestring, criterion, deepseq

13157+ , ghc-prim, hashable, integer-gmp, QuickCheck, smallcheck, tasty

13158+ , tasty-ant-xml, tasty-hunit, tasty-quickcheck, tasty-smallcheck

13159+ , text

13160+ }:

13161+ mkDerivation {

13162+ pname = "scientific";

13163+ version = "0.3.3.3";

13164+ sha256 = "1hngkmd1kggc84sz4mddc0yj2vyzc87dz5dkkywjgxczys51mhqn";

13165+ configureFlags = [

13166+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13167+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13168+ "-fsplitbase" "-f-test-hlint"

13169+ ];

13170+ libraryHaskellDepends = [

13171+ array base bytestring deepseq ghc-prim hashable integer-gmp text

13172+ ];

13173+ testHaskellDepends = [

13174+ base bytestring QuickCheck smallcheck tasty tasty-ant-xml

13175+ tasty-hunit tasty-quickcheck tasty-smallcheck text

13176+ ];

13177+ benchmarkHaskellDepends = [

13178+ array base bytestring criterion deepseq ghc-prim hashable

13179+ integer-gmp text

13180+ ];

13181+ doHaddock = false;

13182+ doCheck = false;

13183+ homepage = "https://github.com/basvandijk/scientific";

13184+ description = "Numbers represented using scientific notation";

13185+ license = stdenv.lib.licenses.bsd3;

13186+ }) {};

13187+ "scotty" = callPackage

13188+ ({ mkDerivation, aeson, base, blaze-builder, bytestring

13189+ , case-insensitive, data-default, hspec-wai, hspec2, http-types

13190+ , lifted-base, monad-control, mtl, regex-compat, text, transformers

13191+ , transformers-base, wai, wai-extra, warp

13192+ }:

13193+ mkDerivation {

13194+ pname = "scotty";

13195+ version = "0.9.0";

13196+ sha256 = "0gx00k5w4cs68bh3ciplkwhzh2412y6wqg0qdsslnnsb41l5kb1d";

13197+ revision = "2";

13198+ editedCabalFile = "0zl0gyc0vp6zjcmw6bz4djqh8dpccbb2aql1sd17pa22v8k7qbpw";

13199+ configureFlags = [

13200+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13201+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13202+ "-fsplitbase" "-f-test-hlint"

13203+ ];

13204+ libraryHaskellDepends = [

13205+ aeson base blaze-builder bytestring case-insensitive data-default

13206+ http-types monad-control mtl regex-compat text transformers

13207+ transformers-base wai wai-extra warp

13208+ ];

13209+ testHaskellDepends = [

13210+ base bytestring hspec-wai hspec2 http-types lifted-base text wai

13211+ ];

13212+ homepage = "https://github.com/scotty-web/scotty";

13213+ description = "Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp";

13214+ license = stdenv.lib.licenses.bsd3;

13215+ }) {};

13216+ "scrobble" = callPackage

13217+ ({ mkDerivation, base, containers, curl, MissingH, network

13218+ , network-uri, old-locale, pureMD5, time, url

13219+ }:

13220+ mkDerivation {

13221+ pname = "scrobble";

13222+ version = "0.2.1.1";

13223+ sha256 = "161l75bni4fxmh35dfz8r2vgllmmf0s55j9y2xpyskqfj3xc85a7";

13224+ configureFlags = [

13225+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13226+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13227+ "-fsplitbase" "-f-test-hlint"

13228+ ];

13229+ isLibrary = true;

13230+ isExecutable = true;

13231+ libraryHaskellDepends = [

13232+ base containers curl MissingH network network-uri old-locale

13233+ pureMD5 time url

13234+ ];

13235+ executableHaskellDepends = [

13236+ base containers curl MissingH network network-uri old-locale time

13237+ url

13238+ ];

13239+ description = "Scrobbling server";

13240+ license = stdenv.lib.licenses.bsd3;

13241+ }) {};

13242+ "securemem" = callPackage

13243+ ({ mkDerivation, base, byteable, bytestring, ghc-prim }:

13244+ mkDerivation {

13245+ pname = "securemem";

13246+ version = "0.1.4";

13247+ sha256 = "1wdbcnyaarrixfvz79mcyqmfnn9h5zsmrrsa64xj8650ppyaxi48";

13248+ configureFlags = [

13249+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13250+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13251+ "-fsplitbase" "-f-test-hlint"

13252+ ];

13253+ enableSeparateDataOutput = true;

13254+ libraryHaskellDepends = [ base byteable bytestring ghc-prim ];

13255+ homepage = "http://github.com/vincenthz/hs-securemem";

13256+ description = "abstraction to an auto scrubbing and const time eq, memory chunk";

13257+ license = stdenv.lib.licenses.bsd3;

13258+ }) {};

13259+ "semigroupoid-extras" = callPackage

13260+ ({ mkDerivation, base, semigroupoids }:

13261+ mkDerivation {

13262+ pname = "semigroupoid-extras";

13263+ version = "4.0";

13264+ sha256 = "07aa7z4nywcrp9msq83b1pcmryl25yxha89sn5vwlgq40cibcm3g";

13265+ configureFlags = [

13266+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13267+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13268+ "-fsplitbase" "-f-test-hlint"

13269+ ];

13270+ libraryHaskellDepends = [ base semigroupoids ];

13271+ doHaddock = false;

13272+ doCheck = false;

13273+ homepage = "http://github.com/ekmett/semigroupoid-extras";

13274+ description = "This package has been absorbed into semigroupoids 4.0";

13275+ license = stdenv.lib.licenses.bsd3;

13276+ }) {};

13277+ "semigroupoids" = callPackage

13278+ ({ mkDerivation, base, base-orphans, comonad, containers

13279+ , contravariant, distributive, semigroups, transformers

13280+ }:

13281+ mkDerivation {

13282+ pname = "semigroupoids";

13283+ version = "4.2";

13284+ sha256 = "18zip518f2l2ccmg3hjzy5mq2b8r98crzm10kr77yc4m64w5vac8";

13285+ revision = "3";

13286+ editedCabalFile = "1nzj1k9g6rfvgpj51hlsl3463hqsl4ckrzy4l3058jqhdx05hd96";

13287+ configureFlags = [

13288+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13289+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13290+ "-fsplitbase" "-f-test-hlint"

13291+ ];

13292+ libraryHaskellDepends = [

13293+ base base-orphans comonad containers contravariant distributive

13294+ semigroups transformers

13295+ ];

13296+ homepage = "http://github.com/ekmett/semigroupoids";

13297+ description = "Semigroupoids: Category sans id";

13298+ license = stdenv.lib.licenses.bsd3;

13299+ }) {base-orphans = null;};

13300+ "semigroups" = callPackage

13301+ ({ mkDerivation, base, bytestring, containers, deepseq, hashable

13302+ , nats, text, unordered-containers

13303+ }:

13304+ mkDerivation {

13305+ pname = "semigroups";

13306+ version = "0.16";

13307+ sha256 = "0mq5c6py0z3jaxr1j0aalz4vjd1v6ygffv91h7nh5621rcv4ga4s";

13308+ configureFlags = [

13309+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13310+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13311+ "-fsplitbase" "-f-test-hlint"

13312+ ];

13313+ libraryHaskellDepends = [

13314+ base bytestring containers deepseq hashable nats text

13315+ unordered-containers

13316+ ];

13317+ homepage = "http://github.com/ekmett/semigroups/";

13318+ description = "Anything that associates";

13319+ license = stdenv.lib.licenses.bsd3;

13320+ }) {};

13321+ "sendfile" = callPackage

13322+ ({ mkDerivation, base, bytestring, network }:

13323+ mkDerivation {

13324+ pname = "sendfile";

13325+ version = "0.7.9";

13326+ sha256 = "0hnw1ym81cff49dwww19kgbs4s0kpandbvn6h5cml3y0p1nxybqh";

13327+ configureFlags = [

13328+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13329+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13330+ "-fsplitbase" "-f-test-hlint"

13331+ ];

13332+ libraryHaskellDepends = [ base bytestring network ];

13333+ homepage = "http://hub.darcs.net/stepcut/sendfile";

13334+ description = "A portable sendfile library";

13335+ license = stdenv.lib.licenses.bsd3;

13336+ }) {};

13337+ "seqloc" = callPackage

13338+ ({ mkDerivation, attoparsec, base, biocore, bytestring, hashable

13339+ , QuickCheck, random, unordered-containers, vector

13340+ }:

13341+ mkDerivation {

13342+ pname = "seqloc";

13343+ version = "0.6";

13344+ sha256 = "11b2c2xl6n993wqci52li0wfr0wkjsw916cni1v59z2fq4kp6027";

13345+ configureFlags = [

13346+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13347+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13348+ "-fsplitbase" "-f-test-hlint"

13349+ ];

13350+ libraryHaskellDepends = [

13351+ attoparsec base biocore bytestring hashable unordered-containers

13352+ vector

13353+ ];

13354+ testHaskellDepends = [

13355+ attoparsec base biocore bytestring hashable QuickCheck random

13356+ unordered-containers vector

13357+ ];

13358+ doHaddock = false;

13359+ doCheck = false;

13360+ homepage = "http://www.ingolia-lab.org/seqloc-tutorial.html";

13361+ description = "Handle sequence locations for bioinformatics";

13362+ license = stdenv.lib.licenses.mit;

13363+ }) {};

13364+ "setenv" = callPackage

13365+ ({ mkDerivation, base, process, unix }:

13366+ mkDerivation {

13367+ pname = "setenv";

13368+ version = "0.1.1.1";

13369+ sha256 = "0azkvsvk9i1979rn45zryqyirvjhj9b32nnz1m30aasbs2q8f393";

13370+ configureFlags = [

13371+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13372+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13373+ "-fsplitbase" "-f-test-hlint"

13374+ ];

13375+ libraryHaskellDepends = [ base unix ];

13376+ testHaskellDepends = [ base process ];

13377+ doHaddock = false;

13378+ doCheck = false;

13379+ description = "A cross-platform library for setting environment variables";

13380+ license = stdenv.lib.licenses.mit;

13381+ }) {};

13382+ "shake" = callPackage

13383+ ({ mkDerivation, base, binary, bytestring, deepseq, directory

13384+ , extra, filepath, hashable, js-flot, js-jquery, old-time, process

13385+ , QuickCheck, random, time, transformers, unix

13386+ , unordered-containers, utf8-string

13387+ }:

13388+ mkDerivation {

13389+ pname = "shake";

13390+ version = "0.14.2";

13391+ sha256 = "0wb4rvnkw6gag1jffv9z2by7y8gifp58pnw3n7dyc01yglbys72m";

13392+ revision = "3";

13393+ editedCabalFile = "1gcrp9mddbg4bzrydiv5drnp76xnabkxy47fr0yrkd0filfic1my";

13394+ configureFlags = [

13395+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13396+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13397+ "-fsplitbase" "-f-test-hlint"

13398+ ];

13399+ isLibrary = true;

13400+ isExecutable = true;

13401+ enableSeparateDataOutput = true;

13402+ libraryHaskellDepends = [

13403+ base binary bytestring deepseq directory extra filepath hashable

13404+ js-flot js-jquery old-time process random time transformers unix

13405+ unordered-containers utf8-string

13406+ ];

13407+ executableHaskellDepends = [

13408+ base binary bytestring deepseq directory extra filepath hashable

13409+ js-flot js-jquery old-time process random time transformers unix

13410+ unordered-containers utf8-string

13411+ ];

13412+ testHaskellDepends = [

13413+ base binary bytestring deepseq directory extra filepath hashable

13414+ js-flot js-jquery old-time process QuickCheck random time

13415+ transformers unix unordered-containers utf8-string

13416+ ];

13417+ doHaddock = false;

13418+ doCheck = false;

13419+ homepage = "http://www.shakebuild.com/";

13420+ description = "Build system library, like Make, but more accurate dependencies";

13421+ license = stdenv.lib.licenses.bsd3;

13422+ }) {};

13423+ "shakespeare" = callPackage

13424+ ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring

13425+ , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec

13426+ , process, system-fileio, system-filepath, template-haskell, text

13427+ , time, transformers

13428+ }:

13429+ mkDerivation {

13430+ pname = "shakespeare";

13431+ version = "2.0.2.1";

13432+ sha256 = "1s73nlkccfg3wl0qfx6f7q3afiakdhzh5xksnfhsg5hjhx80qhza";

13433+ revision = "1";

13434+ editedCabalFile = "14i6al784pb7s85jdscm0yprg5bg2vmlbfc0myldzw5ff107y4di";

13435+ configureFlags = [

13436+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13437+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13438+ "-fsplitbase" "-f-test-hlint"

13439+ ];

13440+ libraryHaskellDepends = [

13441+ aeson base blaze-html blaze-markup bytestring containers directory

13442+ exceptions ghc-prim parsec process system-fileio system-filepath

13443+ template-haskell text time transformers

13444+ ];

13445+ testHaskellDepends = [

13446+ aeson base blaze-html blaze-markup bytestring containers directory

13447+ exceptions ghc-prim hspec HUnit parsec process system-fileio

13448+ system-filepath template-haskell text time transformers

13449+ ];

13450+ homepage = "http://www.yesodweb.com/book/shakespearean-templates";

13451+ description = "A toolkit for making compile-time interpolated templates";

13452+ license = stdenv.lib.licenses.mit;

13453+ }) {};

13454+ "shakespeare-i18n" = callPackage

13455+ ({ mkDerivation, base, shakespeare }:

13456+ mkDerivation {

13457+ pname = "shakespeare-i18n";

13458+ version = "1.1.0";

13459+ sha256 = "0ahhg9r7d8kdxn0x33bp5p8wmwkh1yvdqhw05yjwif0ky5y9h625";

13460+ configureFlags = [

13461+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13462+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13463+ "-fsplitbase" "-f-test-hlint"

13464+ ];

13465+ libraryHaskellDepends = [ base shakespeare ];

13466+ doHaddock = false;

13467+ doCheck = false;

13468+ homepage = "http://www.yesodweb.com/book/shakespearean-templates";

13469+ description = "A type-based approach to internationalization. (deprecated)";

13470+ license = stdenv.lib.licenses.mit;

13471+ }) {};

13472+ "shakespeare-text" = callPackage

13473+ ({ mkDerivation, base, shakespeare }:

13474+ mkDerivation {

13475+ pname = "shakespeare-text";

13476+ version = "1.1.0";

13477+ sha256 = "18ixixb9aqn630s9wblxcki1gggm4i0fj9752c55p3b42q8h86rc";

13478+ configureFlags = [

13479+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13480+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13481+ "-fsplitbase" "-f-test-hlint"

13482+ ];

13483+ libraryHaskellDepends = [ base shakespeare ];

13484+ doHaddock = false;

13485+ doCheck = false;

13486+ homepage = "http://www.yesodweb.com/book/shakespearean-templates";

13487+ description = "Interpolation with quasi-quotation: put variables strings (deprecated)";

13488+ license = stdenv.lib.licenses.mit;

13489+ }) {};

13490+ "shell-conduit" = callPackage

13491+ ({ mkDerivation, async, base, bytestring, conduit, conduit-extra

13492+ , control-monad-loop, directory, filepath, monad-control, monads-tf

13493+ , process, resourcet, semigroups, split, template-haskell, text

13494+ , transformers, transformers-base, unix

13495+ }:

13496+ mkDerivation {

13497+ pname = "shell-conduit";

13498+ version = "4.5";

13499+ sha256 = "1vgqfba6k0nv8nwa48fv2hkr9xlrrfrdh2awgpllrimnh0yww41g";

13500+ revision = "1";

13501+ editedCabalFile = "1c4vy3xbb1h7201ird67a2982j0rn4qgm8pd1x6iaiab8na713li";

13502+ configureFlags = [

13503+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13504+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13505+ "-fsplitbase" "-f-test-hlint"

13506+ ];

13507+ libraryHaskellDepends = [

13508+ async base bytestring conduit conduit-extra control-monad-loop

13509+ directory filepath monad-control monads-tf process resourcet

13510+ semigroups split template-haskell text transformers

13511+ transformers-base unix

13512+ ];

13513+ homepage = "https://github.com/chrisdone/shell-conduit";

13514+ description = "Write shell scripts with Conduit";

13515+ license = stdenv.lib.licenses.bsd3;

13516+ }) {};

13517+ "shelly" = callPackage

13518+ ({ mkDerivation, async, base, bytestring, containers, directory

13519+ , enclosed-exceptions, exceptions, lifted-async, lifted-base

13520+ , monad-control, mtl, process, system-fileio, system-filepath, text

13521+ , time, transformers, transformers-base, unix-compat

13522+ }:

13523+ mkDerivation {

13524+ pname = "shelly";

13525+ version = "1.5.6";

13526+ sha256 = "1vnn0s3i3n76286b7rc70qjzgkmfwllpg7w4zin627v6466pfpzl";

13527+ configureFlags = [

13528+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13529+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13530+ "-fsplitbase" "-f-test-hlint"

13531+ ];

13532+ libraryHaskellDepends = [

13533+ async base bytestring containers directory enclosed-exceptions

13534+ exceptions lifted-async lifted-base monad-control mtl process

13535+ system-fileio system-filepath text time transformers

13536+ transformers-base unix-compat

13537+ ];

13538+ homepage = "https://github.com/yesodweb/Shelly.hs";

13539+ description = "shell-like (systems) programming in Haskell";

13540+ license = stdenv.lib.licenses.bsd3;

13541+ }) {};

13542+ "silently" = callPackage

13543+ ({ mkDerivation, base, deepseq, directory, nanospec }:

13544+ mkDerivation {

13545+ pname = "silently";

13546+ version = "1.2.4.1";

13547+ sha256 = "035dw3zg680ykyz5rqkkrjn51wkznbc4jb45a8l2gh3vgqzgbf52";

13548+ configureFlags = [

13549+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13550+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13551+ "-fsplitbase" "-f-test-hlint"

13552+ ];

13553+ libraryHaskellDepends = [ base deepseq directory ];

13554+ testHaskellDepends = [ base deepseq directory nanospec ];

13555+ homepage = "https://github.com/trystan/silently";

13556+ description = "Prevent or capture writing to stdout and other handles";

13557+ license = stdenv.lib.licenses.bsd3;

13558+ }) {};

13559+ "simple-reflect" = callPackage

13560+ ({ mkDerivation, base }:

13561+ mkDerivation {

13562+ pname = "simple-reflect";

13563+ version = "0.3.2";

13564+ sha256 = "1dpcf6w3cf1sfl9bnlsx04x7aghw029glj5d05qzrsnms2rlw8iq";

13565+ configureFlags = [

13566+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13567+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13568+ "-fsplitbase" "-f-test-hlint"

13569+ ];

13570+ libraryHaskellDepends = [ base ];

13571+ homepage = "http://twanvl.nl/blog/haskell/simple-reflection-of-expressions";

13572+ description = "Simple reflection of expressions containing variables";

13573+ license = stdenv.lib.licenses.bsd3;

13574+ }) {};

13575+ "simple-sendfile" = callPackage

13576+ ({ mkDerivation, base, bytestring, conduit, conduit-extra

13577+ , directory, hspec, HUnit, network, process, resourcet, unix

13578+ }:

13579+ mkDerivation {

13580+ pname = "simple-sendfile";

13581+ version = "0.2.18";

13582+ sha256 = "1dc7c4bkcwzfhbm982svi9j6dzxxf0z6pjkdrs23m9bc9g8aly49";

13583+ configureFlags = [

13584+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13585+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13586+ "-fsplitbase" "-f-test-hlint"

13587+ ];

13588+ libraryHaskellDepends = [ base bytestring network unix ];

13589+ testHaskellDepends = [

13590+ base bytestring conduit conduit-extra directory hspec HUnit network

13591+ process resourcet unix

13592+ ];

13593+ doHaddock = false;

13594+ doCheck = false;

13595+ description = "Cross platform library for the sendfile system call";

13596+ license = stdenv.lib.licenses.bsd3;

13597+ }) {};

13598+ "singletons" = callPackage

13599+ ({ mkDerivation, base, Cabal, constraints, containers, filepath

13600+ , mtl, process, tasty, tasty-golden, template-haskell, th-desugar

13601+ }:

13602+ mkDerivation {

13603+ pname = "singletons";

13604+ version = "1.0";

13605+ sha256 = "1rd1728wghhqlg2djd7az8i01rf4i3wwwcnz2v43a39jjvhlklkg";

13606+ revision = "1";

13607+ editedCabalFile = "03w3qrxgkcnsi5lqyxgd0vizng8l5h02l1nmsh7ywvpik9jpjvm1";

13608+ configureFlags = [

13609+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13610+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13611+ "-fsplitbase" "-f-test-hlint"

13612+ ];

13613+ libraryHaskellDepends = [

13614+ base containers mtl template-haskell th-desugar

13615+ ];

13616+ testHaskellDepends = [

13617+ base Cabal constraints filepath process tasty tasty-golden

13618+ ];

13619+ doHaddock = false;

13620+ doCheck = false;

13621+ homepage = "http://www.cis.upenn.edu/~eir/packages/singletons";

13622+ description = "A framework for generating singleton types";

13623+ license = stdenv.lib.licenses.bsd3;

13624+ }) {};

13625+ "siphash" = callPackage

13626+ ({ mkDerivation, base, bytestring, cpu, QuickCheck, test-framework

13627+ , test-framework-quickcheck2

13628+ }:

13629+ mkDerivation {

13630+ pname = "siphash";

13631+ version = "1.0.3";

13632+ sha256 = "1wq5dan30ggjgmravy92ylqjvjv1q7mxrmddr7zc8h6aqr0wx0fg";

13633+ revision = "1";

13634+ editedCabalFile = "1q2dy0ywngm9iv7k6d9gnf860m9hpf62q5qvdzmxw5s629gk4afn";

13635+ configureFlags = [

13636+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13637+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13638+ "-fsplitbase" "-f-test-hlint"

13639+ ];

13640+ enableSeparateDataOutput = true;

13641+ libraryHaskellDepends = [ base bytestring cpu ];

13642+ testHaskellDepends = [

13643+ base bytestring QuickCheck test-framework

13644+ test-framework-quickcheck2

13645+ ];

13646+ homepage = "http://github.com/vincenthz/hs-siphash";

13647+ description = "siphash: a fast short input PRF";

13648+ license = stdenv.lib.licenses.bsd3;

13649+ }) {};

13650+ "skein" = callPackage

13651+ ({ mkDerivation, base, bytestring, cereal, crypto-api, filepath

13652+ , hspec, tagged

13653+ }:

13654+ mkDerivation {

13655+ pname = "skein";

13656+ version = "1.0.9.1";

13657+ sha256 = "05as5glin9vikxxbnp5wpklqjd5hh9n28asxx147blmiz0x45dw8";

13658+ configureFlags = [

13659+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13660+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13661+ "-fsplitbase" "-f-test-hlint"

13662+ ];

13663+ libraryHaskellDepends = [

13664+ base bytestring cereal crypto-api tagged

13665+ ];

13666+ testHaskellDepends = [

13667+ base bytestring cereal crypto-api filepath hspec tagged

13668+ ];

13669+ homepage = "https://github.com/meteficha/skein";

13670+ description = "Skein, a family of cryptographic hash functions. Includes Skein-MAC as well.";

13671+ license = stdenv.lib.licenses.bsd3;

13672+ }) {};

13673+ "slave-thread" = callPackage

13674+ ({ mkDerivation, base, base-prelude, HTF, list-t, mmorph

13675+ , partial-handler, QuickCheck, quickcheck-instances, SafeSemaphore

13676+ , stm-containers, transformers

13677+ }:

13678+ mkDerivation {

13679+ pname = "slave-thread";

13680+ version = "0.1.4";

13681+ sha256 = "0a9jya48wbi2ddwhdssridzb0f32raq9k6idfpncywr47vgfdg6z";

13682+ configureFlags = [

13683+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13684+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13685+ "-fsplitbase" "-f-test-hlint"

13686+ ];

13687+ libraryHaskellDepends = [

13688+ base base-prelude list-t mmorph partial-handler stm-containers

13689+ transformers

13690+ ];

13691+ testHaskellDepends = [

13692+ base base-prelude HTF QuickCheck quickcheck-instances SafeSemaphore

13693+ ];

13694+ doHaddock = false;

13695+ doCheck = false;

13696+ homepage = "https://github.com/nikita-volkov/slave-thread";

13697+ description = "A principal solution to ghost threads and silent exceptions";

13698+ license = stdenv.lib.licenses.mit;

13699+ }) {};

13700+ "smallcheck" = callPackage

13701+ ({ mkDerivation, base, ghc-prim, logict, mtl, pretty }:

13702+ mkDerivation {

13703+ pname = "smallcheck";

13704+ version = "1.1.1";

13705+ sha256 = "1ygrabxh40bym3grnzqyfqn96lirnxspb8cmwkkr213239y605sd";

13706+ revision = "1";

13707+ editedCabalFile = "1ykq0hqs1alw86p0ssa6dhsb1a8d4m6bqwibkhvzcd6c28dq975i";

13708+ configureFlags = [

13709+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13710+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13711+ "-fsplitbase" "-f-test-hlint"

13712+ ];

13713+ libraryHaskellDepends = [ base ghc-prim logict mtl pretty ];

13714+ homepage = "https://github.com/feuerbach/smallcheck";

13715+ description = "A property-based testing library";

13716+ license = stdenv.lib.licenses.bsd3;

13717+ }) {};

13718+ "smtLib" = callPackage

13719+ ({ mkDerivation, base, pretty }:

13720+ mkDerivation {

13721+ pname = "smtLib";

13722+ version = "1.0.7";

13723+ sha256 = "1jn2790x7g7n6jm5cfgd692n3l6iafyv0zyz40hx8ykcs4jh2rkf";

13724+ revision = "1";

13725+ editedCabalFile = "13j4kp8cjx20zi6xy55bjdbr39p223s299wgad0xpgch1qz7q7bs";

13726+ configureFlags = [

13727+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13728+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13729+ "-fsplitbase" "-f-test-hlint"

13730+ ];

13731+ libraryHaskellDepends = [ base pretty ];

13732+ description = "A library for working with the SMTLIB format";

13733+ license = stdenv.lib.licenses.bsd3;

13734+ }) {};

13735+ "snap" = callPackage

13736+ ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal

13737+ , clientsession, comonad, configurator, containers, directory

13738+ , directory-tree, dlist, errors, filepath, hashable, heist, lens

13739+ , logict, MonadCatchIO-transformers, mtl, mwc-random, old-time

13740+ , pwstore-fast, regex-posix, snap-core, snap-server, stm, syb

13741+ , template-haskell, text, time, transformers, unordered-containers

13742+ , vector, vector-algorithms, xmlhtml

13743+ }:

13744+ mkDerivation {

13745+ pname = "snap";

13746+ version = "0.13.3.2";

13747+ sha256 = "1k6sd2ww8zqkbfv4v5ryqwgicx6yprfil8cd5rgdvygyjs88fcrp";

13748+ revision = "3";

13749+ editedCabalFile = "13r9q0cmfkysvgg3xs64k4ar3wdbpp25hzccphclimfnwvivdzig";

13750+ configureFlags = [

13751+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13752+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13753+ "-fsplitbase" "-f-test-hlint"

13754+ ];

13755+ isLibrary = true;

13756+ isExecutable = true;

13757+ libraryHaskellDepends = [

13758+ aeson attoparsec base bytestring cereal clientsession comonad

13759+ configurator containers directory directory-tree dlist errors

13760+ filepath hashable heist lens logict MonadCatchIO-transformers mtl

13761+ mwc-random pwstore-fast regex-posix snap-core snap-server stm syb

13762+ text time transformers unordered-containers vector

13763+ vector-algorithms xmlhtml

13764+ ];

13765+ executableHaskellDepends = [

13766+ base bytestring containers directory directory-tree filepath

13767+ hashable old-time snap-server template-haskell text

13768+ ];

13769+ homepage = "http://snapframework.com/";

13770+ description = "Top-level package for the Snap Web Framework";

13771+ license = stdenv.lib.licenses.bsd3;

13772+ }) {};

13773+ "snap-core" = callPackage

13774+ ({ mkDerivation, attoparsec, attoparsec-enumerator, base

13775+ , blaze-builder, blaze-builder-enumerator, bytestring

13776+ , bytestring-mmap, case-insensitive, containers, deepseq, directory

13777+ , enumerator, filepath, hashable, HUnit, MonadCatchIO-transformers

13778+ , mtl, random, regex-posix, text, time, unix, unix-compat

13779+ , unordered-containers, vector, zlib-enum

13780+ }:

13781+ mkDerivation {

13782+ pname = "snap-core";

13783+ version = "0.9.6.3";

13784+ sha256 = "0i3gl1kxzi2l76sqhyhda7lrcvq8hq6aqgwvfx5k9fa2xic01dw1";

13785+ revision = "1";

13786+ editedCabalFile = "0gj8wgxy8vs0cdwmb32ksszx7jbgn0w5n2682vg842dn6gvn24qc";

13787+ configureFlags = [

13788+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13789+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13790+ "-fsplitbase" "-f-test-hlint"

13791+ ];

13792+ libraryHaskellDepends = [

13793+ attoparsec attoparsec-enumerator base blaze-builder

13794+ blaze-builder-enumerator bytestring bytestring-mmap

13795+ case-insensitive containers deepseq directory enumerator filepath

13796+ hashable HUnit MonadCatchIO-transformers mtl random regex-posix

13797+ text time unix unix-compat unordered-containers vector zlib-enum

13798+ ];

13799+ homepage = "http://snapframework.com/";

13800+ description = "Snap: A Haskell Web Framework (core interfaces and types)";

13801+ license = stdenv.lib.licenses.bsd3;

13802+ }) {};

13803+ "snap-server" = callPackage

13804+ ({ mkDerivation, attoparsec, attoparsec-enumerator, base

13805+ , blaze-builder, blaze-builder-enumerator, bytestring

13806+ , case-insensitive, containers, enumerator

13807+ , MonadCatchIO-transformers, mtl, network, old-locale, snap-core

13808+ , text, time, unix, unix-compat

13809+ }:

13810+ mkDerivation {

13811+ pname = "snap-server";

13812+ version = "0.9.4.5";

13813+ sha256 = "09399vlqgic0iwmx31c01bjpbdblw8gayxnz71lwzkixqibkbbip";

13814+ revision = "3";

13815+ editedCabalFile = "16dvm07mcxjhybiash5s62nm0fmznxq5xc28i154mcy4s4ds3zj6";

13816+ configureFlags = [

13817+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13818+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13819+ "-fsplitbase" "-f-test-hlint"

13820+ ];

13821+ libraryHaskellDepends = [

13822+ attoparsec attoparsec-enumerator base blaze-builder

13823+ blaze-builder-enumerator bytestring case-insensitive containers

13824+ enumerator MonadCatchIO-transformers mtl network old-locale

13825+ snap-core text time unix unix-compat

13826+ ];

13827+ homepage = "http://snapframework.com/";

13828+ description = "A fast, iteratee-based, epoll-enabled web server for the Snap Framework";

13829+ license = stdenv.lib.licenses.bsd3;

13830+ }) {};

13831+ "snaplet-fay" = callPackage

13832+ ({ mkDerivation, aeson, base, bytestring, configurator, directory

13833+ , fay, filepath, mtl, snap, snap-core, transformers

13834+ }:

13835+ mkDerivation {

13836+ pname = "snaplet-fay";

13837+ version = "0.3.3.8";

13838+ sha256 = "0yzqxciva57sdf0car5rdih2dk19rr589wd35s1jz7hp5ydqj1sj";

13839+ revision = "2";

13840+ editedCabalFile = "03y0jhbzv9vpxkh3jm0pnb5lj4awdh0ks5n6sm0i1z42mm3h2wjm";

13841+ configureFlags = [

13842+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13843+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13844+ "-fsplitbase" "-f-test-hlint"

13845+ ];

13846+ enableSeparateDataOutput = true;

13847+ libraryHaskellDepends = [

13848+ aeson base bytestring configurator directory fay filepath mtl snap

13849+ snap-core transformers

13850+ ];

13851+ homepage = "https://github.com/faylang/snaplet-fay";

13852+ description = "Fay integration for Snap with request- and pre-compilation";

13853+ license = stdenv.lib.licenses.bsd3;

13854+ }) {};

13855+ "socks" = callPackage

13856+ ({ mkDerivation, base, bytestring, cereal, network }:

13857+ mkDerivation {

13858+ pname = "socks";

13859+ version = "0.5.4";

13860+ sha256 = "1nmldlwxqasmg359i2aa3a903gi3lmnlspvf12xk49jrg3mf3dg9";

13861+ configureFlags = [

13862+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13863+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13864+ "-fsplitbase" "-f-test-hlint"

13865+ ];

13866+ enableSeparateDataOutput = true;

13867+ libraryHaskellDepends = [ base bytestring cereal network ];

13868+ homepage = "http://github.com/vincenthz/hs-socks";

13869+ description = "Socks proxy (version 5) implementation";

13870+ license = stdenv.lib.licenses.bsd3;

13871+ }) {};

13872+ "sodium" = callPackage

13873+ ({ mkDerivation, base, containers, mtl }:

13874+ mkDerivation {

13875+ pname = "sodium";

13876+ version = "0.11.0.2";

13877+ sha256 = "0m3ig6nqkw0m6xh6ijgr2w06i4ydyfwx7rsbkrrxflichadm9r2g";

13878+ configureFlags = [

13879+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13880+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13881+ "-fsplitbase" "-f-test-hlint"

13882+ ];

13883+ libraryHaskellDepends = [ base containers mtl ];

13884+ description = "Sodium Reactive Programming (FRP) System";

13885+ license = stdenv.lib.licenses.bsd3;

13886+ }) {};

13887+ "sourcemap" = callPackage

13888+ ({ mkDerivation, aeson, attoparsec, base, bytestring, process, text

13889+ , unordered-containers, utf8-string

13890+ }:

13891+ mkDerivation {

13892+ pname = "sourcemap";

13893+ version = "0.1.3.0";

13894+ sha256 = "1flfsjs2z2zjzqwvmc2vcibvxh19s89ah4s560xr2s5mhdqwbkk5";

13895+ revision = "1";

13896+ editedCabalFile = "0lr0rb1xln9ya1hycbnby7wl2hmlh4sav4d3l0nn8c3gvd6ng2xa";

13897+ configureFlags = [

13898+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13899+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13900+ "-fsplitbase" "-f-test-hlint"

13901+ ];

13902+ libraryHaskellDepends = [

13903+ aeson attoparsec base bytestring process text unordered-containers

13904+ utf8-string

13905+ ];

13906+ description = "Implementation of source maps as proposed by Google and Mozilla";

13907+ license = stdenv.lib.licenses.bsd3;

13908+ }) {};

13909+ "speculation" = callPackage

13910+ ({ mkDerivation, base, ghc-prim, stm, transformers }:

13911+ mkDerivation {

13912+ pname = "speculation";

13913+ version = "1.5.0.1";

13914+ sha256 = "1kjshccmfnigb2dxq0czn3c1ckdflz6bl1q60h38qp3rc7250ml0";

13915+ configureFlags = [

13916+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13917+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13918+ "-fsplitbase" "-f-test-hlint"

13919+ ];

13920+ libraryHaskellDepends = [ base ghc-prim stm transformers ];

13921+ homepage = "http://github.com/ekmett/speculation";

13922+ description = "A framework for safe, programmable, speculative parallelism";

13923+ license = stdenv.lib.licenses.bsd3;

13924+ }) {};

13925+ "sphinx" = callPackage

13926+ ({ mkDerivation, base, binary, bytestring, data-binary-ieee754

13927+ , network, text, text-icu, xml

13928+ }:

13929+ mkDerivation {

13930+ pname = "sphinx";

13931+ version = "0.6.0.1";

13932+ sha256 = "1pcm4y9k5lc00805ddv519cx4j3qld2v1dnbckg38n9dyp96wj98";

13933+ configureFlags = [

13934+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13935+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13936+ "-fsplitbase" "-f-test-hlint"

13937+ ];

13938+ libraryHaskellDepends = [

13939+ base binary bytestring data-binary-ieee754 network text text-icu

13940+ xml

13941+ ];

13942+ homepage = "https://github.com/gregwebs/haskell-sphinx-client";

13943+ description = "Haskell bindings to the Sphinx full-text searching daemon";

13944+ license = stdenv.lib.licenses.bsd3;

13945+ }) {};

13946+ "split" = callPackage

13947+ ({ mkDerivation, base, QuickCheck }:

13948+ mkDerivation {

13949+ pname = "split";

13950+ version = "0.2.2";

13951+ sha256 = "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr";

13952+ revision = "2";

13953+ editedCabalFile = "1hcmy8npnn0jb3frmkc2is97v55q15vmb1y1mgrjf1l8l6238sq6";

13954+ configureFlags = [

13955+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13956+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13957+ "-fsplitbase" "-f-test-hlint"

13958+ ];

13959+ libraryHaskellDepends = [ base ];

13960+ testHaskellDepends = [ base QuickCheck ];

13961+ description = "Combinator library for splitting lists";

13962+ license = stdenv.lib.licenses.bsd3;

13963+ }) {};

13964+ "spoon" = callPackage

13965+ ({ mkDerivation, base, deepseq }:

13966+ mkDerivation {

13967+ pname = "spoon";

13968+ version = "0.3.1";

13969+ sha256 = "1m41k0mfy6fpfrv2ym4m5jsjaj9xdfl2iqpppd3c4d0fffv51cxr";

13970+ revision = "1";

13971+ editedCabalFile = "09s5jjcsg4g4qxchq9g2l4i9d5zh3rixpkbiysqcgl69kj8mwv74";

13972+ configureFlags = [

13973+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13974+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13975+ "-fsplitbase" "-f-test-hlint"

13976+ ];

13977+ libraryHaskellDepends = [ base deepseq ];

13978+ description = "Catch errors thrown from pure computations";

13979+ license = stdenv.lib.licenses.bsd3;

13980+ }) {};

13981+ "sqlite-simple" = callPackage

13982+ ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder

13983+ , blaze-textual, bytestring, containers, direct-sqlite, HUnit, text

13984+ , time, transformers

13985+ }:

13986+ mkDerivation {

13987+ pname = "sqlite-simple";

13988+ version = "0.4.8.0";

13989+ sha256 = "098d1s80wlvsp307422f79bm3a9knvgw5ni6jap62fl4rpa7fsmz";

13990+ configureFlags = [

13991+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13992+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13993+ "-fsplitbase" "-f-test-hlint"

13994+ ];

13995+ libraryHaskellDepends = [

13996+ attoparsec base blaze-builder blaze-textual bytestring containers

13997+ direct-sqlite text time transformers

13998+ ];

13999+ testHaskellDepends = [

14000+ base base16-bytestring bytestring direct-sqlite HUnit text time

14001+ ];

14002+ homepage = "http://github.com/nurpax/sqlite-simple";

14003+ description = "Mid-Level SQLite client library";

14004+ license = stdenv.lib.licenses.bsd3;

14005+ }) {};

14006+ "stateref" = callPackage

14007+ ({ mkDerivation, base, mtl, stm }:

14008+ mkDerivation {

14009+ pname = "stateref";

14010+ version = "0.3";

14011+ sha256 = "0hdpw6g255lj7jjvgqwhjdpzmka546vda5qjvry8gjj6nfm91lvx";

14012+ configureFlags = [

14013+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14014+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14015+ "-fsplitbase" "-f-test-hlint"

14016+ ];

14017+ libraryHaskellDepends = [ base mtl stm ];

14018+ homepage = "http://code.haskell.org/~mokus/stateref/";

14019+ description = "Abstraction for things that work like IORef";

14020+ license = stdenv.lib.licenses.publicDomain;

14021+ }) {};

14022+ "statestack" = callPackage

14023+ ({ mkDerivation, base, mtl, transformers }:

14024+ mkDerivation {

14025+ pname = "statestack";

14026+ version = "0.2.0.3";

14027+ sha256 = "0w5vw8jmnwbfyma4a3ggdm9jvxf3c18kpwbvcmvr5szifaqv9sgx";

14028+ configureFlags = [

14029+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14030+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14031+ "-fsplitbase" "-f-test-hlint"

14032+ ];

14033+ libraryHaskellDepends = [ base mtl transformers ];

14034+ description = "Simple State-like monad transformer with saveable and restorable state";

14035+ license = stdenv.lib.licenses.bsd3;

14036+ }) {};

14037+ "statistics" = callPackage

14038+ ({ mkDerivation, aeson, base, binary, deepseq, erf, HUnit, ieee754

14039+ , math-functions, monad-par, mwc-random, primitive, QuickCheck

14040+ , test-framework, test-framework-hunit, test-framework-quickcheck2

14041+ , vector, vector-algorithms, vector-binary-instances

14042+ }:

14043+ mkDerivation {

14044+ pname = "statistics";

14045+ version = "0.13.2.1";

14046+ sha256 = "0giibqpnjndnhvxqsr8ikcxxfhz3ws0mk3ckykq2sfwz7gkipvva";

14047+ configureFlags = [

14048+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14049+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14050+ "-fsplitbase" "-f-test-hlint"

14051+ ];

14052+ libraryHaskellDepends = [

14053+ aeson base binary deepseq erf math-functions monad-par mwc-random

14054+ primitive vector vector-algorithms vector-binary-instances

14055+ ];

14056+ testHaskellDepends = [

14057+ base binary erf HUnit ieee754 math-functions mwc-random primitive

14058+ QuickCheck test-framework test-framework-hunit

14059+ test-framework-quickcheck2 vector vector-algorithms

14060+ ];

14061+ doHaddock = false;

14062+ doCheck = false;

14063+ homepage = "https://github.com/bos/statistics";

14064+ description = "A library of statistical types, data, and functions";

14065+ license = stdenv.lib.licenses.bsd3;

14066+ }) {};

14067+ "statistics-linreg" = callPackage

14068+ ({ mkDerivation, base, MonadRandom, random, random-shuffle, safe

14069+ , statistics, vector

14070+ }:

14071+ mkDerivation {

14072+ pname = "statistics-linreg";

14073+ version = "0.3";

14074+ sha256 = "02c9xrd3b8iy7bwgsf1r06smi88k3sgpqv2ivr782wl0dcbc4wv2";

14075+ configureFlags = [

14076+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14077+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14078+ "-fsplitbase" "-f-test-hlint"

14079+ ];

14080+ libraryHaskellDepends = [

14081+ base MonadRandom random random-shuffle safe statistics vector

14082+ ];

14083+ homepage = "http://github.com/alpmestan/statistics-linreg";

14084+ description = "Linear regression between two samples, based on the 'statistics' package";

14085+ license = stdenv.lib.licenses.mit;

14086+ }) {};

14087+ "stm" = callPackage

14088+ ({ mkDerivation, array, base }:

14089+ mkDerivation {

14090+ pname = "stm";

14091+ version = "2.4.3";

14092+ sha256 = "0vzw4s06d5scfy4ircl81ym8ylkw9ckzsp8rq950dvipmaj1xhis";

14093+ configureFlags = [

14094+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14095+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14096+ "-fsplitbase" "-f-test-hlint"

14097+ ];

14098+ libraryHaskellDepends = [ array base ];

14099+ description = "Software Transactional Memory";

14100+ license = stdenv.lib.licenses.bsd3;

14101+ }) {};

14102+ "stm-chans" = callPackage

14103+ ({ mkDerivation, base, stm }:

14104+ mkDerivation {

14105+ pname = "stm-chans";

14106+ version = "3.0.0.2";

14107+ sha256 = "1zsa092yjxsdq8nm2yqagdfpip3i3ff3xdwvys99ns7ridxbyynh";

14108+ configureFlags = [

14109+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14110+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14111+ "-fsplitbase" "-f-test-hlint"

14112+ ];

14113+ libraryHaskellDepends = [ base stm ];

14114+ homepage = "http://code.haskell.org/~wren/";

14115+ description = "Additional types of channels for STM";

14116+ license = stdenv.lib.licenses.bsd3;

14117+ }) {};

14118+ "stm-conduit" = callPackage

14119+ ({ mkDerivation, async, base, cereal, cereal-conduit, conduit

14120+ , conduit-extra, directory, HUnit, lifted-async, lifted-base

14121+ , monad-control, monad-loops, QuickCheck, resourcet, stm, stm-chans

14122+ , test-framework, test-framework-hunit, test-framework-quickcheck2

14123+ , transformers

14124+ }:

14125+ mkDerivation {

14126+ pname = "stm-conduit";

14127+ version = "2.5.2";

14128+ sha256 = "1r8l9nznavxd0cg30mj7qdp9nq8jlcr0vcv8ljn6lfw67s0pk82x";

14129+ configureFlags = [

14130+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14131+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14132+ "-fsplitbase" "-f-test-hlint"

14133+ ];

14134+ libraryHaskellDepends = [

14135+ async base cereal cereal-conduit conduit conduit-extra directory

14136+ lifted-async lifted-base monad-control monad-loops resourcet stm

14137+ stm-chans transformers

14138+ ];

14139+ testHaskellDepends = [

14140+ base conduit directory HUnit QuickCheck resourcet stm stm-chans

14141+ test-framework test-framework-hunit test-framework-quickcheck2

14142+ transformers

14143+ ];

14144+ homepage = "https://github.com/wowus/stm-conduit";

14145+ description = "Introduces conduits to channels, and promotes using conduits concurrently";

14146+ license = stdenv.lib.licenses.bsd3;

14147+ }) {};

14148+ "stm-containers" = callPackage

14149+ ({ mkDerivation, base, base-prelude, focus, free, hashable, HTF

14150+ , list-t, loch-th, mtl, mtl-prelude, placeholders, primitive

14151+ , QuickCheck, transformers, unordered-containers

14152+ }:

14153+ mkDerivation {

14154+ pname = "stm-containers";

14155+ version = "0.2.4";

14156+ sha256 = "0qwyy0znd97w52kq9azg9bnc6578x1wvfhknh7qd8sz50gz19qwy";

14157+ configureFlags = [

14158+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14159+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14160+ "-fsplitbase" "-f-test-hlint"

14161+ ];

14162+ libraryHaskellDepends = [

14163+ base-prelude focus hashable list-t loch-th placeholders primitive

14164+ transformers

14165+ ];

14166+ testHaskellDepends = [

14167+ base base-prelude focus free hashable HTF list-t loch-th mtl

14168+ mtl-prelude placeholders primitive QuickCheck transformers

14169+ unordered-containers

14170+ ];

14171+ doHaddock = false;

14172+ doCheck = false;

14173+ homepage = "https://github.com/nikita-volkov/stm-containers";

14174+ description = "Containers for STM";

14175+ license = stdenv.lib.licenses.mit;

14176+ }) {};

14177+ "stm-stats" = callPackage

14178+ ({ mkDerivation, base, containers, stm, template-haskell, time }:

14179+ mkDerivation {

14180+ pname = "stm-stats";

14181+ version = "0.2.0.0";

14182+ sha256 = "0i8ky2l8lvh7nymxglvbifp0ylbyjw20p75avzb51zpzx6qkjkqa";

14183+ configureFlags = [

14184+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14185+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14186+ "-fsplitbase" "-f-test-hlint"

14187+ ];

14188+ libraryHaskellDepends = [

14189+ base containers stm template-haskell time

14190+ ];

14191+ description = "retry statistics for STM transactions";

14192+ license = stdenv.lib.licenses.bsd3;

14193+ }) {};

14194+ "storable-complex" = callPackage

14195+ ({ mkDerivation, base }:

14196+ mkDerivation {

14197+ pname = "storable-complex";

14198+ version = "0.2.1";

14199+ sha256 = "0dnxnsi7m5whwwki3fry6db6gyy5qzfz8jcj1fg3fhfyf4f9wpaz";

14200+ revision = "1";

14201+ editedCabalFile = "1hspdlyn44c7wd08fxmc5zsc93pzd7ckr8rankz30wzn44kib215";

14202+ configureFlags = [

14203+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14204+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14205+ "-fsplitbase" "-f-test-hlint"

14206+ ];

14207+ libraryHaskellDepends = [ base ];

14208+ description = "Storable instance for Complex";

14209+ license = stdenv.lib.licenses.bsd3;

14210+ }) {};

14211+ "storable-endian" = callPackage

14212+ ({ mkDerivation, base, byteorder }:

14213+ mkDerivation {

14214+ pname = "storable-endian";

14215+ version = "0.2.5";

14216+ sha256 = "04j1nk0wga4dqrqvhm8yd9h9194db1n3yrnhg8s3gsc0jk7yw1p2";

14217+ configureFlags = [

14218+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14219+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14220+ "-fsplitbase" "-f-test-hlint"

14221+ ];

14222+ libraryHaskellDepends = [ base byteorder ];

14223+ description = "Storable instances with endianness";

14224+ license = stdenv.lib.licenses.bsd3;

14225+ }) {};

14226+ "streaming-commons" = callPackage

14227+ ({ mkDerivation, array, async, base, blaze-builder, bytestring

14228+ , criterion, deepseq, directory, hspec, network, process

14229+ , QuickCheck, random, stm, text, transformers, unix, zlib

14230+ }:

14231+ mkDerivation {

14232+ pname = "streaming-commons";

14233+ version = "0.1.7.3";

14234+ sha256 = "12sm59dhjrygly215888i2xcsn5m5a393ir0mm6w62883x49wzxb";

14235+ revision = "1";

14236+ editedCabalFile = "0wq9j3gjknmhhxvj9nb63z9kax3f6vwvybxfjcpw6jdzg48yaj7w";

14237+ configureFlags = [

14238+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14239+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14240+ "-fsplitbase" "-f-test-hlint"

14241+ ];

14242+ libraryHaskellDepends = [

14243+ array base blaze-builder bytestring directory network process

14244+ random stm text transformers unix zlib

14245+ ];

14246+ testHaskellDepends = [

14247+ array async base blaze-builder bytestring deepseq hspec network

14248+ QuickCheck text unix zlib

14249+ ];

14250+ benchmarkHaskellDepends = [ base bytestring criterion text ];

14251+ homepage = "https://github.com/fpco/streaming-commons";

14252+ description = "Common lower-level functions needed by various streaming data libraries";

14253+ license = stdenv.lib.licenses.mit;

14254+ }) {};

14255+ "streams" = callPackage

14256+ ({ mkDerivation, adjunctions, base, comonad, distributive

14257+ , semigroupoids, semigroups

14258+ }:

14259+ mkDerivation {

14260+ pname = "streams";

14261+ version = "3.2";

14262+ sha256 = "1pms4wiispnpzysq44fcvspdxmbwk47rfcpcyshnnhpw7c7qngni";

14263+ revision = "1";

14264+ editedCabalFile = "0lrdskf575kdlm7rh99g49yyj3ynkg9gzdcdfwf4pjy7gm49sj5g";

14265+ configureFlags = [

14266+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14267+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14268+ "-fsplitbase" "-f-test-hlint"

14269+ ];

14270+ libraryHaskellDepends = [

14271+ adjunctions base comonad distributive semigroupoids semigroups

14272+ ];

14273+ homepage = "http://github.com/ekmett/streams/issues";

14274+ description = "Various Haskell 2010 stream comonads";

14275+ license = stdenv.lib.licenses.bsd3;

14276+ }) {};

14277+ "strict" = callPackage

14278+ ({ mkDerivation, array, base }:

14279+ mkDerivation {

14280+ pname = "strict";

14281+ version = "0.3.2";

14282+ sha256 = "08cjajqz9h47fkq98mlf3rc8n5ghbmnmgn8pfsl3bdldjdkmmlrc";

14283+ configureFlags = [

14284+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14285+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14286+ "-fsplitbase" "-f-test-hlint"

14287+ ];

14288+ libraryHaskellDepends = [ array base ];

14289+ homepage = "http://www.cse.unsw.edu.au/~rl/code/strict.html";

14290+ description = "Strict data types and String IO";

14291+ license = stdenv.lib.licenses.bsd3;

14292+ }) {};

14293+ "stringable" = callPackage

14294+ ({ mkDerivation, base, bytestring, system-filepath, text }:

14295+ mkDerivation {

14296+ pname = "stringable";

14297+ version = "0.1.3";

14298+ sha256 = "10jsvbiqbmnbipv1566k5mqkpgfyrzbk8m7b18rqjb5m3qg9dbz7";

14299+ configureFlags = [

14300+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14301+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14302+ "-fsplitbase" "-f-test-hlint"

14303+ ];

14304+ libraryHaskellDepends = [ base bytestring system-filepath text ];

14305+ description = "A Stringable type class, in the spirit of Foldable and Traversable";

14306+ license = stdenv.lib.licenses.mit;

14307+ }) {};

14308+ "stringbuilder" = callPackage

14309+ ({ mkDerivation, base, hspec, QuickCheck }:

14310+ mkDerivation {

14311+ pname = "stringbuilder";

14312+ version = "0.5.0";

14313+ sha256 = "1ap95xphqnrhv64c2a137wqslkdmb2jjd9ldb17gs1pw48k8hrl9";

14314+ configureFlags = [

14315+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14316+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14317+ "-fsplitbase" "-f-test-hlint"

14318+ ];

14319+ libraryHaskellDepends = [ base ];

14320+ testHaskellDepends = [ base hspec QuickCheck ];

14321+ description = "A writer monad for multi-line string literals";

14322+ license = stdenv.lib.licenses.mit;

14323+ }) {};

14324+ "stringprep" = callPackage

14325+ ({ mkDerivation, base, containers, QuickCheck, tasty

14326+ , tasty-quickcheck, tasty-th, text, text-icu

14327+ }:

14328+ mkDerivation {

14329+ pname = "stringprep";

14330+ version = "1.0.0";

14331+ sha256 = "0ha4cvzdppd514xh9315v3nvrn1q4xd74gifdqpszw98hj2mw0b0";

14332+ configureFlags = [

14333+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14334+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14335+ "-fsplitbase" "-f-test-hlint"

14336+ ];

14337+ libraryHaskellDepends = [ base containers text text-icu ];

14338+ testHaskellDepends = [

14339+ base containers QuickCheck tasty tasty-quickcheck tasty-th text

14340+ text-icu

14341+ ];

14342+ description = "Implements the \"StringPrep\" algorithm";

14343+ license = stdenv.lib.licenses.bsd3;

14344+ }) {};

14345+ "stringsearch" = callPackage

14346+ ({ mkDerivation, array, base, bytestring, containers }:

14347+ mkDerivation {

14348+ pname = "stringsearch";

14349+ version = "0.3.6.5";

14350+ sha256 = "1mjvb1qr4fkxv5qvq4jfswa3dcj3dwzvwx7dbp2wqw8zand41lsq";

14351+ revision = "1";

14352+ editedCabalFile = "1igl3rj889gn94yy0svk8vj9ygdsgiz01b5j67nzpd6nwigdl43s";

14353+ configureFlags = [

14354+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14355+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14356+ "-fsplitbase" "-f-test-hlint"

14357+ ];

14358+ libraryHaskellDepends = [ array base bytestring containers ];

14359+ homepage = "https://bitbucket.org/dafis/stringsearch";

14360+ description = "Fast searching, splitting and replacing of ByteStrings";

14361+ license = stdenv.lib.licenses.bsd3;

14362+ }) {};

14363+ "stylish-haskell" = callPackage

14364+ ({ mkDerivation, aeson, base, bytestring, cmdargs, containers

14365+ , directory, filepath, haskell-src-exts, HUnit, mtl, strict, syb

14366+ , test-framework, test-framework-hunit, yaml

14367+ }:

14368+ mkDerivation {

14369+ pname = "stylish-haskell";

14370+ version = "0.5.11.0";

14371+ sha256 = "1174gs5a2n6l2flyb2x93yiq7viwb52kbadw6jya6041xrpblckz";

14372+ configureFlags = [

14373+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14374+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14375+ "-fsplitbase" "-f-test-hlint"

14376+ ];

14377+ isLibrary = true;

14378+ isExecutable = true;

14379+ enableSeparateDataOutput = true;

14380+ libraryHaskellDepends = [

14381+ aeson base bytestring containers directory filepath

14382+ haskell-src-exts mtl syb yaml

14383+ ];

14384+ executableHaskellDepends = [

14385+ aeson base bytestring cmdargs containers directory filepath

14386+ haskell-src-exts mtl strict syb yaml

14387+ ];

14388+ testHaskellDepends = [

14389+ aeson base bytestring cmdargs containers directory filepath

14390+ haskell-src-exts HUnit mtl syb test-framework test-framework-hunit

14391+ yaml

14392+ ];

14393+ homepage = "https://github.com/jaspervdj/stylish-haskell";

14394+ description = "Haskell code prettifier";

14395+ license = stdenv.lib.licenses.bsd3;

14396+ }) {};

14397+ "syb" = callPackage

14398+ ({ mkDerivation, base, containers, HUnit, mtl }:

14399+ mkDerivation {

14400+ pname = "syb";

14401+ version = "0.4.2";

14402+ sha256 = "1gvyw2gbccip24wpp9xi6qgwvg4m5cijhzz1v51wvyamqv4p2b8l";

14403+ revision = "1";

14404+ editedCabalFile = "0nh7vs9dc2j7r7lm8142gb6yavhjqhfnmq6wjgyyd9b1m67lgzqn";

14405+ configureFlags = [

14406+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14407+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14408+ "-fsplitbase" "-f-test-hlint"

14409+ ];

14410+ libraryHaskellDepends = [ base ];

14411+ testHaskellDepends = [ base containers HUnit mtl ];

14412+ homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB";

14413+ description = "Scrap Your Boilerplate";

14414+ license = stdenv.lib.licenses.bsd3;

14415+ }) {};

14416+ "syb-with-class" = callPackage

14417+ ({ mkDerivation, array, base, bytestring, containers

14418+ , template-haskell

14419+ }:

14420+ mkDerivation {

14421+ pname = "syb-with-class";

14422+ version = "0.6.1.5";

14423+ sha256 = "1gn4p92jabgvbk7bg1nzjimyfzznl800bi9hw4ssvc7jqqnyw5zn";

14424+ configureFlags = [

14425+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14426+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14427+ "-fsplitbase" "-f-test-hlint"

14428+ ];

14429+ libraryHaskellDepends = [

14430+ array base bytestring containers template-haskell

14431+ ];

14432+ description = "Scrap Your Boilerplate With Class";

14433+ license = stdenv.lib.licenses.bsd3;

14434+ }) {};

14435+ "system-canonicalpath" = callPackage

14436+ ({ mkDerivation, base, basic-prelude, directory, system-filepath

14437+ , text

14438+ }:

14439+ mkDerivation {

14440+ pname = "system-canonicalpath";

14441+ version = "0.2.0.0";

14442+ sha256 = "130zfchx3clj26vhg54ilab0m4hnfn9vkga8vylcwdpfnglziyk9";

14443+ configureFlags = [

14444+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14445+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14446+ "-fsplitbase" "-f-test-hlint"

14447+ ];

14448+ libraryHaskellDepends = [

14449+ base basic-prelude directory system-filepath text

14450+ ];

14451+ homepage = "https://github.com/d12frosted/CanonicalPath";

14452+ description = "Abstract data type for canonical paths with pretty operations";

14453+ license = stdenv.lib.licenses.mit;

14454+ }) {};

14455+ "system-fileio" = callPackage

14456+ ({ mkDerivation, base, bytestring, chell, system-filepath

14457+ , temporary, text, time, transformers, unix

14458+ }:

14459+ mkDerivation {

14460+ pname = "system-fileio";

14461+ version = "0.3.15";

14462+ sha256 = "06cnr3hzw8xd75529nfqajgb5xy5i4ddqybgjw1v1nwpq04mhihi";

14463+ revision = "1";

14464+ editedCabalFile = "1b5fja8c05ipq6ss85k0bj8dw140vzch8wia9j7rals9w6vfhdvr";

14465+ configureFlags = [

14466+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14467+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14468+ "-fsplitbase" "-f-test-hlint"

14469+ ];

14470+ libraryHaskellDepends = [

14471+ base bytestring system-filepath text time unix

14472+ ];

14473+ testHaskellDepends = [

14474+ base bytestring chell system-filepath temporary text time

14475+ transformers unix

14476+ ];

14477+ homepage = "https://john-millikin.com/software/haskell-filesystem/";

14478+ description = "Consistent filesystem interaction across GHC versions";

14479+ license = stdenv.lib.licenses.mit;

14480+ }) {};

14481+ "system-filepath" = callPackage

14482+ ({ mkDerivation, base, bytestring, chell, chell-quickcheck, deepseq

14483+ , QuickCheck, text

14484+ }:

14485+ mkDerivation {

14486+ pname = "system-filepath";

14487+ version = "0.4.12";

14488+ sha256 = "0sfralwgd5b9hfqmp20v31sq96s0v7j9g920qdj3n9i5mhslhwd2";

14489+ revision = "1";

14490+ editedCabalFile = "09vdxm7gl2xr2i0dy9iqcdxdvv78mgl7pkb2zwz1fmd57xiw6wvv";

14491+ configureFlags = [

14492+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14493+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14494+ "-fsplitbase" "-f-test-hlint"

14495+ ];

14496+ libraryHaskellDepends = [ base bytestring deepseq text ];

14497+ testHaskellDepends = [

14498+ base bytestring chell chell-quickcheck QuickCheck text

14499+ ];

14500+ doHaddock = false;

14501+ doCheck = false;

14502+ homepage = "https://john-millikin.com/software/haskell-filesystem/";

14503+ description = "High-level, byte-based file and directory path manipulations";

14504+ license = stdenv.lib.licenses.mit;

14505+ }) {};

14506+ "system-posix-redirect" = callPackage

14507+ ({ mkDerivation, base, bytestring, unix }:

14508+ mkDerivation {

14509+ pname = "system-posix-redirect";

14510+ version = "1.1.0.1";

14511+ sha256 = "1wkfz898d3607xnx779l1k1qc8i2k63ixg47542r45scwq8m0lsk";

14512+ configureFlags = [

14513+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14514+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14515+ "-fsplitbase" "-f-test-hlint"

14516+ ];

14517+ libraryHaskellDepends = [ base bytestring unix ];

14518+ description = "A toy module to temporarily redirect a program's stdout";

14519+ license = stdenv.lib.licenses.bsd3;

14520+ }) {};

14521+ "tabular" = callPackage

14522+ ({ mkDerivation, base, csv, html, mtl }:

14523+ mkDerivation {

14524+ pname = "tabular";

14525+ version = "0.2.2.5";

14526+ sha256 = "00d1f8yr7kbg30ziv09pb8f4apcvrfb6izb26my1s97kw9ixa740";

14527+ revision = "1";

14528+ editedCabalFile = "0pyhxddgn6w3d192fjkkzm6yvbys64r738najyk9l00q6120f6ly";

14529+ configureFlags = [

14530+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14531+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14532+ "-fsplitbase" "-f-test-hlint"

14533+ ];

14534+ enableSeparateDataOutput = true;

14535+ libraryHaskellDepends = [ base csv html mtl ];

14536+ homepage = "http://hub.darcs.net/kowey/tabular";

14537+ description = "Two-dimensional data tables with rendering functions";

14538+ license = stdenv.lib.licenses.bsd3;

14539+ }) {};

14540+ "tagged" = callPackage

14541+ ({ mkDerivation, base }:

14542+ mkDerivation {

14543+ pname = "tagged";

14544+ version = "0.7.3";

14545+ sha256 = "016bzws7w09xhyyqiz56ahlf7zhagihn370ga0083fgv172lym7b";

14546+ configureFlags = [

14547+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14548+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14549+ "-fsplitbase" "-f-test-hlint"

14550+ ];

14551+ libraryHaskellDepends = [ base ];

14552+ homepage = "http://github.com/ekmett/tagged";

14553+ description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments";

14554+ license = stdenv.lib.licenses.bsd3;

14555+ }) {};

14556+ "tagshare" = callPackage

14557+ ({ mkDerivation, base, containers, mtl }:

14558+ mkDerivation {

14559+ pname = "tagshare";

14560+ version = "0.0";

14561+ sha256 = "1q3chp1rmwmxa8rxv7548wsvbqbng6grrnv1587p08385sp4ncfj";

14562+ configureFlags = [

14563+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14564+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14565+ "-fsplitbase" "-f-test-hlint"

14566+ ];

14567+ libraryHaskellDepends = [ base containers mtl ];

14568+ description = "TagShare - explicit sharing with tags";

14569+ license = stdenv.lib.licenses.bsd3;

14570+ }) {};

14571+ "tagsoup" = callPackage

14572+ ({ mkDerivation, base, bytestring, containers, text }:

14573+ mkDerivation {

14574+ pname = "tagsoup";

14575+ version = "0.13.3";

14576+ sha256 = "13b6zy6346r3cxhaivys84fnxarg8wbv7r2znazfjdkqil8n5a1j";

14577+ configureFlags = [

14578+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14579+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14580+ "-fsplitbase" "-f-test-hlint"

14581+ ];

14582+ isLibrary = true;

14583+ isExecutable = true;

14584+ libraryHaskellDepends = [ base bytestring containers text ];

14585+ homepage = "http://community.haskell.org/~ndm/tagsoup/";

14586+ description = "Parsing and extracting information from (possibly malformed) HTML/XML documents";

14587+ license = stdenv.lib.licenses.bsd3;

14588+ }) {};

14589+ "tagstream-conduit" = callPackage

14590+ ({ mkDerivation, attoparsec, base, blaze-builder, bytestring

14591+ , case-insensitive, conduit, conduit-extra, data-default, hspec

14592+ , HUnit, QuickCheck, resourcet, text, transformers, xml-conduit

14593+ }:

14594+ mkDerivation {

14595+ pname = "tagstream-conduit";

14596+ version = "0.5.5.3";

14597+ sha256 = "1arlf7qil9bzcqykda8yyrnncm29jsfjvz5kbcdrbbhqpbqfi5mj";

14598+ configureFlags = [

14599+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14600+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14601+ "-fsplitbase" "-f-test-hlint"

14602+ ];

14603+ libraryHaskellDepends = [

14604+ attoparsec base blaze-builder bytestring case-insensitive conduit

14605+ conduit-extra data-default resourcet text transformers xml-conduit

14606+ ];

14607+ testHaskellDepends = [

14608+ base bytestring conduit hspec HUnit QuickCheck resourcet text

14609+ ];

14610+ homepage = "http://github.com/yihuang/tagstream-conduit";

14611+ description = "streamlined html tag parser";

14612+ license = stdenv.lib.licenses.bsd3;

14613+ }) {};

14614+ "tar" = callPackage

14615+ ({ mkDerivation, base, bytestring, directory, filepath, old-time

14616+ , time

14617+ }:

14618+ mkDerivation {

14619+ pname = "tar";

14620+ version = "0.4.0.1";

14621+ sha256 = "0vbsv7h3zgp30mlgsw156jkv1rqy5zbm98as9haf7x15hd6jf254";

14622+ revision = "1";

14623+ editedCabalFile = "1r3mcy11y2vym6y995n95fsrpvhgbxlwwbl4h4qymiyrwhmpjlqn";

14624+ configureFlags = [

14625+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14626+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14627+ "-fsplitbase" "-f-test-hlint"

14628+ ];

14629+ libraryHaskellDepends = [

14630+ base bytestring directory filepath old-time time

14631+ ];

14632+ description = "Reading, writing and manipulating \".tar\" archive files.";

14633+ license = stdenv.lib.licenses.bsd3;

14634+ }) {};

14635+ "tardis" = callPackage

14636+ ({ mkDerivation, base, mtl }:

14637+ mkDerivation {

14638+ pname = "tardis";

14639+ version = "0.3.0.0";

14640+ sha256 = "15f88b5qg4v1ah60y0jxkww9n6z7gvnkslx4inckh6m6c7yvj8k6";

14641+ configureFlags = [

14642+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14643+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14644+ "-fsplitbase" "-f-test-hlint"

14645+ ];

14646+ libraryHaskellDepends = [ base mtl ];

14647+ homepage = "https://github.com/DanBurton/tardis";

14648+ description = "Bidirectional state monad transformer";

14649+ license = stdenv.lib.licenses.bsd3;

14650+ }) {};

14651+ "tasty" = callPackage

14652+ ({ mkDerivation, ansi-terminal, async, base, containers, deepseq

14653+ , mtl, optparse-applicative, regex-tdfa-rc, stm, tagged, time

14654+ , unbounded-delays

14655+ }:

14656+ mkDerivation {

14657+ pname = "tasty";

14658+ version = "0.10.1";

14659+ sha256 = "1l8ah7018f3m8css56h59fcly1jhanm5wd0hbgm8mg6pn7rrjml5";

14660+ revision = "2";

14661+ editedCabalFile = "0xi507m5w8dbg8hvsaiy0fzsm96l2j5b30kw860la7lkjb2h69wd";

14662+ configureFlags = [

14663+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14664+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14665+ "-fsplitbase" "-f-test-hlint"

14666+ ];

14667+ libraryHaskellDepends = [

14668+ ansi-terminal async base containers deepseq mtl

14669+ optparse-applicative regex-tdfa-rc stm tagged time unbounded-delays

14670+ ];

14671+ homepage = "http://documentup.com/feuerbach/tasty";

14672+ description = "Modern and extensible testing framework";

14673+ license = stdenv.lib.licenses.mit;

14674+ }) {};

14675+ "tasty-ant-xml" = callPackage

14676+ ({ mkDerivation, base, containers, generic-deriving, ghc-prim, mtl

14677+ , stm, tagged, tasty, transformers, xml

14678+ }:

14679+ mkDerivation {

14680+ pname = "tasty-ant-xml";

14681+ version = "1.0.1";

14682+ sha256 = "1wb9lm9rbk46g9cm2lpcrzh59zpcy270p824agg61bj1xb9jymsc";

14683+ configureFlags = [

14684+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14685+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14686+ "-fsplitbase" "-f-test-hlint"

14687+ ];

14688+ libraryHaskellDepends = [

14689+ base containers generic-deriving ghc-prim mtl stm tagged tasty

14690+ transformers xml

14691+ ];

14692+ homepage = "http://github.com/ocharles/tasty-ant-xml";

14693+ description = "Render tasty output to XML for Jenkins";

14694+ license = stdenv.lib.licenses.bsd3;

14695+ }) {};

14696+ "tasty-golden" = callPackage

14697+ ({ mkDerivation, async, base, bytestring, containers, deepseq

14698+ , directory, filepath, mtl, optparse-applicative, process, tagged

14699+ , tasty, tasty-hunit, temporary-rc

14700+ }:

14701+ mkDerivation {

14702+ pname = "tasty-golden";

14703+ version = "2.2.2.4";

14704+ sha256 = "096c4h306r4z7wq8nm94mwmdndm0mwd6hhiqf77iilpdndasrl1c";

14705+ revision = "1";

14706+ editedCabalFile = "0s59gkp12p7wkkd5dk5k1bg3k8b7q98lxsjknw1bi8a22gx055n2";

14707+ configureFlags = [

14708+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14709+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14710+ "-fsplitbase" "-f-test-hlint"

14711+ ];

14712+ libraryHaskellDepends = [

14713+ async base bytestring containers deepseq directory filepath mtl

14714+ optparse-applicative process tagged tasty temporary-rc

14715+ ];

14716+ testHaskellDepends = [

14717+ base directory filepath process tasty tasty-hunit temporary-rc

14718+ ];

14719+ homepage = "https://github.com/feuerbach/tasty-golden";

14720+ description = "Golden tests support for tasty";

14721+ license = stdenv.lib.licenses.mit;

14722+ }) {};

14723+ "tasty-hunit" = callPackage

14724+ ({ mkDerivation, base, tasty }:

14725+ mkDerivation {

14726+ pname = "tasty-hunit";

14727+ version = "0.9.0.1";

14728+ sha256 = "0rhdjb4fakcbkz4cvmmf679zad9h5yr31i1g9xm1338p6xd4vwcb";

14729+ configureFlags = [

14730+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14731+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14732+ "-fsplitbase" "-f-test-hlint"

14733+ ];

14734+ libraryHaskellDepends = [ base tasty ];

14735+ homepage = "http://documentup.com/feuerbach/tasty";

14736+ description = "HUnit support for the Tasty test framework";

14737+ license = stdenv.lib.licenses.mit;

14738+ }) {};

14739+ "tasty-quickcheck" = callPackage

14740+ ({ mkDerivation, base, pcre-light, QuickCheck, tagged, tasty

14741+ , tasty-hunit

14742+ }:

14743+ mkDerivation {

14744+ pname = "tasty-quickcheck";

14745+ version = "0.8.3.2";

14746+ sha256 = "1q1fghmsjrdl6jkcnajmsvw4d893m6cyhzpai9vvrhxy9vdy0l1v";

14747+ configureFlags = [

14748+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14749+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14750+ "-fsplitbase" "-f-test-hlint"

14751+ ];

14752+ libraryHaskellDepends = [ base QuickCheck tagged tasty ];

14753+ testHaskellDepends = [ base pcre-light tasty tasty-hunit ];

14754+ homepage = "http://documentup.com/feuerbach/tasty";

14755+ description = "QuickCheck support for the Tasty test framework";

14756+ license = stdenv.lib.licenses.mit;

14757+ }) {};

14758+ "tasty-smallcheck" = callPackage

14759+ ({ mkDerivation, async, base, smallcheck, tagged, tasty }:

14760+ mkDerivation {

14761+ pname = "tasty-smallcheck";

14762+ version = "0.8.0.1";

14763+ sha256 = "0yckfbz8na8ccyw2911i3a4hd3fdncclk3ng5343hs5cylw6y4sm";

14764+ configureFlags = [

14765+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14766+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14767+ "-fsplitbase" "-f-test-hlint"

14768+ ];

14769+ libraryHaskellDepends = [ async base smallcheck tagged tasty ];

14770+ homepage = "http://documentup.com/feuerbach/tasty";

14771+ description = "SmallCheck support for the Tasty test framework";

14772+ license = stdenv.lib.licenses.bsd3;

14773+ }) {};

14774+ "tasty-th" = callPackage

14775+ ({ mkDerivation, base, language-haskell-extract, tasty

14776+ , template-haskell

14777+ }:

14778+ mkDerivation {

14779+ pname = "tasty-th";

14780+ version = "0.1.3";

14781+ sha256 = "1fl5pagm9bdqvp7v54ilkr91m667rxw1jifwfdhrikr938aqrzx3";

14782+ configureFlags = [

14783+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14784+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14785+ "-fsplitbase" "-f-test-hlint"

14786+ ];

14787+ libraryHaskellDepends = [

14788+ base language-haskell-extract tasty template-haskell

14789+ ];

14790+ homepage = "http://github.com/bennofs/tasty-th";

14791+ description = "Automagically generate the HUnit- and Quickcheck-bulk-code using Template Haskell";

14792+ license = stdenv.lib.licenses.bsd3;

14793+ }) {};

14794+ "temporary" = callPackage

14795+ ({ mkDerivation, base, directory, exceptions, filepath

14796+ , transformers, unix

14797+ }:

14798+ mkDerivation {

14799+ pname = "temporary";

14800+ version = "1.2.0.3";

14801+ sha256 = "0is67bmsjmbbw6wymhis8wyq9gax3sszm573p5719fx2c9z9r24a";

14802+ configureFlags = [

14803+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14804+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14805+ "-fsplitbase" "-f-test-hlint"

14806+ ];

14807+ libraryHaskellDepends = [

14808+ base directory exceptions filepath transformers unix

14809+ ];

14810+ homepage = "http://www.github.com/batterseapower/temporary";

14811+ description = "Portable temporary file and directory support for Windows and Unix, based on code from Cabal";

14812+ license = stdenv.lib.licenses.bsd3;

14813+ }) {};

14814+ "temporary-rc" = callPackage

14815+ ({ mkDerivation, base, directory, exceptions, filepath

14816+ , transformers, unix

14817+ }:

14818+ mkDerivation {

14819+ pname = "temporary-rc";

14820+ version = "1.2.0.3";

14821+ sha256 = "1nqih0qks439k3pr5kmbbc8rjdw730slrxlflqb27fbxbzb8skqs";

14822+ configureFlags = [

14823+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14824+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14825+ "-fsplitbase" "-f-test-hlint"

14826+ ];

14827+ libraryHaskellDepends = [

14828+ base directory exceptions filepath transformers unix

14829+ ];

14830+ homepage = "http://www.github.com/feuerbach/temporary";

14831+ description = "Portable temporary file and directory support for Windows and Unix, based on code from Cabal";

14832+ license = stdenv.lib.licenses.bsd3;

14833+ }) {};

14834+ "terminal-progress-bar" = callPackage

14835+ ({ mkDerivation, base, base-unicode-symbols, HUnit, stm, stm-chans

14836+ , test-framework, test-framework-hunit

14837+ }:

14838+ mkDerivation {

14839+ pname = "terminal-progress-bar";

14840+ version = "0.0.1.4";

14841+ sha256 = "0ldvii23ks446xrd27aklh8s8pn1yi3dzhhzl05gipjqbhq3lsx3";

14842+ configureFlags = [

14843+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14844+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14845+ "-fsplitbase" "-f-test-hlint"

14846+ ];

14847+ libraryHaskellDepends = [

14848+ base base-unicode-symbols stm stm-chans

14849+ ];

14850+ testHaskellDepends = [

14851+ base base-unicode-symbols HUnit test-framework test-framework-hunit

14852+ ];

14853+ homepage = "https://github.com/roelvandijk/terminal-progress-bar";

14854+ description = "A simple progress bar in the terminal";

14855+ license = stdenv.lib.licenses.bsd3;

14856+ }) {};

14857+ "terminal-size" = callPackage

14858+ ({ mkDerivation, base }:

14859+ mkDerivation {

14860+ pname = "terminal-size";

14861+ version = "0.3.0";

14862+ sha256 = "0g8v08d20hlfsah9dlgv2v2pzj0m4dva0zp6zi4jrkxjhg6vi7bw";

14863+ configureFlags = [

14864+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14865+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14866+ "-fsplitbase" "-f-test-hlint"

14867+ ];

14868+ libraryHaskellDepends = [ base ];

14869+ description = "Get terminal window height and width";

14870+ license = stdenv.lib.licenses.bsd3;

14871+ }) {};

14872+ "test-framework" = callPackage

14873+ ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, containers

14874+ , hostname, old-locale, random, regex-posix, time, xml

14875+ }:

14876+ mkDerivation {

14877+ pname = "test-framework";

14878+ version = "0.8.0.3";

14879+ sha256 = "136nw5dapsz3jrnw1pdfkjgplxigpr2mrf6i85154vx342zvw5ar";

14880+ revision = "1";

14881+ editedCabalFile = "0jkzp2q0ljigdaxgw53qzzs1zcj5fypsk1a44yhkyc8sk9n5fdxn";

14882+ configureFlags = [

14883+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14884+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14885+ "-fsplitbase" "-f-test-hlint"

14886+ ];

14887+ isLibrary = true;

14888+ isExecutable = true;

14889+ libraryHaskellDepends = [

14890+ ansi-terminal ansi-wl-pprint base containers hostname old-locale

14891+ random regex-posix time xml

14892+ ];

14893+ homepage = "https://batterseapower.github.io/test-framework/";

14894+ description = "Framework for running and organising tests, with HUnit and QuickCheck support";

14895+ license = stdenv.lib.licenses.bsd3;

14896+ }) {};

14897+ "test-framework-hunit" = callPackage

14898+ ({ mkDerivation, base, extensible-exceptions, HUnit, test-framework

14899+ }:

14900+ mkDerivation {

14901+ pname = "test-framework-hunit";

14902+ version = "0.3.0.1";

14903+ sha256 = "1h0h55kf6ff25nbfx1mhliwyknc0glwv3zi78wpzllbjbs7gvyfk";

14904+ revision = "1";

14905+ editedCabalFile = "0aabb5lksl75yc75rfscgsv2aiazkz3hyx6j9mpis8nwcykmaqgg";

14906+ configureFlags = [

14907+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14908+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14909+ "-fsplitbase" "-f-test-hlint"

14910+ ];

14911+ libraryHaskellDepends = [

14912+ base extensible-exceptions HUnit test-framework

14913+ ];

14914+ homepage = "https://batterseapower.github.io/test-framework/";

14915+ description = "HUnit support for the test-framework package";

14916+ license = stdenv.lib.licenses.bsd3;

14917+ }) {};

14918+ "test-framework-quickcheck2" = callPackage

14919+ ({ mkDerivation, base, extensible-exceptions, QuickCheck, random

14920+ , test-framework

14921+ }:

14922+ mkDerivation {

14923+ pname = "test-framework-quickcheck2";

14924+ version = "0.3.0.3";

14925+ sha256 = "12p1zwrsz35r3j5gzbvixz9z1h5643rhihf5gqznmc991krwd5nc";

14926+ revision = "4";

14927+ editedCabalFile = "1j1lk0xpbdfvp42h6c34yq1snhl1mk6sf393raxvakfl0l7nybqd";

14928+ configureFlags = [

14929+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14930+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14931+ "-fsplitbase" "-f-test-hlint"

14932+ ];

14933+ libraryHaskellDepends = [

14934+ base extensible-exceptions QuickCheck random test-framework

14935+ ];

14936+ homepage = "https://batterseapower.github.io/test-framework/";

14937+ description = "QuickCheck2 support for the test-framework package";

14938+ license = stdenv.lib.licenses.bsd3;

14939+ }) {};

14940+ "test-framework-th" = callPackage

14941+ ({ mkDerivation, base, haskell-src-exts, language-haskell-extract

14942+ , regex-posix, template-haskell, test-framework

14943+ }:

14944+ mkDerivation {

14945+ pname = "test-framework-th";

14946+ version = "0.2.4";

14947+ sha256 = "12lw7yj02jb9s0i7rb98jjam43j2h0gzmnbj9zi933fx7sg0sy4b";

14948+ configureFlags = [

14949+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14950+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14951+ "-fsplitbase" "-f-test-hlint"

14952+ ];

14953+ libraryHaskellDepends = [

14954+ base haskell-src-exts language-haskell-extract regex-posix

14955+ template-haskell test-framework

14956+ ];

14957+ homepage = "http://github.com/finnsson/test-generator";

14958+ description = "Automagically generate the HUnit- and Quickcheck-bulk-code using Template Haskell";

14959+ license = stdenv.lib.licenses.bsd3;

14960+ }) {};

14961+ "testing-feat" = callPackage

14962+ ({ mkDerivation, base, mtl, QuickCheck, tagshare, template-haskell

14963+ }:

14964+ mkDerivation {

14965+ pname = "testing-feat";

14966+ version = "0.4.0.2";

14967+ sha256 = "15gi6w7p4alnih9grklhhr8338y1aal07admbz4n2f724hnhyb2j";

14968+ revision = "1";

14969+ editedCabalFile = "0gyxqh0g30ldzc7hdkadkvjwbdyjqnk14g53h0gpl3mcx7hxss01";

14970+ configureFlags = [

14971+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14972+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14973+ "-fsplitbase" "-f-test-hlint"

14974+ ];

14975+ libraryHaskellDepends = [

14976+ base mtl QuickCheck tagshare template-haskell

14977+ ];

14978+ description = "Functional Enumeration of Algebraic Types";

14979+ license = stdenv.lib.licenses.bsd3;

14980+ }) {};

14981+ "testpack" = callPackage

14982+ ({ mkDerivation, base, containers, HUnit, mtl, QuickCheck, random

14983+ }:

14984+ mkDerivation {

14985+ pname = "testpack";

14986+ version = "2.1.3.0";

14987+ sha256 = "1rq5d64d7j3gpgbfxmfr4xmzizjy0ricw5ghrakv8gzvxmi2bn4p";

14988+ revision = "1";

14989+ editedCabalFile = "0fdgxw04gx1ai31bk0cyck9qfqpn10yfgjaazc15r2ngjpbbqqy7";

14990+ configureFlags = [

14991+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14992+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14993+ "-fsplitbase" "-f-test-hlint"

14994+ ];

14995+ libraryHaskellDepends = [

14996+ base containers HUnit mtl QuickCheck random

14997+ ];

14998+ homepage = "https://github.com/jgoerzen/testpack";

14999+ description = "Test Utililty Pack for HUnit and QuickCheck (unmaintained)";

15000+ license = "LGPL";

15001+ }) {};

15002+ "texmath" = callPackage

15003+ ({ mkDerivation, base, bytestring, containers, directory, filepath

15004+ , mtl, pandoc-types, parsec, process, split, syb, temporary, text

15005+ , utf8-string, xml

15006+ }:

15007+ mkDerivation {

15008+ pname = "texmath";

15009+ version = "0.8";

15010+ sha256 = "1j0i9594fqhl2fzxyndyy6fvrpaqdarq817pxdar0hmccy55b7gb";

15011+ configureFlags = [

15012+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15013+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15014+ "-fsplitbase" "-f-test-hlint"

15015+ ];

15016+ isLibrary = true;

15017+ isExecutable = true;

15018+ libraryHaskellDepends = [

15019+ base containers mtl pandoc-types parsec syb xml

15020+ ];

15021+ testHaskellDepends = [

15022+ base bytestring directory filepath process split temporary text

15023+ utf8-string xml

15024+ ];

15025+ homepage = "http://github.com/jgm/texmath";

15026+ description = "Conversion between formats used to represent mathematics";

15027+ license = "GPL";

15028+ }) {};

15029+ "text" = callPackage

15030+ ({ mkDerivation, array, base, bytestring, deepseq, directory

15031+ , ghc-prim, HUnit, integer-gmp, QuickCheck, random, test-framework

15032+ , test-framework-hunit, test-framework-quickcheck2

15033+ }:

15034+ mkDerivation {

15035+ pname = "text";

15036+ version = "1.1.1.3";

15037+ sha256 = "1yrzg449nbbzh2fb9mdmf2jjfhk2g87kr9m2ibssbsqx53p98z0c";

15038+ revision = "1";

15039+ editedCabalFile = "1f0j4v8saagz4bvbwhranvq09bk55zfqbbdlbj5zpywml4qv7123";

15040+ configureFlags = [

15041+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15042+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15043+ "-fsplitbase" "-f-test-hlint"

15044+ ];

15045+ libraryHaskellDepends = [

15046+ array base bytestring deepseq ghc-prim integer-gmp

15047+ ];

15048+ testHaskellDepends = [

15049+ array base bytestring deepseq directory ghc-prim HUnit integer-gmp

15050+ QuickCheck random test-framework test-framework-hunit

15051+ test-framework-quickcheck2

15052+ ];

15053+ doHaddock = false;

15054+ doCheck = false;

15055+ homepage = "https://github.com/bos/text";

15056+ description = "An efficient packed Unicode text type";

15057+ license = stdenv.lib.licenses.bsd3;

15058+ }) {};

15059+ "text-binary" = callPackage

15060+ ({ mkDerivation, base, binary, text }:

15061+ mkDerivation {

15062+ pname = "text-binary";

15063+ version = "0.1.0";

15064+ sha256 = "0wc501j8hqspnhf4d1hyb18f1wgc4kl2qx1b5s4bkxv0dfbwrk6z";

15065+ revision = "2";

15066+ editedCabalFile = "06aig24xj1n7jvbajnk0xjdimpb1wx84nv6bdv3mbpxk4rzj091m";

15067+ configureFlags = [

15068+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15069+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15070+ "-fsplitbase" "-f-test-hlint"

15071+ ];

15072+ libraryHaskellDepends = [ base binary text ];

15073+ homepage = "https://github.com/kawu/text-binary";

15074+ description = "Binary instances for text types";

15075+ license = stdenv.lib.licenses.bsd3;

15076+ }) {};

15077+ "text-format" = callPackage

15078+ ({ mkDerivation, array, base, double-conversion, ghc-prim

15079+ , integer-gmp, old-locale, text, time, transformers

15080+ }:

15081+ mkDerivation {

15082+ pname = "text-format";

15083+ version = "0.3.1.1";

15084+ sha256 = "02zfgzfjvkaxbma1h2gr95h10c8q9gyaadag41q579j68iv15qbd";

15085+ configureFlags = [

15086+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15087+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15088+ "-fsplitbase" "-f-test-hlint"

15089+ ];

15090+ libraryHaskellDepends = [

15091+ array base double-conversion ghc-prim integer-gmp old-locale text

15092+ time transformers

15093+ ];

15094+ homepage = "https://github.com/bos/text-format";

15095+ description = "Text formatting";

15096+ license = stdenv.lib.licenses.bsd3;

15097+ }) {};

15098+ "text-icu" = callPackage

15099+ ({ mkDerivation, array, base, bytestring, deepseq, directory

15100+ , ghc-prim, HUnit, icu, QuickCheck, random, test-framework

15101+ , test-framework-hunit, test-framework-quickcheck2, text

15102+ }:

15103+ mkDerivation {

15104+ pname = "text-icu";

15105+ version = "0.7.0.0";

15106+ sha256 = "1fvq6qi9kvw722v2m9d40vwwa2irswfapqfjcrym9c2swdagxnry";

15107+ revision = "2";

15108+ editedCabalFile = "07dqh8inkz7m0v65rl1npvg48g73vg5d192n6rwkgacczz54whqr";

15109+ configureFlags = [

15110+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15111+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15112+ "-fsplitbase" "-f-test-hlint"

15113+ ];

15114+ libraryHaskellDepends = [ base bytestring deepseq text ];

15115+ librarySystemDepends = [ icu ];

15116+ testHaskellDepends = [

15117+ array base bytestring deepseq directory ghc-prim HUnit QuickCheck

15118+ random test-framework test-framework-hunit

15119+ test-framework-quickcheck2 text

15120+ ];

15121+ homepage = "https://github.com/bos/text-icu";

15122+ description = "Bindings to the ICU library";

15123+ license = stdenv.lib.licenses.bsd3;

15124+ }) {inherit (pkgs) icu;};

15125+ "tf-random" = callPackage

15126+ ({ mkDerivation, base, primitive, random, time }:

15127+ mkDerivation {

15128+ pname = "tf-random";

15129+ version = "0.5";

15130+ sha256 = "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f";

15131+ configureFlags = [

15132+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15133+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15134+ "-fsplitbase" "-f-test-hlint"

15135+ ];

15136+ libraryHaskellDepends = [ base primitive random time ];

15137+ description = "High-quality splittable pseudorandom number generator";

15138+ license = stdenv.lib.licenses.bsd3;

15139+ }) {};

15140+ "th-desugar" = callPackage

15141+ ({ mkDerivation, base, containers, hspec, HUnit, mtl, syb

15142+ , template-haskell

15143+ }:

15144+ mkDerivation {

15145+ pname = "th-desugar";

15146+ version = "1.4.2";

15147+ sha256 = "16l0khjx2wppnm9spp6mg659m95hxjkzfv3pjw5ays3z6clhx8b9";

15148+ revision = "1";

15149+ editedCabalFile = "0ciba862l9df0xxhkxida504ppvnzh3q86c4jhi2nkja4fvmri8y";

15150+ configureFlags = [

15151+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15152+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15153+ "-fsplitbase" "-f-test-hlint"

15154+ ];

15155+ libraryHaskellDepends = [

15156+ base containers mtl syb template-haskell

15157+ ];

15158+ testHaskellDepends = [

15159+ base containers hspec HUnit mtl syb template-haskell

15160+ ];

15161+ doHaddock = false;

15162+ doCheck = false;

15163+ homepage = "http://www.cis.upenn.edu/~eir/packages/th-desugar";

15164+ description = "Functions to desugar Template Haskell";

15165+ license = stdenv.lib.licenses.bsd3;

15166+ }) {};

15167+ "th-expand-syns" = callPackage

15168+ ({ mkDerivation, base, containers, syb, template-haskell }:

15169+ mkDerivation {

15170+ pname = "th-expand-syns";

15171+ version = "0.3.0.4";

15172+ sha256 = "05qgfam7zq02848icvddds67ch5d8py7r30izg4lp0df0kzn08yq";

15173+ revision = "1";

15174+ editedCabalFile = "060bj09vm0g2ldrjl58ffg5wpk4lzwa7a4hyjghl6yaa9kfgnrx0";

15175+ configureFlags = [

15176+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15177+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15178+ "-fsplitbase" "-f-test-hlint"

15179+ ];

15180+ libraryHaskellDepends = [ base containers syb template-haskell ];

15181+ description = "Expands type synonyms in Template Haskell ASTs";

15182+ license = stdenv.lib.licenses.bsd3;

15183+ }) {};

15184+ "th-extras" = callPackage

15185+ ({ mkDerivation, base, syb, template-haskell }:

15186+ mkDerivation {

15187+ pname = "th-extras";

15188+ version = "0.0.0.2";

15189+ sha256 = "15sqf2jjnqcssq8hp80fk0ysgwqykjjc31gvvmzg4sypskpjs8cl";

15190+ revision = "1";

15191+ editedCabalFile = "0ryzvqav51wdwfagmg71kq1ljgfqs9a3zr4pzmc2fcc8vapbvpyr";

15192+ configureFlags = [

15193+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15194+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15195+ "-fsplitbase" "-f-test-hlint"

15196+ ];

15197+ libraryHaskellDepends = [ base syb template-haskell ];

15198+ homepage = "https://github.com/mokus0/th-extras";

15199+ description = "A grab bag of functions for use with Template Haskell";

15200+ license = stdenv.lib.licenses.publicDomain;

15201+ }) {};

15202+ "th-lift" = callPackage

15203+ ({ mkDerivation, base, template-haskell }:

15204+ mkDerivation {

15205+ pname = "th-lift";

15206+ version = "0.7";

15207+ sha256 = "1mh5k6ifmc3mjavlrpkcq55ng737yb3nqv1q67fv8irkv5m6qpza";

15208+ revision = "2";

15209+ editedCabalFile = "1mdf0zv65025fma8v6gxi3hf3ikjbkfydh74i0axw8cnwa6y29wc";

15210+ configureFlags = [

15211+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15212+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15213+ "-fsplitbase" "-f-test-hlint"

15214+ ];

15215+ libraryHaskellDepends = [ base template-haskell ];

15216+ testHaskellDepends = [ base template-haskell ];

15217+ homepage = "http://github.com/mboes/th-lift";

15218+ description = "Derive Template Haskell's Lift class for datatypes";

15219+ license = stdenv.lib.licenses.bsd3;

15220+ }) {};

15221+ "th-orphans" = callPackage

15222+ ({ mkDerivation, base, template-haskell, th-lift, th-reify-many }:

15223+ mkDerivation {

15224+ pname = "th-orphans";

15225+ version = "0.8.2";

15226+ sha256 = "19d4ls2plxmn5n9c99503mvi99ffp6y6zxi564zf6cdfgw8v73fy";

15227+ revision = "1";

15228+ editedCabalFile = "0584ik7bakaywvib3grwg4qzz4fcsbp486k7xhd7jc4r6nbhp6cs";

15229+ configureFlags = [

15230+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15231+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15232+ "-fsplitbase" "-f-test-hlint"

15233+ ];

15234+ libraryHaskellDepends = [

15235+ base template-haskell th-lift th-reify-many

15236+ ];

15237+ description = "Orphan instances for TH datatypes";

15238+ license = stdenv.lib.licenses.bsd3;

15239+ }) {};

15240+ "th-reify-many" = callPackage

15241+ ({ mkDerivation, base, containers, mtl, safe, template-haskell

15242+ , th-expand-syns

15243+ }:

15244+ mkDerivation {

15245+ pname = "th-reify-many";

15246+ version = "0.1.2";

15247+ sha256 = "1r7ran4vi2mrhcr6qil89cni6ci3dgm775lfw5ciml3gz1948vz9";

15248+ revision = "1";

15249+ editedCabalFile = "0cdgbcz0gcmbnjghk4aj5viwz306zi32ikvxk062wkk4jk006r7y";

15250+ configureFlags = [

15251+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15252+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15253+ "-fsplitbase" "-f-test-hlint"

15254+ ];

15255+ libraryHaskellDepends = [

15256+ base containers mtl safe template-haskell th-expand-syns

15257+ ];

15258+ homepage = "http://github.com/mgsloan/th-reify-many";

15259+ description = "Recurseively reify template haskell datatype info";

15260+ license = stdenv.lib.licenses.bsd3;

15261+ }) {};

15262+ "threads" = callPackage

15263+ ({ mkDerivation, base, base-unicode-symbols, concurrent-extra

15264+ , HUnit, stm, test-framework, test-framework-hunit

15265+ }:

15266+ mkDerivation {

15267+ pname = "threads";

15268+ version = "0.5.1.2";

15269+ sha256 = "1bq2aza6sam4zkgpgf8x4lhkk2na1i8annx9cwad3j68p5vdg929";

15270+ configureFlags = [

15271+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15272+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15273+ "-fsplitbase" "-f-test-hlint"

15274+ ];

15275+ libraryHaskellDepends = [ base base-unicode-symbols stm ];

15276+ testHaskellDepends = [

15277+ base base-unicode-symbols concurrent-extra HUnit stm test-framework

15278+ test-framework-hunit

15279+ ];

15280+ doHaddock = false;

15281+ doCheck = false;

15282+ homepage = "https://github.com/basvandijk/threads";

15283+ description = "Fork threads and wait for their result";

15284+ license = stdenv.lib.licenses.bsd3;

15285+ }) {};

15286+ "thyme" = callPackage

15287+ ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal

15288+ , containers, cpphs, criterion, deepseq, directory, filepath, mtl

15289+ , old-locale, profunctors, QuickCheck, random

15290+ , system-posix-redirect, text, time, vector, vector-space

15291+ , vector-th-unbox

15292+ }:

15293+ mkDerivation {

15294+ pname = "thyme";

15295+ version = "0.3.5.5";

15296+ sha256 = "0v3rbjl92bqggsdra72zdq6rxzb2qf1268424p94225lnwgp1il4";

15297+ configureFlags = [

15298+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15299+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15300+ "-fsplitbase" "-f-test-hlint"

15301+ ];

15302+ libraryHaskellDepends = [

15303+ aeson attoparsec base bytestring containers deepseq mtl old-locale

15304+ profunctors QuickCheck random text time vector vector-space

15305+ vector-th-unbox

15306+ ];

15307+ libraryToolDepends = [ cpphs ];

15308+ testHaskellDepends = [

15309+ attoparsec base bytestring Cabal containers directory filepath mtl

15310+ old-locale profunctors QuickCheck random system-posix-redirect text

15311+ time vector-space

15312+ ];

15313+ benchmarkHaskellDepends = [

15314+ base criterion mtl old-locale profunctors QuickCheck random time

15315+ vector vector-space

15316+ ];

15317+ doHaddock = false;

15318+ doCheck = false;

15319+ homepage = "https://github.com/liyang/thyme";

15320+ description = "A faster time library";

15321+ license = stdenv.lib.licenses.bsd3;

15322+ }) {};

15323+ "time-compat" = callPackage

15324+ ({ mkDerivation, base, old-time, time }:

15325+ mkDerivation {

15326+ pname = "time-compat";

15327+ version = "0.1.0.3";

15328+ sha256 = "0zqgzr8yjn36rn6gflwh5s0c92vl44xzxiw0jz8d5h0h8lhi21sr";

15329+ configureFlags = [

15330+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15331+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15332+ "-fsplitbase" "-f-test-hlint"

15333+ ];

15334+ libraryHaskellDepends = [ base old-time time ];

15335+ homepage = "http://hub.darcs.net/dag/time-compat";

15336+ description = "Compatibility with old-time for the time package";

15337+ license = stdenv.lib.licenses.bsd3;

15338+ }) {};

15339+ "time-lens" = callPackage

15340+ ({ mkDerivation, base, data-lens-light, time }:

15341+ mkDerivation {

15342+ pname = "time-lens";

15343+ version = "0.4.0.1";

15344+ sha256 = "0916qfan93aq91icf87ifvskrq6s6s75rhkajvl8pxp74j28hlwz";

15345+ configureFlags = [

15346+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15347+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15348+ "-fsplitbase" "-f-test-hlint"

15349+ ];

15350+ libraryHaskellDepends = [ base data-lens-light time ];

15351+ description = "Lens-based interface to Data.Time data structures";

15352+ license = stdenv.lib.licenses.bsd3;

15353+ }) {};

15354+ "timezone-olson" = callPackage

15355+ ({ mkDerivation, base, binary, bytestring, extensible-exceptions

15356+ , time, timezone-series

15357+ }:

15358+ mkDerivation {

15359+ pname = "timezone-olson";

15360+ version = "0.1.6";

15361+ sha256 = "0gg1fq85km5d48966a267q6z0wwl1dz88xq88v0l1jlkwd9jsb0z";

15362+ configureFlags = [

15363+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15364+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15365+ "-fsplitbase" "-f-test-hlint"

15366+ ];

15367+ libraryHaskellDepends = [

15368+ base binary bytestring extensible-exceptions time timezone-series

15369+ ];

15370+ homepage = "http://projects.haskell.org/time-ng/";

15371+ description = "A pure Haskell parser and renderer for binary Olson timezone files";

15372+ license = stdenv.lib.licenses.bsd3;

15373+ }) {};

15374+ "timezone-series" = callPackage

15375+ ({ mkDerivation, base, time }:

15376+ mkDerivation {

15377+ pname = "timezone-series";

15378+ version = "0.1.4";

15379+ sha256 = "06p5v0dimhwmra100gwkhkz3ll492i2bvafw0qx2qzcxx4yxff40";

15380+ configureFlags = [

15381+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15382+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15383+ "-fsplitbase" "-f-test-hlint"

15384+ ];

15385+ libraryHaskellDepends = [ base time ];

15386+ homepage = "http://projects.haskell.org/time-ng/";

15387+ description = "Enhanced timezone handling for Data.Time";

15388+ license = stdenv.lib.licenses.bsd3;

15389+ }) {};

15390+ "tls" = callPackage

15391+ ({ mkDerivation, asn1-encoding, asn1-types, async, base, byteable

15392+ , bytestring, cereal, cipher-aes, cipher-des, cipher-rc4, cprng-aes

15393+ , criterion, crypto-cipher-types, crypto-numbers, crypto-pubkey

15394+ , crypto-pubkey-types, crypto-random, cryptohash

15395+ , data-default-class, hourglass, mtl, network, QuickCheck, tasty

15396+ , tasty-quickcheck, transformers, x509, x509-store, x509-validation

15397+ }:

15398+ mkDerivation {

15399+ pname = "tls";

15400+ version = "1.2.13";

15401+ sha256 = "1djjscmyn3wcnlzz1r0clz2nxa2y23rlyjk30xjsdp0m1sq0vdc3";

15402+ configureFlags = [

15403+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15404+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15405+ "-fsplitbase" "-f-test-hlint"

15406+ ];

15407+ libraryHaskellDepends = [

15408+ asn1-encoding asn1-types async base byteable bytestring cereal

15409+ cipher-aes cipher-des cipher-rc4 crypto-cipher-types crypto-numbers

15410+ crypto-pubkey crypto-pubkey-types crypto-random cryptohash

15411+ data-default-class mtl network transformers x509 x509-store

15412+ x509-validation

15413+ ];

15414+ testHaskellDepends = [

15415+ base bytestring cereal cprng-aes crypto-pubkey crypto-random

15416+ data-default-class hourglass mtl QuickCheck tasty tasty-quickcheck

15417+ x509 x509-validation

15418+ ];

15419+ benchmarkHaskellDepends = [

15420+ base bytestring cprng-aes criterion crypto-pubkey crypto-random

15421+ data-default-class hourglass mtl QuickCheck x509 x509-validation

15422+ ];

15423+ homepage = "http://github.com/vincenthz/hs-tls";

15424+ description = "TLS/SSL protocol native implementation (Server and Client)";

15425+ license = stdenv.lib.licenses.bsd3;

15426+ }) {};

15427+ "tls-debug" = callPackage

15428+ ({ mkDerivation, base, bytestring, cprng-aes, crypto-pubkey

15429+ , data-default-class, network, pem, time, tls, x509, x509-system

15430+ , x509-validation

15431+ }:

15432+ mkDerivation {

15433+ pname = "tls-debug";

15434+ version = "0.3.4";

15435+ sha256 = "08bxcl0lf07fx3xfajd99090glvgnpn5s4826g2hirr75b9a5b93";

15436+ configureFlags = [

15437+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15438+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15439+ "-fsplitbase" "-f-test-hlint"

15440+ ];

15441+ isLibrary = false;

15442+ isExecutable = true;

15443+ executableHaskellDepends = [

15444+ base bytestring cprng-aes crypto-pubkey data-default-class network

15445+ pem time tls x509 x509-system x509-validation

15446+ ];

15447+ doHaddock = false;

15448+ homepage = "http://github.com/vincenthz/hs-tls";

15449+ description = "Set of programs for TLS testing and debugging";

15450+ license = stdenv.lib.licenses.bsd3;

15451+ }) {};

15452+ "tostring" = callPackage

15453+ ({ mkDerivation, base, case-insensitive, text, utf8-string }:

15454+ mkDerivation {

15455+ pname = "tostring";

15456+ version = "0.2.1";

15457+ sha256 = "0lvfvjs1q6hndbchij3zn1xi6vb1v53r379jvyc2m92sqqcfnylw";

15458+ configureFlags = [

15459+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15460+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15461+ "-fsplitbase" "-f-test-hlint"

15462+ ];

15463+ libraryHaskellDepends = [ base case-insensitive text utf8-string ];

15464+ description = "The ToString class";

15465+ license = stdenv.lib.licenses.bsd3;

15466+ }) {};

15467+ "transformers-base" = callPackage

15468+ ({ mkDerivation, base, stm, transformers }:

15469+ mkDerivation {

15470+ pname = "transformers-base";

15471+ version = "0.4.3";

15472+ sha256 = "0bklr7piiipnh99jnqx262pdyb9hzk852d6hzk5sqppvz5ndcf4y";

15473+ revision = "1";

15474+ editedCabalFile = "0pjlcmb92fqa4hhzsmwq48ny86ihswzxrmymjcabq31yrv3ngqj8";

15475+ configureFlags = [

15476+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15477+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15478+ "-fsplitbase" "-f-test-hlint"

15479+ ];

15480+ libraryHaskellDepends = [ base stm transformers ];

15481+ homepage = "https://github.com/mvv/transformers-base";

15482+ description = "Lift computations from the bottom of a transformer stack";

15483+ license = stdenv.lib.licenses.bsd3;

15484+ }) {};

15485+ "transformers-compat" = callPackage

15486+ ({ mkDerivation, base, transformers }:

15487+ mkDerivation {

15488+ pname = "transformers-compat";

15489+ version = "0.3.3.3";

15490+ sha256 = "18cqghf0gc97j9qnlfnwwhvfm8j4sk99rm0xv3bf6ml8slk7njx7";

15491+ configureFlags = [

15492+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15493+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15494+ "-fsplitbase" "-f-test-hlint"

15495+ ];

15496+ libraryHaskellDepends = [ base transformers ];

15497+ doHaddock = false;

15498+ doCheck = false;

15499+ homepage = "http://github.com/ekmett/transformers-compat/";

15500+ description = "A small compatibility shim exposing the new types from transformers 0.3 and 0.4 to older Haskell platforms.";

15501+ license = stdenv.lib.licenses.bsd3;

15502+ }) {};

15503+ "traverse-with-class" = callPackage

15504+ ({ mkDerivation, base, template-haskell, transformers }:

15505+ mkDerivation {

15506+ pname = "traverse-with-class";

15507+ version = "0.2.0.3";

15508+ sha256 = "0snms19w3n9ni1wmf4ikwpp298nc6qk6phrjxi5g023ihqqdvr6g";

15509+ configureFlags = [

15510+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15511+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15512+ "-fsplitbase" "-f-test-hlint"

15513+ ];

15514+ libraryHaskellDepends = [ base template-haskell transformers ];

15515+ description = "Generic applicative traversals";

15516+ license = stdenv.lib.licenses.mit;

15517+ }) {};

15518+ "tree-view" = callPackage

15519+ ({ mkDerivation, base, containers, mtl }:

15520+ mkDerivation {

15521+ pname = "tree-view";

15522+ version = "0.4";

15523+ sha256 = "0mzywp6nipc6zs98dy4ny2s3r9d745lqpjazfnj5y4hx8swyckgn";

15524+ configureFlags = [

15525+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15526+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15527+ "-fsplitbase" "-f-test-hlint"

15528+ ];

15529+ libraryHaskellDepends = [ base containers mtl ];

15530+ description = "Render trees as foldable HTML and Unicode art";

15531+ license = stdenv.lib.licenses.bsd3;

15532+ }) {};

15533+ "tuple" = callPackage

15534+ ({ mkDerivation, base, OneTuple }:

15535+ mkDerivation {

15536+ pname = "tuple";

15537+ version = "0.3.0.2";

15538+ sha256 = "094nx29aahyrvbcn7yca9zs2a5rxz1is7510w1q43rpvza7hdjrg";

15539+ configureFlags = [

15540+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15541+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15542+ "-fsplitbase" "-f-test-hlint"

15543+ ];

15544+ libraryHaskellDepends = [ base OneTuple ];

15545+ description = "Various functions on tuples";

15546+ license = stdenv.lib.licenses.bsd3;

15547+ }) {};

15548+ "type-eq" = callPackage

15549+ ({ mkDerivation, base, cpphs }:

15550+ mkDerivation {

15551+ pname = "type-eq";

15552+ version = "0.4.2";

15553+ sha256 = "0nyx3lqgrnlz0l3p615ln2dglqd39jwlk91ybz7blzhq1gpgayar";

15554+ configureFlags = [

15555+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15556+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15557+ "-fsplitbase" "-f-test-hlint"

15558+ ];

15559+ libraryHaskellDepends = [ base ];

15560+ libraryToolDepends = [ cpphs ];

15561+ homepage = "http://github.com/glaebhoerl/type-eq";

15562+ description = "Type equality evidence you can carry around";

15563+ license = stdenv.lib.licenses.bsd3;

15564+ }) {};

15565+ "udbus" = callPackage

15566+ ({ mkDerivation, base, binary, bytestring, cereal, containers

15567+ , ghc-prim, mtl, network, unix, utf8-string

15568+ }:

15569+ mkDerivation {

15570+ pname = "udbus";

15571+ version = "0.2.1";

15572+ sha256 = "0a7kksh99nll91q41z4xgrcwc8pnfm0p71bxw6yymcd7yb0v09fk";

15573+ configureFlags = [

15574+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15575+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15576+ "-fsplitbase" "-f-test-hlint"

15577+ ];

15578+ isLibrary = true;

15579+ isExecutable = true;

15580+ enableSeparateDataOutput = true;

15581+ libraryHaskellDepends = [

15582+ base binary bytestring cereal containers ghc-prim mtl network unix

15583+ utf8-string

15584+ ];

15585+ homepage = "http://github.com/vincenthz/hs-udbus";

15586+ description = "Small DBus implementation";

15587+ license = stdenv.lib.licenses.bsd3;

15588+ }) {};

15589+ "unbounded-delays" = callPackage

15590+ ({ mkDerivation, base }:

15591+ mkDerivation {

15592+ pname = "unbounded-delays";

15593+ version = "0.1.0.8";

15594+ sha256 = "1jdlpg82kndz6g97bw8fb6sjyyvylrcrg982xnhgi36717f0pv40";

15595+ configureFlags = [

15596+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15597+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15598+ "-fsplitbase" "-f-test-hlint"

15599+ ];

15600+ libraryHaskellDepends = [ base ];

15601+ homepage = "https://github.com/basvandijk/unbounded-delays";

15602+ description = "Unbounded thread delays and timeouts";

15603+ license = stdenv.lib.licenses.bsd3;

15604+ }) {};

15605+ "union-find" = callPackage

15606+ ({ mkDerivation, base, containers, transformers }:

15607+ mkDerivation {

15608+ pname = "union-find";

15609+ version = "0.2";

15610+ sha256 = "1v7hj42j9w6jlzi56jg8rh4p58gfs1c5dx30wd1qqvn0p0mnihp6";

15611+ revision = "1";

15612+ editedCabalFile = "13cwjh03n82sgshbk4fdlvhc0pb3v979sdcdrpvnpjdqmvcprs92";

15613+ configureFlags = [

15614+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15615+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15616+ "-fsplitbase" "-f-test-hlint"

15617+ ];

15618+ libraryHaskellDepends = [ base containers transformers ];

15619+ homepage = "http://github.com/nominolo/union-find";

15620+ description = "Efficient union and equivalence testing of sets";

15621+ license = stdenv.lib.licenses.bsd3;

15622+ }) {};

15623+ "uniplate" = callPackage

15624+ ({ mkDerivation, base, containers, hashable, syb

15625+ , unordered-containers

15626+ }:

15627+ mkDerivation {

15628+ pname = "uniplate";

15629+ version = "1.6.12";

15630+ sha256 = "1dx8f9aw27fz8kw0ad1nm6355w5rdl7bjvb427v2bsgnng30pipw";

15631+ configureFlags = [

15632+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15633+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15634+ "-fsplitbase" "-f-test-hlint"

15635+ ];

15636+ libraryHaskellDepends = [

15637+ base containers hashable syb unordered-containers

15638+ ];

15639+ homepage = "http://community.haskell.org/~ndm/uniplate/";

15640+ description = "Help writing simple, concise and fast generic operations";

15641+ license = stdenv.lib.licenses.bsd3;

15642+ }) {};

15643+ "unix-compat" = callPackage

15644+ ({ mkDerivation, base, unix }:

15645+ mkDerivation {

15646+ pname = "unix-compat";

15647+ version = "0.4.1.3";

15648+ sha256 = "1vfw3ffzdk9mshhgyp3dnbn8rihkz8qg6n5zqak8966dsdqhm4xb";

15649+ revision = "1";

15650+ editedCabalFile = "1by9rr09gww1fi48w7nzhzmmgkllv2ahlcazpmwdi4r8ac9d0ddk";

15651+ configureFlags = [

15652+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15653+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15654+ "-fsplitbase" "-f-test-hlint"

15655+ ];

15656+ libraryHaskellDepends = [ base unix ];

15657+ homepage = "http://github.com/jystic/unix-compat";

15658+ description = "Portable POSIX-compatibility layer";

15659+ license = stdenv.lib.licenses.bsd3;

15660+ }) {};

15661+ "unix-time" = callPackage

15662+ ({ mkDerivation, base, binary, bytestring, doctest, hspec

15663+ , old-locale, old-time, QuickCheck, time

15664+ }:

15665+ mkDerivation {

15666+ pname = "unix-time";

15667+ version = "0.3.4";

15668+ sha256 = "1bni03bzayg3vwj6mwcl4z41zixv8nida8jc3vkv41fr7mzb24g5";

15669+ configureFlags = [

15670+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15671+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15672+ "-fsplitbase" "-f-test-hlint"

15673+ ];

15674+ libraryHaskellDepends = [ base binary bytestring old-time ];

15675+ testHaskellDepends = [

15676+ base bytestring doctest hspec old-locale old-time QuickCheck time

15677+ ];

15678+ doHaddock = false;

15679+ doCheck = false;

15680+ description = "Unix time parser/formatter and utilities";

15681+ license = stdenv.lib.licenses.bsd3;

15682+ }) {};

15683+ "unordered-containers" = callPackage

15684+ ({ mkDerivation, base, bytestring, ChasingBottoms, containers

15685+ , criterion, deepseq, hashable, hashmap, HUnit, mtl, QuickCheck

15686+ , random, test-framework, test-framework-hunit

15687+ , test-framework-quickcheck2

15688+ }:

15689+ mkDerivation {

15690+ pname = "unordered-containers";

15691+ version = "0.2.5.1";

15692+ sha256 = "06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f";

15693+ revision = "1";

15694+ editedCabalFile = "0kbd4c2vfv10w8biqfhf4n5gljjy6y23x4qi84gnrpp6riaqhfsp";

15695+ configureFlags = [

15696+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15697+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15698+ "-fsplitbase" "-f-test-hlint"

15699+ ];

15700+ libraryHaskellDepends = [ base deepseq hashable ];

15701+ testHaskellDepends = [

15702+ base ChasingBottoms containers hashable HUnit QuickCheck

15703+ test-framework test-framework-hunit test-framework-quickcheck2

15704+ ];

15705+ benchmarkHaskellDepends = [

15706+ base bytestring containers criterion deepseq hashable hashmap mtl

15707+ random

15708+ ];

15709+ homepage = "https://github.com/tibbe/unordered-containers";

15710+ description = "Efficient hashing-based container types";

15711+ license = stdenv.lib.licenses.bsd3;

15712+ }) {};

15713+ "uri-encode" = callPackage

15714+ ({ mkDerivation, base, bytestring, network, text, utf8-string }:

15715+ mkDerivation {

15716+ pname = "uri-encode";

15717+ version = "1.5.0.3";

15718+ sha256 = "115wnc7x7gx57qza5az4c1wy0n2f40634529jk0vpxw6bb9b1mzn";

15719+ revision = "1";

15720+ editedCabalFile = "1gjkbxxwamv6vak2iqn1byxh3z98d13z2nr1y533dv78bjj72ps5";

15721+ configureFlags = [

15722+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15723+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15724+ "-fsplitbase" "-f-test-hlint"

15725+ ];

15726+ isLibrary = true;

15727+ isExecutable = true;

15728+ libraryHaskellDepends = [

15729+ base bytestring network text utf8-string

15730+ ];

15731+ description = "Unicode aware uri-encoding";

15732+ license = "unknown";

15733+ }) {};

15734+ "url" = callPackage

15735+ ({ mkDerivation, base, utf8-string }:

15736+ mkDerivation {

15737+ pname = "url";

15738+ version = "2.1.3";

15739+ sha256 = "0qag18wbrq9jjk1444mjigz1xl7xl03fz66b1lnya9qaihzpxwjs";

15740+ configureFlags = [

15741+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15742+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15743+ "-fsplitbase" "-f-test-hlint"

15744+ ];

15745+ libraryHaskellDepends = [ base utf8-string ];

15746+ homepage = "http://www.haskell.org/haskellwiki/Url";

15747+ description = "A library for working with URLs";

15748+ license = stdenv.lib.licenses.bsd3;

15749+ }) {};

15750+ "utf8-light" = callPackage

15751+ ({ mkDerivation, base, bytestring, ghc-prim }:

15752+ mkDerivation {

15753+ pname = "utf8-light";

15754+ version = "0.4.2";

15755+ sha256 = "0rwyc5z331yfnm4hpx0sph6i1zvkd1z10vvglhnp0vc9wy644k0q";

15756+ configureFlags = [

15757+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15758+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15759+ "-fsplitbase" "-f-test-hlint"

15760+ ];

15761+ libraryHaskellDepends = [ base bytestring ghc-prim ];

15762+ description = "Unicode";

15763+ license = stdenv.lib.licenses.bsd3;

15764+ }) {};

15765+ "utf8-string" = callPackage

15766+ ({ mkDerivation, base, bytestring }:

15767+ mkDerivation {

15768+ pname = "utf8-string";

15769+ version = "0.3.8";

15770+ sha256 = "1h29dn0scsfkhmkg14ywq9178lw40ah1r36w249zfzqr02y7qxc0";

15771+ revision = "2";

15772+ editedCabalFile = "1zwrnnyay7nxsi0v8v9cdy5qa06kzy8h6l6w5cs6bzvg08hdfm85";

15773+ configureFlags = [

15774+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15775+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15776+ "-fsplitbase" "-f-test-hlint"

15777+ ];

15778+ libraryHaskellDepends = [ base bytestring ];

15779+ homepage = "http://github.com/glguy/utf8-string/";

15780+ description = "Support for reading and writing UTF8 Strings";

15781+ license = stdenv.lib.licenses.bsd3;

15782+ }) {};

15783+ "uuid" = callPackage

15784+ ({ mkDerivation, base, binary, bytestring, cryptohash, deepseq

15785+ , hashable, HUnit, network-info, QuickCheck, random, test-framework

15786+ , test-framework-hunit, test-framework-quickcheck2, time

15787+ }:

15788+ mkDerivation {

15789+ pname = "uuid";

15790+ version = "1.3.5";

15791+ sha256 = "1pbla9fqadk5ia42c45qvdn1617gl8nv3b0bsb5yy3lh414v32q9";

15792+ configureFlags = [

15793+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15794+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15795+ "-fsplitbase" "-f-test-hlint"

15796+ ];

15797+ libraryHaskellDepends = [

15798+ base binary bytestring cryptohash deepseq hashable network-info

15799+ random time

15800+ ];

15801+ testHaskellDepends = [

15802+ base bytestring HUnit QuickCheck random test-framework

15803+ test-framework-hunit test-framework-quickcheck2

15804+ ];

15805+ homepage = "http://projects.haskell.org/uuid/";

15806+ description = "For creating, comparing, parsing and printing Universally Unique Identifiers";

15807+ license = stdenv.lib.licenses.bsd3;

15808+ }) {};

15809+ "vault" = callPackage

15810+ ({ mkDerivation, base, containers, hashable, unordered-containers

15811+ }:

15812+ mkDerivation {

15813+ pname = "vault";

15814+ version = "0.3.0.3";

15815+ sha256 = "0wpj73jbwgcva1hfjc0bpf9l3lfc3iwdz70m29dh1785wvzxhsh5";

15816+ configureFlags = [

15817+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15818+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15819+ "-fsplitbase" "-f-test-hlint"

15820+ ];

15821+ libraryHaskellDepends = [

15822+ base containers hashable unordered-containers

15823+ ];

15824+ homepage = "https://github.com/HeinrichApfelmus/vault";

15825+ description = "a persistent store for values of arbitrary types";

15826+ license = stdenv.lib.licenses.bsd3;

15827+ }) {};

15828+ "vector" = callPackage

15829+ ({ mkDerivation, base, deepseq, ghc-prim, primitive, QuickCheck

15830+ , random, template-haskell, test-framework

15831+ , test-framework-quickcheck2, transformers

15832+ }:

15833+ mkDerivation {

15834+ pname = "vector";

15835+ version = "0.10.12.2";

15836+ sha256 = "01hc71k1z9m0g0dv4zsvq5d2dvbgyc5p01hryw5c53792yi2fm25";

15837+ configureFlags = [

15838+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15839+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15840+ "-fsplitbase" "-f-test-hlint"

15841+ ];

15842+ libraryHaskellDepends = [ base deepseq ghc-prim primitive ];

15843+ testHaskellDepends = [

15844+ base QuickCheck random template-haskell test-framework

15845+ test-framework-quickcheck2 transformers

15846+ ];

15847+ homepage = "https://github.com/haskell/vector";

15848+ description = "Efficient Arrays";

15849+ license = stdenv.lib.licenses.bsd3;

15850+ }) {};

15851+ "vector-algorithms" = callPackage

15852+ ({ mkDerivation, base, bytestring, containers, mtl, mwc-random

15853+ , primitive, QuickCheck, vector

15854+ }:

15855+ mkDerivation {

15856+ pname = "vector-algorithms";

15857+ version = "0.6.0.3";

15858+ sha256 = "1kz4b41y7swad6mbx0g3adc8lqma8pl3rnzah71cfdvb87gssbn4";

15859+ configureFlags = [

15860+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15861+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15862+ "-fsplitbase" "-f-test-hlint"

15863+ ];

15864+ isLibrary = true;

15865+ isExecutable = true;

15866+ libraryHaskellDepends = [ base bytestring primitive vector ];

15867+ executableHaskellDepends = [ base mtl mwc-random vector ];

15868+ testHaskellDepends = [

15869+ base bytestring containers QuickCheck vector

15870+ ];

15871+ homepage = "http://code.haskell.org/~dolio/";

15872+ description = "Efficient algorithms for vector arrays";

15873+ license = stdenv.lib.licenses.bsd3;

15874+ }) {};

15875+ "vector-binary-instances" = callPackage

15876+ ({ mkDerivation, base, binary, cereal, vector }:

15877+ mkDerivation {

15878+ pname = "vector-binary-instances";

15879+ version = "0.2.1.0";

15880+ sha256 = "028rsf2w193rhs1gic5yvvrwidw9sblczcn10aw64npfc6502l4l";

15881+ configureFlags = [

15882+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15883+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15884+ "-fsplitbase" "-f-test-hlint"

15885+ ];

15886+ libraryHaskellDepends = [ base binary cereal vector ];

15887+ homepage = "https://github.com/bos/vector-binary-instances";

15888+ description = "Instances of Data.Binary and Data.Serialize for vector";

15889+ license = stdenv.lib.licenses.bsd3;

15890+ }) {};

15891+ "vector-instances" = callPackage

15892+ ({ mkDerivation, base, comonad, keys, pointed, semigroupoids

15893+ , semigroups, vector

15894+ }:

15895+ mkDerivation {

15896+ pname = "vector-instances";

15897+ version = "3.3";

15898+ sha256 = "0iiw9p2ivcdfsh81vdy4yn6hbigdwclrkssd68hdsg9n6q3fmq5y";

15899+ revision = "1";

15900+ editedCabalFile = "1hikvr5aprlixp4mryq603b1wh31sq57532pvw08qmxam9vjs71d";

15901+ configureFlags = [

15902+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15903+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15904+ "-fsplitbase" "-f-test-hlint"

15905+ ];

15906+ libraryHaskellDepends = [

15907+ base comonad keys pointed semigroupoids semigroups vector

15908+ ];

15909+ homepage = "http://github.com/ekmett/vector-instances";

15910+ description = "Orphan Instances for 'Data.Vector'";

15911+ license = stdenv.lib.licenses.bsd3;

15912+ }) {};

15913+ "vector-space" = callPackage

15914+ ({ mkDerivation, base, Boolean, MemoTrie, NumInstances }:

15915+ mkDerivation {

15916+ pname = "vector-space";

15917+ version = "0.8.7";

15918+ sha256 = "1i3c34b3ngksmw4blhldap8fiw1jddm2h1qyr92csn3cllj6j1vm";

15919+ configureFlags = [

15920+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15921+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15922+ "-fsplitbase" "-f-test-hlint"

15923+ ];

15924+ libraryHaskellDepends = [ base Boolean MemoTrie NumInstances ];

15925+ description = "Vector & affine spaces, linear maps, and derivatives";

15926+ license = stdenv.lib.licenses.bsd3;

15927+ }) {};

15928+ "vector-space-points" = callPackage

15929+ ({ mkDerivation, base, vector-space }:

15930+ mkDerivation {

15931+ pname = "vector-space-points";

15932+ version = "0.2";

15933+ sha256 = "05wczgvcqwqhcr4v0md4x5vybq6ns8rk6459yqyrc96kaig0sf2i";

15934+ configureFlags = [

15935+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15936+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15937+ "-fsplitbase" "-f-test-hlint"

15938+ ];

15939+ libraryHaskellDepends = [ base vector-space ];

15940+ description = "A type for points, as distinct from vectors";

15941+ license = stdenv.lib.licenses.bsd3;

15942+ }) {};

15943+ "vector-th-unbox" = callPackage

15944+ ({ mkDerivation, base, data-default, template-haskell, vector }:

15945+ mkDerivation {

15946+ pname = "vector-th-unbox";

15947+ version = "0.2.1.0";

15948+ sha256 = "0r8yxj63hvkm923y8mk1b5kv1b15lqadxhlncc02glvmy8zf1prh";

15949+ revision = "2";

15950+ editedCabalFile = "0fnbivm8qc2bqjh4j8psffs713in5373kaycigm9bbsz2nywy2fa";

15951+ configureFlags = [

15952+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15953+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15954+ "-fsplitbase" "-f-test-hlint"

15955+ ];

15956+ libraryHaskellDepends = [ base template-haskell vector ];

15957+ testHaskellDepends = [ base data-default vector ];

15958+ description = "Deriver for Data.Vector.Unboxed using Template Haskell";

15959+ license = stdenv.lib.licenses.bsd3;

15960+ }) {};

15961+ "vhd" = callPackage

15962+ ({ mkDerivation, base, byteable, bytestring, cereal, cipher-aes

15963+ , cryptohash, directory, filepath, mmap, QuickCheck, random

15964+ , storable-endian, test-framework, test-framework-quickcheck2, text

15965+ , time

15966+ }:

15967+ mkDerivation {

15968+ pname = "vhd";

15969+ version = "0.2.2";

15970+ sha256 = "0z7a17j0rd06kvn3v4qr0fhxg0xw6n3579477y2lvx4mcc3qyrvw";

15971+ configureFlags = [

15972+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15973+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15974+ "-fsplitbase" "-f-test-hlint"

15975+ ];

15976+ isLibrary = true;

15977+ isExecutable = true;

15978+ enableSeparateDataOutput = true;

15979+ libraryHaskellDepends = [

15980+ base byteable bytestring cereal cipher-aes cryptohash directory

15981+ filepath mmap random storable-endian text time

15982+ ];

15983+ testHaskellDepends = [

15984+ base byteable bytestring cereal cryptohash filepath mmap QuickCheck

15985+ random test-framework test-framework-quickcheck2 text time

15986+ ];

15987+ homepage = "https://github.com/vincenthz/hs-vhd";

15988+ description = "Provides functions to inspect and manipulate virtual hard disk (VHD) files";

15989+ license = stdenv.lib.licenses.bsd3;

15990+ }) {};

15991+ "void" = callPackage

15992+ ({ mkDerivation, base, ghc-prim, hashable, semigroups }:

15993+ mkDerivation {

15994+ pname = "void";

15995+ version = "0.7";

15996+ sha256 = "0ivgr4minxb5v56v4kbd045iwqk1c2w89c830731l75mkg8qa6wq";

15997+ revision = "1";

15998+ editedCabalFile = "1bgll5awf4j5766w63bnj9vl00irfdiyhhv903q3vw9s90zcjrhv";

15999+ configureFlags = [

16000+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16001+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16002+ "-fsplitbase" "-f-test-hlint"

16003+ ];

16004+ libraryHaskellDepends = [ base ghc-prim hashable semigroups ];

16005+ homepage = "http://github.com/ekmett/void";

16006+ description = "A Haskell 98 logically uninhabited data type";

16007+ license = stdenv.lib.licenses.bsd3;

16008+ }) {};

16009+ "wai" = callPackage

16010+ ({ mkDerivation, base, blaze-builder, bytestring, hspec, http-types

16011+ , network, text, vault

16012+ }:

16013+ mkDerivation {

16014+ pname = "wai";

16015+ version = "3.0.2";

16016+ sha256 = "0k67yzr05d6vjwqamnzzggk1mlj9wabqrm26dqbrrc40jj3kddgw";

16017+ configureFlags = [

16018+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16019+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16020+ "-fsplitbase" "-f-test-hlint"

16021+ ];

16022+ libraryHaskellDepends = [

16023+ base blaze-builder bytestring http-types network text vault

16024+ ];

16025+ testHaskellDepends = [ base blaze-builder bytestring hspec ];

16026+ homepage = "https://github.com/yesodweb/wai";

16027+ description = "Web Application Interface";

16028+ license = stdenv.lib.licenses.mit;

16029+ }) {};

16030+ "wai-app-static" = callPackage

16031+ ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html

16032+ , blaze-markup, byteable, bytestring, containers, cryptohash

16033+ , cryptohash-conduit, directory, file-embed, filepath, hspec

16034+ , http-date, http-types, mime-types, network, old-locale

16035+ , optparse-applicative, system-fileio, system-filepath

16036+ , template-haskell, text, time, transformers, unix-compat

16037+ , unordered-containers, wai, wai-extra, warp, zlib

16038+ }:

16039+ mkDerivation {

16040+ pname = "wai-app-static";

16041+ version = "3.0.0.3";

16042+ sha256 = "0krvjnysmfaqds715mp6lhh5am327swi2vja5insmn08da87zhnb";

16043+ revision = "1";

16044+ editedCabalFile = "0c74h9lbdcnnp7ly948dmkpiny33449g8w1m9ldnwqc3mnv9w6im";

16045+ configureFlags = [

16046+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16047+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16048+ "-fsplitbase" "-f-test-hlint"

16049+ ];

16050+ isLibrary = true;

16051+ isExecutable = true;

16052+ libraryHaskellDepends = [

16053+ base base64-bytestring blaze-builder blaze-html blaze-markup

16054+ byteable bytestring containers cryptohash cryptohash-conduit

16055+ directory file-embed filepath http-date http-types mime-types

16056+ old-locale optparse-applicative system-fileio system-filepath

16057+ template-haskell text time transformers unix-compat

16058+ unordered-containers wai wai-extra warp zlib

16059+ ];

16060+ executableHaskellDepends = [

16061+ base bytestring containers directory mime-types text

16062+ ];

16063+ testHaskellDepends = [

16064+ base bytestring hspec http-date http-types mime-types network

16065+ old-locale text time transformers unix-compat wai wai-extra zlib

16066+ ];

16067+ homepage = "http://www.yesodweb.com/book/web-application-interface";

16068+ description = "WAI application for static serving";

16069+ license = stdenv.lib.licenses.mit;

16070+ }) {};

16071+ "wai-conduit" = callPackage

16072+ ({ mkDerivation, base, blaze-builder, bytestring, conduit

16073+ , http-types, transformers, wai

16074+ }:

16075+ mkDerivation {

16076+ pname = "wai-conduit";

16077+ version = "3.0.0.1";

16078+ sha256 = "0m5mfr6plzb873by4pab9d4g4cwfcpxl6g5c5qyljb8sydfzhhym";

16079+ configureFlags = [

16080+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16081+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16082+ "-fsplitbase" "-f-test-hlint"

16083+ ];

16084+ libraryHaskellDepends = [

16085+ base blaze-builder bytestring conduit http-types transformers wai

16086+ ];

16087+ homepage = "https://github.com/yesodweb/wai";

16088+ description = "conduit wrappers for WAI";

16089+ license = stdenv.lib.licenses.mit;

16090+ }) {};

16091+ "wai-eventsource" = callPackage

16092+ ({ mkDerivation, wai }:

16093+ mkDerivation {

16094+ pname = "wai-eventsource";

16095+ version = "3.0.0";

16096+ sha256 = "1h5zlqky7ldqbmiaixizhk1s8ghf5i3ha1xfz8flxgzr7gr0al3q";

16097+ configureFlags = [

16098+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16099+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16100+ "-fsplitbase" "-f-test-hlint"

16101+ ];

16102+ libraryHaskellDepends = [ wai ];

16103+ doHaddock = false;

16104+ doCheck = false;

16105+ homepage = "http://www.yesodweb.com/book/web-application-interface";

16106+ description = "WAI support for server-sent events (deprecated)";

16107+ license = stdenv.lib.licenses.mit;

16108+ }) {};

16109+ "wai-extra" = callPackage

16110+ ({ mkDerivation, ansi-terminal, base, base64-bytestring

16111+ , blaze-builder, bytestring, case-insensitive, containers

16112+ , data-default-class, deepseq, directory, fast-logger, hspec

16113+ , http-types, HUnit, lifted-base, network, old-locale, resourcet

16114+ , streaming-commons, stringsearch, text, time, transformers, unix

16115+ , void, wai, wai-logger, word8, zlib

16116+ }:

16117+ mkDerivation {

16118+ pname = "wai-extra";

16119+ version = "3.0.2.2";

16120+ sha256 = "0lbm5z4fzsss1y4749598ish967j64nfvlvdmgj27nvshi7qn4s9";

16121+ revision = "1";

16122+ editedCabalFile = "0dimv622d287iqfy0gj0x56inc0fql1pdk45cb3v76khdz2mdmy8";

16123+ configureFlags = [

16124+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16125+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16126+ "-fsplitbase" "-f-test-hlint"

16127+ ];

16128+ libraryHaskellDepends = [

16129+ ansi-terminal base base64-bytestring blaze-builder bytestring

16130+ case-insensitive containers data-default-class deepseq directory

16131+ fast-logger http-types lifted-base network old-locale resourcet

16132+ streaming-commons stringsearch text time transformers unix void wai

16133+ wai-logger word8

16134+ ];

16135+ testHaskellDepends = [

16136+ base bytestring fast-logger hspec http-types HUnit resourcet text

16137+ transformers wai zlib

16138+ ];

16139+ homepage = "http://github.com/yesodweb/wai";

16140+ description = "Provides some basic WAI handlers and middleware";

16141+ license = stdenv.lib.licenses.mit;

16142+ }) {};

16143+ "wai-logger" = callPackage

16144+ ({ mkDerivation, auto-update, base, blaze-builder, byteorder

16145+ , bytestring, case-insensitive, doctest, easy-file, fast-logger

16146+ , http-types, network, unix, unix-time, wai

16147+ }:

16148+ mkDerivation {

16149+ pname = "wai-logger";

16150+ version = "2.2.3";

16151+ sha256 = "0ljpzq3yfiz3xfglvj69jdk46lmgsg6nqncv9mhij4ih6qq0cx0w";

16152+ configureFlags = [

16153+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16154+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16155+ "-fsplitbase" "-f-test-hlint"

16156+ ];

16157+ libraryHaskellDepends = [

16158+ auto-update base blaze-builder byteorder bytestring

16159+ case-insensitive easy-file fast-logger http-types network unix

16160+ unix-time wai

16161+ ];

16162+ testHaskellDepends = [ base doctest ];

16163+ doHaddock = false;

16164+ doCheck = false;

16165+ description = "A logging system for WAI";

16166+ license = stdenv.lib.licenses.bsd3;

16167+ }) {};

16168+ "wai-middleware-static" = callPackage

16169+ ({ mkDerivation, base, bytestring, containers, directory, filepath

16170+ , http-types, mtl, text, wai

16171+ }:

16172+ mkDerivation {

16173+ pname = "wai-middleware-static";

16174+ version = "0.6.0.1";

16175+ sha256 = "1ylf2nm535d3dw0ksa9dfz1b4b78mqzkdrpdfd5pxswcqbgs266d";

16176+ configureFlags = [

16177+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16178+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16179+ "-fsplitbase" "-f-test-hlint"

16180+ ];

16181+ libraryHaskellDepends = [

16182+ base bytestring containers directory filepath http-types mtl text

16183+ wai

16184+ ];

16185+ homepage = "https://github.com/scotty-web/wai-middleware-static";

16186+ description = "WAI middleware that serves requests to static files";

16187+ license = stdenv.lib.licenses.bsd3;

16188+ }) {};

16189+ "wai-websockets" = callPackage

16190+ ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive

16191+ , file-embed, http-types, network, text, transformers, wai

16192+ , wai-app-static, warp, websockets

16193+ }:

16194+ mkDerivation {

16195+ pname = "wai-websockets";

16196+ version = "3.0.0.2";

16197+ sha256 = "1p0ylwc19g63z4qijnis1x5wys5h2avim6s2fn7m2ihrlc3pkhsb";

16198+ configureFlags = [

16199+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16200+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16201+ "-fsplitbase" "-f-test-hlint"

16202+ ];

16203+ isLibrary = true;

16204+ isExecutable = true;

16205+ libraryHaskellDepends = [

16206+ base blaze-builder bytestring case-insensitive http-types network

16207+ transformers wai websockets

16208+ ];

16209+ executableHaskellDepends = [

16210+ base blaze-builder bytestring case-insensitive file-embed

16211+ http-types network text transformers wai wai-app-static warp

16212+ websockets

16213+ ];

16214+ homepage = "http://github.com/yesodweb/wai";

16215+ description = "Provide a bridge betweeen WAI and the websockets package";

16216+ license = stdenv.lib.licenses.mit;

16217+ }) {};

16218+ "warp" = callPackage

16219+ ({ mkDerivation, array, async, auto-update, base, blaze-builder

16220+ , bytestring, case-insensitive, criterion, doctest, ghc-prim

16221+ , hashable, hspec, HTTP, http-date, http-types, HUnit, lifted-base

16222+ , network, old-locale, QuickCheck, simple-sendfile

16223+ , streaming-commons, text, time, transformers, unix, unix-compat

16224+ , void, wai

16225+ }:

16226+ mkDerivation {

16227+ pname = "warp";

16228+ version = "3.0.4";

16229+ sha256 = "0kykf3nki9a7mqr1z9jhk4z0cbzlmk9lyc7zw5y36285mx9id0dr";

16230+ revision = "1";

16231+ editedCabalFile = "1xd5x1lffhp025pxwhvypcbx4fv2zd8jmdcibfl6dy1a9kphml58";

16232+ configureFlags = [

16233+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16234+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16235+ "-fsplitbase" "-f-test-hlint"

16236+ ];

16237+ libraryHaskellDepends = [

16238+ array auto-update base blaze-builder bytestring case-insensitive

16239+ ghc-prim hashable http-date http-types network simple-sendfile

16240+ streaming-commons text unix unix-compat void wai

16241+ ];

16242+ testHaskellDepends = [

16243+ array async auto-update base blaze-builder bytestring

16244+ case-insensitive doctest ghc-prim hashable hspec HTTP http-date

16245+ http-types HUnit lifted-base network old-locale QuickCheck

16246+ simple-sendfile streaming-commons text time transformers unix

16247+ unix-compat void wai

16248+ ];

16249+ benchmarkHaskellDepends = [

16250+ base bytestring criterion http-types network

16251+ ];

16252+ doHaddock = false;

16253+ doCheck = false;

16254+ homepage = "http://github.com/yesodweb/wai";

16255+ description = "A fast, light-weight web server for WAI applications";

16256+ license = stdenv.lib.licenses.mit;

16257+ }) {};

16258+ "warp-tls" = callPackage

16259+ ({ mkDerivation, base, bytestring, cprng-aes, data-default-class

16260+ , network, streaming-commons, tls, wai, warp

16261+ }:

16262+ mkDerivation {

16263+ pname = "warp-tls";

16264+ version = "3.0.1";

16265+ sha256 = "0s87ricslidyg6m17q5mllpl47v0d8mvvd6psq4izz5l27dg2xpy";

16266+ revision = "1";

16267+ editedCabalFile = "1bs01bscx0h84rpbasng5ihni7wgml70s8rq3di8ksgqsxa9xxyj";

16268+ configureFlags = [

16269+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16270+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16271+ "-fsplitbase" "-f-test-hlint"

16272+ ];

16273+ libraryHaskellDepends = [

16274+ base bytestring cprng-aes data-default-class network

16275+ streaming-commons tls wai warp

16276+ ];

16277+ homepage = "http://github.com/yesodweb/wai";

16278+ description = "HTTP over SSL/TLS support for Warp via the TLS package";

16279+ license = stdenv.lib.licenses.mit;

16280+ }) {};

16281+ "web-fpco" = callPackage

16282+ ({ mkDerivation, base, happstack-server, safe, snap, snap-core

16283+ , snap-server

16284+ }:

16285+ mkDerivation {

16286+ pname = "web-fpco";

16287+ version = "0.1.1.0";

16288+ sha256 = "1iizmg1syjywd5hs9swcqxxzmix04hwa86p8c246xybwcklf667n";

16289+ configureFlags = [

16290+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16291+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16292+ "-fsplitbase" "-f-test-hlint"

16293+ ];

16294+ libraryHaskellDepends = [

16295+ base happstack-server safe snap snap-core snap-server

16296+ ];

16297+ homepage = "https://github.com/fpco/web-fpco";

16298+ description = "Wrappers for web frameworks to ease usage with the FP Complete environment";

16299+ license = stdenv.lib.licenses.mit;

16300+ }) {};

16301+ "webdriver" = callPackage

16302+ ({ mkDerivation, aeson, attoparsec, base, base64-bytestring

16303+ , bytestring, cond, data-default, directory, directory-tree

16304+ , exceptions, filepath, http-client, http-types, lifted-base

16305+ , monad-control, mtl, network, network-uri, parallel, scientific

16306+ , temporary, text, time, transformers, transformers-base

16307+ , unordered-containers, vector, zip-archive

16308+ }:

16309+ mkDerivation {

16310+ pname = "webdriver";

16311+ version = "0.6.0.3";

16312+ sha256 = "1q0l9rs5j4cxzyqsy6r40y425359s246spk3g3pks7s47yynjn4q";

16313+ configureFlags = [

16314+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16315+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16316+ "-fsplitbase" "-f-test-hlint"

16317+ ];

16318+ libraryHaskellDepends = [

16319+ aeson attoparsec base base64-bytestring bytestring cond

16320+ data-default directory directory-tree exceptions filepath

16321+ http-client http-types lifted-base monad-control mtl network

16322+ network-uri scientific temporary text time transformers

16323+ transformers-base unordered-containers vector zip-archive

16324+ ];

16325+ testHaskellDepends = [ base parallel text ];

16326+ doHaddock = false;

16327+ doCheck = false;

16328+ homepage = "https://github.com/kallisti-dev/hs-webdriver";

16329+ description = "a Haskell client for the Selenium WebDriver protocol";

16330+ license = stdenv.lib.licenses.bsd3;

16331+ }) {};

16332+ "websockets" = callPackage

16333+ ({ mkDerivation, attoparsec, base, base64-bytestring, binary

16334+ , blaze-builder, bytestring, case-insensitive, containers, entropy

16335+ , HUnit, mtl, network, QuickCheck, random, SHA, test-framework

16336+ , test-framework-hunit, test-framework-quickcheck2, text

16337+ }:

16338+ mkDerivation {

16339+ pname = "websockets";

16340+ version = "0.9.2.1";

16341+ sha256 = "11pdh5dc7r9svg789yx66lff5gcmzs6yg7m74ciz3ybb2i4p855s";

16342+ configureFlags = [

16343+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16344+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16345+ "-fsplitbase" "-f-test-hlint"

16346+ ];

16347+ libraryHaskellDepends = [

16348+ attoparsec base base64-bytestring binary blaze-builder bytestring

16349+ case-insensitive containers entropy mtl network random SHA text

16350+ ];

16351+ testHaskellDepends = [

16352+ attoparsec base base64-bytestring binary blaze-builder bytestring

16353+ case-insensitive containers entropy HUnit mtl network QuickCheck

16354+ random SHA test-framework test-framework-hunit

16355+ test-framework-quickcheck2 text

16356+ ];

16357+ doHaddock = false;

16358+ doCheck = false;

16359+ homepage = "http://jaspervdj.be/websockets";

16360+ description = "A sensible and clean way to write WebSocket-capable servers in Haskell";

16361+ license = stdenv.lib.licenses.bsd3;

16362+ }) {};

16363+ "wizards" = callPackage

16364+ ({ mkDerivation, base, containers, control-monad-free, haskeline

16365+ , mtl, transformers

16366+ }:

16367+ mkDerivation {

16368+ pname = "wizards";

16369+ version = "1.0.1";

16370+ sha256 = "08dn24injfzvhs34yw39y336pyi6p98bdrafx3lhd6lcbp531sca";

16371+ configureFlags = [

16372+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16373+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16374+ "-fsplitbase" "-f-test-hlint"

16375+ ];

16376+ libraryHaskellDepends = [

16377+ base containers control-monad-free haskeline mtl transformers

16378+ ];

16379+ description = "High level, generic library for interrogative user interfaces";

16380+ license = stdenv.lib.licenses.bsd3;

16381+ }) {};

16382+ "wl-pprint" = callPackage

16383+ ({ mkDerivation, base }:

16384+ mkDerivation {

16385+ pname = "wl-pprint";

16386+ version = "1.1";

16387+ sha256 = "16kp3fkh0x9kgzk6fdqrm8m0v7b5cgbv0m3x63ybbp5vxbhand06";

16388+ revision = "1";

16389+ editedCabalFile = "1vbagi930lj362vjvq95jq1gc9d9vvk6p5kx1ybwyxrv98vb9wgs";

16390+ configureFlags = [

16391+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16392+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16393+ "-fsplitbase" "-f-test-hlint"

16394+ ];

16395+ libraryHaskellDepends = [ base ];

16396+ description = "The Wadler/Leijen Pretty Printer";

16397+ license = stdenv.lib.licenses.bsd3;

16398+ }) {};

16399+ "wl-pprint-extras" = callPackage

16400+ ({ mkDerivation, base, containers, HUnit, nats, semigroupoids

16401+ , semigroups, test-framework, test-framework-hunit, text

16402+ , utf8-string

16403+ }:

16404+ mkDerivation {

16405+ pname = "wl-pprint-extras";

16406+ version = "3.5.0.3";

16407+ sha256 = "124wb4hqd97f3naha0589v18lvi9xbn39bmn8jwaylvyg6s5fyyp";

16408+ configureFlags = [

16409+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16410+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16411+ "-fsplitbase" "-f-test-hlint"

16412+ ];

16413+ libraryHaskellDepends = [

16414+ base containers nats semigroupoids semigroups text utf8-string

16415+ ];

16416+ testHaskellDepends = [

16417+ base HUnit test-framework test-framework-hunit

16418+ ];

16419+ homepage = "http://github.com/ekmett/wl-pprint-extras/";

16420+ description = "A free monad based on the Wadler/Leijen pretty printer";

16421+ license = stdenv.lib.licenses.bsd3;

16422+ }) {};

16423+ "wl-pprint-terminfo" = callPackage

16424+ ({ mkDerivation, base, bytestring, containers, nats, semigroups

16425+ , terminfo, text, transformers, wl-pprint-extras

16426+ }:

16427+ mkDerivation {

16428+ pname = "wl-pprint-terminfo";

16429+ version = "3.7.1.3";

16430+ sha256 = "19z5cr1wqc3xcy39dswx78b6fpxhb41798zkiwkmb97nnvzwbdmv";

16431+ configureFlags = [

16432+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16433+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16434+ "-fsplitbase" "-f-test-hlint"

16435+ ];

16436+ enableSeparateDataOutput = true;

16437+ libraryHaskellDepends = [

16438+ base bytestring containers nats semigroups terminfo text

16439+ transformers wl-pprint-extras

16440+ ];

16441+ homepage = "http://github.com/ekmett/wl-pprint-terminfo/";

16442+ description = "A color pretty printer with terminfo support";

16443+ license = stdenv.lib.licenses.bsd3;

16444+ }) {};

16445+ "wl-pprint-text" = callPackage

16446+ ({ mkDerivation, base, text }:

16447+ mkDerivation {

16448+ pname = "wl-pprint-text";

16449+ version = "1.1.0.2";

16450+ sha256 = "0wbfqp38as2qpn66sq4hvl3hzvj66v301cz9rmgnx2i62r0a3s81";

16451+ configureFlags = [

16452+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16453+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16454+ "-fsplitbase" "-f-test-hlint"

16455+ ];

16456+ libraryHaskellDepends = [ base text ];

16457+ description = "A Wadler/Leijen Pretty Printer for Text values";

16458+ license = stdenv.lib.licenses.bsd3;

16459+ }) {};

16460+ "word8" = callPackage

16461+ ({ mkDerivation, base, bytestring, criterion, hspec }:

16462+ mkDerivation {

16463+ pname = "word8";

16464+ version = "0.1.1";

16465+ sha256 = "1xpa0haacimrblxg3x3n5vdcnkg3ff5zqamppdarv0zvkcdj139r";

16466+ configureFlags = [

16467+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16468+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16469+ "-fsplitbase" "-f-test-hlint"

16470+ ];

16471+ libraryHaskellDepends = [ base ];

16472+ testHaskellDepends = [ base hspec ];

16473+ benchmarkHaskellDepends = [ base bytestring criterion ];

16474+ description = "Word8 library";

16475+ license = stdenv.lib.licenses.bsd3;

16476+ }) {};

16477+ "x509" = callPackage

16478+ ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, base

16479+ , bytestring, containers, crypto-pubkey-types, cryptohash

16480+ , directory, filepath, hourglass, mtl, pem, process, tasty

16481+ , tasty-quickcheck

16482+ }:

16483+ mkDerivation {

16484+ pname = "x509";

16485+ version = "1.5.0.1";

16486+ sha256 = "03gj4190f0ql1ghn2mri8901xdydhhnwijyfn8lmpjyn7pgpl3ba";

16487+ revision = "1";

16488+ editedCabalFile = "0z8mhdvpxv71iacnry4g56wnrn7k039sn55h655z5sqalkdic6i6";

16489+ configureFlags = [

16490+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16491+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16492+ "-fsplitbase" "-f-test-hlint"

16493+ ];

16494+ libraryHaskellDepends = [

16495+ asn1-encoding asn1-parse asn1-types base bytestring containers

16496+ crypto-pubkey-types cryptohash directory filepath hourglass mtl pem

16497+ process

16498+ ];

16499+ testHaskellDepends = [

16500+ asn1-types base bytestring crypto-pubkey-types hourglass mtl tasty

16501+ tasty-quickcheck

16502+ ];

16503+ homepage = "http://github.com/vincenthz/hs-certificate";

16504+ description = "X509 reader and writer";

16505+ license = stdenv.lib.licenses.bsd3;

16506+ }) {};

16507+ "x509-store" = callPackage

16508+ ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring

16509+ , containers, crypto-pubkey-types, directory, filepath, mtl, pem

16510+ , process, x509

16511+ }:

16512+ mkDerivation {

16513+ pname = "x509-store";

16514+ version = "1.5.0";

16515+ sha256 = "1w9sqb007s4avjzvrdwq13a4c528h7h2lg3m8cl31syrgznc9ny5";

16516+ configureFlags = [

16517+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16518+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16519+ "-fsplitbase" "-f-test-hlint"

16520+ ];

16521+ libraryHaskellDepends = [

16522+ asn1-encoding asn1-types base bytestring containers

16523+ crypto-pubkey-types directory filepath mtl pem process x509

16524+ ];

16525+ homepage = "http://github.com/vincenthz/hs-certificate";

16526+ description = "X.509 collection accessing and storing methods";

16527+ license = stdenv.lib.licenses.bsd3;

16528+ }) {};

16529+ "x509-system" = callPackage

16530+ ({ mkDerivation, base, bytestring, containers, directory, filepath

16531+ , mtl, pem, process, x509, x509-store

16532+ }:

16533+ mkDerivation {

16534+ pname = "x509-system";

16535+ version = "1.5.0";

16536+ sha256 = "159zwg35nq42j1rl0p4x00hdf3iy48hd7kavz0rnpwd2p7ljamr3";

16537+ configureFlags = [

16538+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16539+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16540+ "-fsplitbase" "-f-test-hlint"

16541+ ];

16542+ libraryHaskellDepends = [

16543+ base bytestring containers directory filepath mtl pem process x509

16544+ x509-store

16545+ ];

16546+ homepage = "http://github.com/vincenthz/hs-certificate";

16547+ description = "Handle per-operating-system X.509 accessors and storage";

16548+ license = stdenv.lib.licenses.bsd3;

16549+ }) {};

16550+ "x509-validation" = callPackage

16551+ ({ mkDerivation, asn1-encoding, asn1-types, base, byteable

16552+ , bytestring, containers, crypto-pubkey, crypto-pubkey-types

16553+ , cryptohash, data-default-class, directory, filepath, hourglass

16554+ , mtl, network, pem, process, x509, x509-store

16555+ }:

16556+ mkDerivation {

16557+ pname = "x509-validation";

16558+ version = "1.5.1";

16559+ sha256 = "19cp187id9hdlzkr7sbv2sdxqxnpjv0db09hwf3zdqqqxr30mn6x";

16560+ configureFlags = [

16561+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16562+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16563+ "-fsplitbase" "-f-test-hlint"

16564+ ];

16565+ libraryHaskellDepends = [

16566+ asn1-encoding asn1-types base byteable bytestring containers

16567+ crypto-pubkey crypto-pubkey-types cryptohash data-default-class

16568+ directory filepath hourglass mtl network pem process x509

16569+ x509-store

16570+ ];

16571+ homepage = "http://github.com/vincenthz/hs-certificate";

16572+ description = "X.509 Certificate and CRL validation";

16573+ license = stdenv.lib.licenses.bsd3;

16574+ }) {};

16575+ "xenstore" = callPackage

16576+ ({ mkDerivation, base, bytestring, cereal, mtl, network }:

16577+ mkDerivation {

16578+ pname = "xenstore";

16579+ version = "0.1.1";

16580+ sha256 = "0x788lpkkxg7ds1bgnw0kvkf6pkfbknn7jy0njhz85k7rv4kidf2";

16581+ configureFlags = [

16582+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16583+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16584+ "-fsplitbase" "-f-test-hlint"

16585+ ];

16586+ isLibrary = true;

16587+ isExecutable = true;

16588+ libraryHaskellDepends = [ base bytestring cereal mtl network ];

16589+ description = "Xenstore client access";

16590+ license = stdenv.lib.licenses.bsd3;

16591+ }) {};

16592+ "xml" = callPackage

16593+ ({ mkDerivation, base, bytestring, text }:

16594+ mkDerivation {

16595+ pname = "xml";

16596+ version = "1.3.13";

16597+ sha256 = "04xq2ma2if5gqz16bjrxwigh4vzw6m8i2zk11s5qg3d4z370fdn3";

16598+ configureFlags = [

16599+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16600+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16601+ "-fsplitbase" "-f-test-hlint"

16602+ ];

16603+ libraryHaskellDepends = [ base bytestring text ];

16604+ homepage = "http://code.galois.com";

16605+ description = "A simple XML library";

16606+ license = stdenv.lib.licenses.bsd3;

16607+ }) {};

16608+ "xml-conduit" = callPackage

16609+ ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html

16610+ , blaze-markup, bytestring, conduit, conduit-extra, containers

16611+ , data-default, deepseq, hspec, HUnit, monad-control, resourcet

16612+ , system-filepath, text, transformers, xml-types

16613+ }:

16614+ mkDerivation {

16615+ pname = "xml-conduit";

16616+ version = "1.2.3";

16617+ sha256 = "1knwmvs9hczlknyi27hciy1xkn219s6niv3w7q0wkw6rxz2q555v";

16618+ revision = "1";

16619+ editedCabalFile = "0kvw0n8dlmm9v4dnvaq1lzka44sr8zkcm5p38555fxyasq0d99zn";

16620+ configureFlags = [

16621+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16622+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16623+ "-fsplitbase" "-f-test-hlint"

16624+ ];

16625+ libraryHaskellDepends = [

16626+ attoparsec base blaze-builder blaze-html blaze-markup bytestring

16627+ conduit conduit-extra containers data-default deepseq monad-control

16628+ resourcet system-filepath text transformers xml-types

16629+ ];

16630+ testHaskellDepends = [

16631+ base blaze-markup bytestring conduit containers hspec HUnit

16632+ resourcet text transformers xml-types

16633+ ];

16634+ homepage = "http://github.com/snoyberg/xml";

16635+ description = "Pure-Haskell utilities for dealing with XML with the conduit package";

16636+ license = stdenv.lib.licenses.bsd3;

16637+ }) {};

16638+ "xml-hamlet" = callPackage

16639+ ({ mkDerivation, base, containers, hspec, HUnit, parsec

16640+ , shakespeare, template-haskell, text, xml-conduit

16641+ }:

16642+ mkDerivation {

16643+ pname = "xml-hamlet";

16644+ version = "0.4.0.9";

16645+ sha256 = "0vm4jhvjf53a33sisnhghg0m9pcv2fx676rl90vbm2xcd9rqlj82";

16646+ configureFlags = [

16647+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16648+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16649+ "-fsplitbase" "-f-test-hlint"

16650+ ];

16651+ libraryHaskellDepends = [

16652+ base containers parsec shakespeare template-haskell text

16653+ xml-conduit

16654+ ];

16655+ testHaskellDepends = [

16656+ base containers hspec HUnit parsec shakespeare template-haskell

16657+ text xml-conduit

16658+ ];

16659+ homepage = "http://www.yesodweb.com/";

16660+ description = "Hamlet-style quasiquoter for XML content";

16661+ license = stdenv.lib.licenses.bsd3;

16662+ }) {};

16663+ "xml-types" = callPackage

16664+ ({ mkDerivation, base, deepseq, text }:

16665+ mkDerivation {

16666+ pname = "xml-types";

16667+ version = "0.3.4";

16668+ sha256 = "1689ijr4xxh4shxxvd51wdkpc535kzv6liqg4m1prag96aq05r8y";

16669+ configureFlags = [

16670+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16671+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16672+ "-fsplitbase" "-f-test-hlint"

16673+ ];

16674+ libraryHaskellDepends = [ base deepseq text ];

16675+ homepage = "https://john-millikin.com/software/haskell-xml/";

16676+ description = "Basic types for representing XML";

16677+ license = stdenv.lib.licenses.mit;

16678+ }) {};

16679+ "xmlgen" = callPackage

16680+ ({ mkDerivation, base, blaze-builder, bytestring, containers

16681+ , criterion, filepath, HUnit, hxt, mtl, process, QuickCheck, text

16682+ , unix

16683+ }:

16684+ mkDerivation {

16685+ pname = "xmlgen";

16686+ version = "0.6.2.1";

16687+ sha256 = "1rmsg9wxs0bsj0xpagxrm3fmlqd63b0dfyc21rx9jj76g9za29wh";

16688+ configureFlags = [

16689+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16690+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16691+ "-fsplitbase" "-f-test-hlint"

16692+ ];

16693+ libraryHaskellDepends = [

16694+ base blaze-builder bytestring containers mtl text

16695+ ];

16696+ testHaskellDepends = [

16697+ base bytestring containers filepath HUnit hxt process QuickCheck

16698+ text unix

16699+ ];

16700+ benchmarkHaskellDepends = [ base bytestring criterion text ];

16701+ doHaddock = false;

16702+ doCheck = false;

16703+ description = "Fast XML generation library";

16704+ license = stdenv.lib.licenses.bsd3;

16705+ }) {};

16706+ "xmlhtml" = callPackage

16707+ ({ mkDerivation, base, blaze-builder, blaze-html, blaze-markup

16708+ , bytestring, containers, parsec, text, unordered-containers

16709+ }:

16710+ mkDerivation {

16711+ pname = "xmlhtml";

16712+ version = "0.2.3.3";

16713+ sha256 = "0n95284z24ddgw7v8zjqzanyrshxydcxs4ivchpj88gh5r3ryv5j";

16714+ revision = "1";

16715+ editedCabalFile = "0c5jva1rlvm0kpi1ii4i9c1v2vqyc6l0a8pljc120qbz8v87y5w3";

16716+ configureFlags = [

16717+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16718+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16719+ "-fsplitbase" "-f-test-hlint"

16720+ ];

16721+ libraryHaskellDepends = [

16722+ base blaze-builder blaze-html blaze-markup bytestring containers

16723+ parsec text unordered-containers

16724+ ];

16725+ description = "XML parser and renderer with HTML 5 quirks mode";

16726+ license = stdenv.lib.licenses.bsd3;

16727+ }) {};

16728+ "xss-sanitize" = callPackage

16729+ ({ mkDerivation, attoparsec, base, containers, css-text, hspec

16730+ , HUnit, network, tagsoup, text, utf8-string

16731+ }:

16732+ mkDerivation {

16733+ pname = "xss-sanitize";

16734+ version = "0.3.5.4";

16735+ sha256 = "1h9dj234sj216g676la0h73nwm0fw4snik31qi0s754vyy6bcygf";

16736+ configureFlags = [

16737+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16738+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16739+ "-fsplitbase" "-f-test-hlint"

16740+ ];

16741+ libraryHaskellDepends = [

16742+ attoparsec base containers css-text network tagsoup text

16743+ utf8-string

16744+ ];

16745+ testHaskellDepends = [

16746+ attoparsec base containers css-text hspec HUnit network tagsoup

16747+ text utf8-string

16748+ ];

16749+ homepage = "http://github.com/yesodweb/haskell-xss-sanitize";

16750+ description = "sanitize untrusted HTML to prevent XSS attacks";

16751+ license = stdenv.lib.licenses.bsd3;

16752+ }) {};

16753+ "yackage" = callPackage

16754+ ({ mkDerivation, base, blaze-builder, blaze-html, bytestring, Cabal

16755+ , cmdargs, conduit, containers, directory, hamlet, http-conduit

16756+ , http-types, shakespeare, tar, text, transformers

16757+ , unordered-containers, vector, wai, warp, yaml, yesod-core

16758+ , yesod-form, zlib

16759+ }:

16760+ mkDerivation {

16761+ pname = "yackage";

16762+ version = "0.7.0.5";

16763+ sha256 = "17bn9i3l8bgh7h641bix2faskx91gbl5clnz7xv8h64zj1bdqzy9";

16764+ configureFlags = [

16765+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16766+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16767+ "-fsplitbase" "-f-test-hlint"

16768+ ];

16769+ isLibrary = false;

16770+ isExecutable = true;

16771+ executableHaskellDepends = [

16772+ base blaze-builder blaze-html bytestring Cabal cmdargs conduit

16773+ containers directory hamlet http-conduit http-types shakespeare tar

16774+ text transformers unordered-containers vector wai warp yaml

16775+ yesod-core yesod-form zlib

16776+ ];

16777+ doHaddock = false;

16778+ homepage = "http://github.com/snoyberg/yackage";

16779+ description = "Personal Hackage replacement for testing new packages";

16780+ license = stdenv.lib.licenses.bsd3;

16781+ }) {};

16782+ "yaml" = callPackage

16783+ ({ mkDerivation, aeson, aeson-qq, attoparsec, base, bytestring

16784+ , conduit, containers, directory, enclosed-exceptions, filepath

16785+ , hspec, hspec-expectations, HUnit, resourcet, scientific, text

16786+ , transformers, unordered-containers, vector

16787+ }:

16788+ mkDerivation {

16789+ pname = "yaml";

16790+ version = "0.8.10.1";

16791+ sha256 = "1a8v8digg6mcc4gx4kgfg8wzgj18wdf40wv1b7n72dg1c8kr2xz9";

16792+ configureFlags = [

16793+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16794+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16795+ "-fsplitbase" "-f-test-hlint"

16796+ ];

16797+ isLibrary = true;

16798+ isExecutable = true;

16799+ libraryHaskellDepends = [

16800+ aeson attoparsec base bytestring conduit containers directory

16801+ enclosed-exceptions filepath resourcet scientific text transformers

16802+ unordered-containers vector

16803+ ];

16804+ executableHaskellDepends = [ aeson base bytestring ];

16805+ testHaskellDepends = [

16806+ aeson aeson-qq base bytestring conduit directory hspec

16807+ hspec-expectations HUnit resourcet text transformers

16808+ unordered-containers vector

16809+ ];

16810+ homepage = "http://github.com/snoyberg/yaml/";

16811+ description = "Support for parsing and rendering YAML documents";

16812+ license = stdenv.lib.licenses.bsd3;

16813+ }) {};

16814+ "yesod" = callPackage

16815+ ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring

16816+ , conduit-extra, data-default, directory, fast-logger

16817+ , monad-control, monad-logger, safe, semigroups, shakespeare

16818+ , streaming-commons, template-haskell, text, transformers, unix

16819+ , unordered-containers, wai, wai-extra, wai-logger, warp, yaml

16820+ , yesod-auth, yesod-core, yesod-form, yesod-persistent

16821+ }:

16822+ mkDerivation {

16823+ pname = "yesod";

16824+ version = "1.4.1.1";

16825+ sha256 = "0p95f6gjpcl28ysl82hbyxh7fjql6lr5csndmnrd264h2pd88pxx";

16826+ configureFlags = [

16827+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16828+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16829+ "-fsplitbase" "-f-test-hlint"

16830+ ];

16831+ libraryHaskellDepends = [

16832+ aeson base blaze-html blaze-markup bytestring conduit-extra

16833+ data-default directory fast-logger monad-control monad-logger safe

16834+ semigroups shakespeare streaming-commons template-haskell text

16835+ transformers unix unordered-containers wai wai-extra wai-logger

16836+ warp yaml yesod-auth yesod-core yesod-form yesod-persistent

16837+ ];

16838+ homepage = "http://www.yesodweb.com/";

16839+ description = "Creation of type-safe, RESTful web applications";

16840+ license = stdenv.lib.licenses.mit;

16841+ }) {};

16842+ "yesod-auth" = callPackage

16843+ ({ mkDerivation, aeson, authenticate, base, base16-bytestring

16844+ , base64-bytestring, binary, blaze-builder, blaze-html

16845+ , blaze-markup, byteable, bytestring, conduit, conduit-extra

16846+ , containers, cryptohash, data-default, email-validate, file-embed

16847+ , http-client, http-conduit, http-types, lifted-base, mime-mail

16848+ , network, persistent, persistent-template, random, resourcet, safe

16849+ , shakespeare, template-haskell, text, time, transformers

16850+ , unordered-containers, wai, yesod-core, yesod-form

16851+ , yesod-persistent

16852+ }:

16853+ mkDerivation {

16854+ pname = "yesod-auth";

16855+ version = "1.4.1";

16856+ sha256 = "1nvc5ni4bwhb10ayr75s3z44ynv9kq3lp6kgd536xyagbi054gdp";

16857+ configureFlags = [

16858+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16859+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16860+ "-fsplitbase" "-f-test-hlint"

16861+ ];

16862+ libraryHaskellDepends = [

16863+ aeson authenticate base base16-bytestring base64-bytestring binary

16864+ blaze-builder blaze-html blaze-markup byteable bytestring conduit

16865+ conduit-extra containers cryptohash data-default email-validate

16866+ file-embed http-client http-conduit http-types lifted-base

16867+ mime-mail network persistent persistent-template random resourcet

16868+ safe shakespeare template-haskell text time transformers

16869+ unordered-containers wai yesod-core yesod-form yesod-persistent

16870+ ];

16871+ homepage = "http://www.yesodweb.com/";

16872+ description = "Authentication for Yesod";

16873+ license = stdenv.lib.licenses.mit;

16874+ }) {};

16875+ "yesod-auth-deskcom" = callPackage

16876+ ({ mkDerivation, aeson, base, base64-bytestring, byteable

16877+ , bytestring, cipher-aes, cprng-aes, crypto-api, crypto-random

16878+ , cryptohash, data-default, http-conduit, http-types

16879+ , template-haskell, text, time, transformers, yesod-auth

16880+ , yesod-core

16881+ }:

16882+ mkDerivation {

16883+ pname = "yesod-auth-deskcom";

16884+ version = "1.4.0";

16885+ sha256 = "17lpkwrfc10rdmvkjg6qmbi7gysjjhqyh7n5d1mxgxhzxzqbi06w";

16886+ configureFlags = [

16887+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16888+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16889+ "-fsplitbase" "-f-test-hlint"

16890+ ];

16891+ libraryHaskellDepends = [

16892+ aeson base base64-bytestring byteable bytestring cipher-aes

16893+ cprng-aes crypto-api crypto-random cryptohash data-default

16894+ http-conduit http-types template-haskell text time transformers

16895+ yesod-auth yesod-core

16896+ ];

16897+ homepage = "https://github.com/prowdsponsor/yesod-auth-deskcom";

16898+ description = "Desk.com remote authentication support for Yesod apps.";

16899+ license = stdenv.lib.licenses.bsd3;

16900+ }) {};

16901+ "yesod-auth-fb" = callPackage

16902+ ({ mkDerivation, aeson, base, bytestring, conduit, fb, http-conduit

16903+ , lifted-base, shakespeare, text, time, transformers, wai

16904+ , yesod-auth, yesod-core, yesod-fb

16905+ }:

16906+ mkDerivation {

16907+ pname = "yesod-auth-fb";

16908+ version = "1.6.6";

16909+ sha256 = "00pk5vridic77laydkfhrixfv50ps7f15dxvcd44cn0z8s2d3y74";

16910+ configureFlags = [

16911+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16912+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16913+ "-fsplitbase" "-f-test-hlint"

16914+ ];

16915+ libraryHaskellDepends = [

16916+ aeson base bytestring conduit fb http-conduit lifted-base

16917+ shakespeare text time transformers wai yesod-auth yesod-core

16918+ yesod-fb

16919+ ];

16920+ homepage = "https://github.com/prowdsponsor/yesod-auth-fb";

16921+ description = "Authentication backend for Yesod using Facebook";

16922+ license = stdenv.lib.licenses.bsd3;

16923+ }) {};

16924+ "yesod-auth-hashdb" = callPackage

16925+ ({ mkDerivation, base, bytestring, cryptohash, hspec, persistent

16926+ , pwstore-fast, text, yesod-auth, yesod-core, yesod-form

16927+ , yesod-persistent

16928+ }:

16929+ mkDerivation {

16930+ pname = "yesod-auth-hashdb";

16931+ version = "1.4.1.1";

16932+ sha256 = "0bb37iawsdq3m5p1sjdnz954f3nfdmvvhm0hxap1z2hf9dk516ci";

16933+ configureFlags = [

16934+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16935+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16936+ "-fsplitbase" "-f-test-hlint"

16937+ ];

16938+ libraryHaskellDepends = [

16939+ base bytestring cryptohash persistent pwstore-fast text yesod-auth

16940+ yesod-core yesod-form yesod-persistent

16941+ ];

16942+ testHaskellDepends = [ base hspec text ];

16943+ homepage = "https://github.com/paul-rouse/yesod-auth-hashdb";

16944+ description = "Authentication plugin for Yesod";

16945+ license = stdenv.lib.licenses.mit;

16946+ }) {};

16947+ "yesod-bin" = callPackage

16948+ ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder

16949+ , bytestring, Cabal, conduit, conduit-extra, containers

16950+ , data-default-class, directory, file-embed, filepath, fsnotify

16951+ , ghc, ghc-paths, http-conduit, http-reverse-proxy, http-types

16952+ , lifted-base, network, optparse-applicative, parsec, process

16953+ , project-template, resourcet, shakespeare, split

16954+ , streaming-commons, system-fileio, system-filepath, tar

16955+ , template-haskell, text, time, transformers, transformers-compat

16956+ , unix-compat, unordered-containers, wai, wai-extra, warp, yaml

16957+ , zlib

16958+ }:

16959+ mkDerivation {

16960+ pname = "yesod-bin";

16961+ version = "1.4.1";

16962+ sha256 = "0kzhnq0mv8s4qdkzqj05c7jdmp2xllv02kqgihwhyr2s4wvqmviw";

16963+ configureFlags = [

16964+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16965+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16966+ "-fsplitbase" "-f-test-hlint"

16967+ ];

16968+ isLibrary = false;

16969+ isExecutable = true;

16970+ enableSeparateDataOutput = true;

16971+ executableHaskellDepends = [

16972+ attoparsec base base64-bytestring blaze-builder bytestring Cabal

16973+ conduit conduit-extra containers data-default-class directory

16974+ file-embed filepath fsnotify ghc ghc-paths http-conduit

16975+ http-reverse-proxy http-types lifted-base network

16976+ optparse-applicative parsec process project-template resourcet

16977+ shakespeare split streaming-commons system-fileio system-filepath

16978+ tar template-haskell text time transformers transformers-compat

16979+ unix-compat unordered-containers wai wai-extra warp yaml zlib

16980+ ];

16981+ doHaddock = false;

16982+ homepage = "http://www.yesodweb.com/";

16983+ description = "The yesod helper executable";

16984+ license = stdenv.lib.licenses.mit;

16985+ }) {};

16986+ "yesod-core" = callPackage

16987+ ({ mkDerivation, aeson, async, auto-update, base, blaze-builder

16988+ , blaze-html, blaze-markup, bytestring, case-insensitive, cereal

16989+ , clientsession, conduit, conduit-extra, containers, cookie

16990+ , criterion, data-default, deepseq, directory, exceptions

16991+ , fast-logger, hspec, http-types, HUnit, lifted-base, monad-control

16992+ , monad-logger, mtl, mwc-random, network, old-locale, parsec

16993+ , path-pieces, primitive, QuickCheck, random, resourcet, safe

16994+ , shakespeare, streaming-commons, template-haskell, text, time

16995+ , transformers, transformers-base, unix-compat

16996+ , unordered-containers, vector, wai, wai-extra, wai-logger, warp

16997+ , word8

16998+ }:

16999+ mkDerivation {

17000+ pname = "yesod-core";

17001+ version = "1.4.6";

17002+ sha256 = "1xlqqiyn2p0c1qxrkx0mlkp4cra0adhlpw27y03icvj0c93xi27g";

17003+ configureFlags = [

17004+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17005+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17006+ "-fsplitbase" "-f-test-hlint"

17007+ ];

17008+ libraryHaskellDepends = [

17009+ aeson auto-update base blaze-builder blaze-html blaze-markup

17010+ bytestring case-insensitive cereal clientsession conduit

17011+ conduit-extra containers cookie data-default deepseq directory

17012+ exceptions fast-logger http-types lifted-base monad-control

17013+ monad-logger mtl mwc-random old-locale parsec path-pieces primitive

17014+ random resourcet safe shakespeare template-haskell text time

17015+ transformers transformers-base unix-compat unordered-containers

17016+ vector wai wai-extra wai-logger warp word8

17017+ ];

17018+ testHaskellDepends = [

17019+ async base blaze-builder bytestring conduit conduit-extra

17020+ containers hspec http-types HUnit lifted-base mwc-random network

17021+ path-pieces QuickCheck random resourcet shakespeare

17022+ streaming-commons template-haskell text transformers wai wai-extra

17023+ ];

17024+ benchmarkHaskellDepends = [

17025+ base blaze-html bytestring criterion text transformers

17026+ ];

17027+ homepage = "http://www.yesodweb.com/";

17028+ description = "Creation of type-safe, RESTful web applications";

17029+ license = stdenv.lib.licenses.mit;

17030+ }) {};

17031+ "yesod-eventsource" = callPackage

17032+ ({ mkDerivation, base, blaze-builder, conduit, transformers, wai

17033+ , wai-eventsource, wai-extra, yesod-core

17034+ }:

17035+ mkDerivation {

17036+ pname = "yesod-eventsource";

17037+ version = "1.4.0";

17038+ sha256 = "0j2r05cryzn1ncgx2ylr39dg72zhr4n09166ps0dkcbdfva48ps9";

17039+ configureFlags = [

17040+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17041+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17042+ "-fsplitbase" "-f-test-hlint"

17043+ ];

17044+ libraryHaskellDepends = [

17045+ base blaze-builder conduit transformers wai wai-eventsource

17046+ wai-extra yesod-core

17047+ ];

17048+ homepage = "http://www.yesodweb.com/";

17049+ description = "Server-sent events support for Yesod apps";

17050+ license = stdenv.lib.licenses.mit;

17051+ }) {};

17052+ "yesod-fay" = callPackage

17053+ ({ mkDerivation, aeson, base, bytestring, data-default, directory

17054+ , fay, fay-dom, monad-loops, process, pureMD5, shakespeare

17055+ , system-fileio, system-filepath, template-haskell, text

17056+ , transformers, utf8-string, yesod-core, yesod-form, yesod-static

17057+ }:

17058+ mkDerivation {

17059+ pname = "yesod-fay";

17060+ version = "0.7.0";

17061+ sha256 = "1q02r7gd0fbhasc10h8my6j3vcc50pagpz8gvrbsc7x928gp42p4";

17062+ configureFlags = [

17063+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17064+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17065+ "-fsplitbase" "-f-test-hlint"

17066+ ];

17067+ libraryHaskellDepends = [

17068+ aeson base bytestring data-default directory fay fay-dom

17069+ monad-loops process pureMD5 shakespeare system-fileio

17070+ system-filepath template-haskell text transformers utf8-string

17071+ yesod-core yesod-form yesod-static

17072+ ];

17073+ homepage = "https://github.com/fpco/yesod-fay";

17074+ description = "Utilities for using the Fay Haskell-to-JS compiler with Yesod";

17075+ license = stdenv.lib.licenses.mit;

17076+ }) {};

17077+ "yesod-fb" = callPackage

17078+ ({ mkDerivation, aeson, base, bytestring, conduit, crypto-api, fb

17079+ , http-conduit, text, wai, yesod-core

17080+ }:

17081+ mkDerivation {

17082+ pname = "yesod-fb";

17083+ version = "0.3.4";

17084+ sha256 = "09cymp9y21vawbgr6gcj41s5xkq6j22mvk0vgl3pnyq382j33rmp";

17085+ configureFlags = [

17086+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17087+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17088+ "-fsplitbase" "-f-test-hlint"

17089+ ];

17090+ libraryHaskellDepends = [

17091+ aeson base bytestring conduit crypto-api fb http-conduit text wai

17092+ yesod-core

17093+ ];

17094+ homepage = "https://github.com/prowdsponsor/yesod-fb";

17095+ description = "Useful glue functions between the fb library and Yesod";

17096+ license = stdenv.lib.licenses.bsd3;

17097+ }) {};

17098+ "yesod-form" = callPackage

17099+ ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html

17100+ , blaze-markup, byteable, bytestring, containers, data-default

17101+ , email-validate, hspec, network, persistent, resourcet

17102+ , shakespeare, template-haskell, text, time, transformers, wai

17103+ , xss-sanitize, yesod-core, yesod-persistent

17104+ }:

17105+ mkDerivation {

17106+ pname = "yesod-form";

17107+ version = "1.4.3";

17108+ sha256 = "08ivcqq4glyyvjm60fsmd4linqr6kkh6wn4bbcpzinvpv6asr6mr";

17109+ configureFlags = [

17110+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17111+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17112+ "-fsplitbase" "-f-test-hlint"

17113+ ];

17114+ libraryHaskellDepends = [

17115+ aeson attoparsec base blaze-builder blaze-html blaze-markup

17116+ byteable bytestring containers data-default email-validate network

17117+ persistent resourcet shakespeare template-haskell text time

17118+ transformers wai xss-sanitize yesod-core yesod-persistent

17119+ ];

17120+ testHaskellDepends = [ base hspec text time ];

17121+ homepage = "http://www.yesodweb.com/";

17122+ description = "Form handling support for Yesod Web Framework";

17123+ license = stdenv.lib.licenses.mit;

17124+ }) {};

17125+ "yesod-gitrepo" = callPackage

17126+ ({ mkDerivation, base, directory, enclosed-exceptions, http-types

17127+ , lifted-base, process, system-filepath, temporary, text, wai

17128+ , yesod-core

17129+ }:

17130+ mkDerivation {

17131+ pname = "yesod-gitrepo";

17132+ version = "0.1.1.0";

17133+ sha256 = "1bf4rhf6i4cciyllkh6zil29i7yi5ph0nkpcqmhbihk4i7xm05zj";

17134+ configureFlags = [

17135+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17136+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17137+ "-fsplitbase" "-f-test-hlint"

17138+ ];

17139+ libraryHaskellDepends = [

17140+ base directory enclosed-exceptions http-types lifted-base process

17141+ system-filepath temporary text wai yesod-core

17142+ ];

17143+ homepage = "https://github.com/snoyberg/yesod-gitrepo";

17144+ description = "Host content provided by a Git repo";

17145+ license = stdenv.lib.licenses.mit;

17146+ }) {};

17147+ "yesod-newsfeed" = callPackage

17148+ ({ mkDerivation, base, blaze-html, blaze-markup, bytestring

17149+ , containers, shakespeare, text, time, xml-conduit, yesod-core

17150+ }:

17151+ mkDerivation {

17152+ pname = "yesod-newsfeed";

17153+ version = "1.4.0";

17154+ sha256 = "0gp9xsfvzylkj8k3cqldi6804maz95iq9bl8yc1mcmhsakq3jfxw";

17155+ configureFlags = [

17156+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17157+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17158+ "-fsplitbase" "-f-test-hlint"

17159+ ];

17160+ libraryHaskellDepends = [

17161+ base blaze-html blaze-markup bytestring containers shakespeare text

17162+ time xml-conduit yesod-core

17163+ ];

17164+ homepage = "http://www.yesodweb.com/";

17165+ description = "Helper functions and data types for producing News feeds";

17166+ license = stdenv.lib.licenses.mit;

17167+ }) {};

17168+ "yesod-persistent" = callPackage

17169+ ({ mkDerivation, base, blaze-builder, conduit, hspec, persistent

17170+ , persistent-sqlite, persistent-template, resource-pool, resourcet

17171+ , text, transformers, wai-extra, yesod-core

17172+ }:

17173+ mkDerivation {

17174+ pname = "yesod-persistent";

17175+ version = "1.4.0.1";

17176+ sha256 = "08648n6b4xhsqbvqh8vpsf3481hvzhrkyqbzs303s6fz683mn0zw";

17177+ configureFlags = [

17178+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17179+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17180+ "-fsplitbase" "-f-test-hlint"

17181+ ];

17182+ libraryHaskellDepends = [

17183+ base blaze-builder conduit persistent persistent-template

17184+ resource-pool resourcet transformers yesod-core

17185+ ];

17186+ testHaskellDepends = [

17187+ base blaze-builder conduit hspec persistent persistent-sqlite text

17188+ wai-extra yesod-core

17189+ ];

17190+ homepage = "http://www.yesodweb.com/";

17191+ description = "Some helpers for using Persistent from Yesod";

17192+ license = stdenv.lib.licenses.mit;

17193+ }) {};

17194+ "yesod-sitemap" = callPackage

17195+ ({ mkDerivation, base, conduit, containers, data-default, text

17196+ , time, xml-conduit, xml-types, yesod-core

17197+ }:

17198+ mkDerivation {

17199+ pname = "yesod-sitemap";

17200+ version = "1.4.0";

17201+ sha256 = "0v2ksy6vvn43ll3gf0fy0n46xzn3j59b5667in4lq4dwxllmn1fk";

17202+ configureFlags = [

17203+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17204+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17205+ "-fsplitbase" "-f-test-hlint"

17206+ ];

17207+ libraryHaskellDepends = [

17208+ base conduit containers data-default text time xml-conduit

17209+ xml-types yesod-core

17210+ ];

17211+ homepage = "http://www.yesodweb.com/";

17212+ description = "Generate XML sitemaps";

17213+ license = stdenv.lib.licenses.mit;

17214+ }) {};

17215+ "yesod-static" = callPackage

17216+ ({ mkDerivation, async, attoparsec, base, base64-bytestring

17217+ , blaze-builder, byteable, bytestring, conduit, conduit-extra

17218+ , containers, cryptohash, cryptohash-conduit, css-text

17219+ , data-default, directory, file-embed, filepath, hashable, hjsmin

17220+ , hspec, http-types, HUnit, mime-types, old-time, process

17221+ , resourcet, system-fileio, system-filepath, template-haskell, text

17222+ , transformers, unix-compat, unordered-containers, wai

17223+ , wai-app-static, wai-extra, yesod-core, yesod-test

17224+ }:

17225+ mkDerivation {

17226+ pname = "yesod-static";

17227+ version = "1.4.0.3";

17228+ sha256 = "15rwlw76rfh18l3ap73aqmwz4bafmxbr5pchyarll14ps0rjs74g";

17229+ revision = "1";

17230+ editedCabalFile = "0cv6k39ijvph3pgfxnsw26kqzszay4gmbj7vzh8z92b67q23cb31";

17231+ configureFlags = [

17232+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17233+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17234+ "-fsplitbase" "-f-test-hlint"

17235+ ];

17236+ libraryHaskellDepends = [

17237+ async attoparsec base base64-bytestring blaze-builder byteable

17238+ bytestring conduit conduit-extra containers cryptohash

17239+ cryptohash-conduit css-text data-default directory file-embed

17240+ filepath hashable hjsmin http-types mime-types old-time process

17241+ resourcet system-fileio system-filepath template-haskell text

17242+ transformers unix-compat unordered-containers wai wai-app-static

17243+ yesod-core

17244+ ];

17245+ testHaskellDepends = [

17246+ async base base64-bytestring byteable bytestring conduit

17247+ conduit-extra containers cryptohash cryptohash-conduit data-default

17248+ directory file-embed filepath hjsmin hspec http-types HUnit

17249+ mime-types old-time process resourcet system-fileio system-filepath

17250+ template-haskell text transformers unix-compat unordered-containers

17251+ wai wai-app-static wai-extra yesod-core yesod-test

17252+ ];

17253+ homepage = "http://www.yesodweb.com/";

17254+ description = "Static file serving subsite for Yesod Web Framework";

17255+ license = stdenv.lib.licenses.mit;

17256+ }) {};

17257+ "yesod-test" = callPackage

17258+ ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html

17259+ , blaze-markup, bytestring, case-insensitive, containers, cookie

17260+ , hspec, hspec-core, html-conduit, http-types, HUnit, monad-control

17261+ , network, persistent, text, time, transformers, wai, wai-extra

17262+ , xml-conduit, xml-types, yesod-core, yesod-form

17263+ }:

17264+ mkDerivation {

17265+ pname = "yesod-test";

17266+ version = "1.4.2";

17267+ sha256 = "09iia8vligw41ayhp1fp797n783avb0sf89z8midindrhb5plfbl";

17268+ configureFlags = [

17269+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17270+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17271+ "-fsplitbase" "-f-test-hlint"

17272+ ];

17273+ libraryHaskellDepends = [

17274+ attoparsec base blaze-builder blaze-html blaze-markup bytestring

17275+ case-insensitive containers cookie hspec-core html-conduit

17276+ http-types HUnit monad-control network persistent text time

17277+ transformers wai wai-extra xml-conduit xml-types yesod-core

17278+ ];

17279+ testHaskellDepends = [

17280+ base bytestring containers hspec html-conduit HUnit text wai

17281+ xml-conduit yesod-core yesod-form

17282+ ];

17283+ homepage = "http://www.yesodweb.com";

17284+ description = "integration testing for WAI/Yesod Applications";

17285+ license = stdenv.lib.licenses.mit;

17286+ }) {};

17287+ "yesod-text-markdown" = callPackage

17288+ ({ mkDerivation, aeson, base, markdown, persistent, shakespeare

17289+ , text, yesod-core, yesod-form, yesod-persistent

17290+ }:

17291+ mkDerivation {

17292+ pname = "yesod-text-markdown";

17293+ version = "0.1.7";

17294+ sha256 = "133zv2f8240qbygpza39m28k4hfy2aiqmr6ds8ihwbb8dz98d5rr";

17295+ configureFlags = [

17296+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17297+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17298+ "-fsplitbase" "-f-test-hlint"

17299+ ];

17300+ libraryHaskellDepends = [

17301+ aeson base markdown persistent shakespeare text yesod-core

17302+ yesod-form yesod-persistent

17303+ ];

17304+ description = "Yesod support for Text.Markdown.";

17305+ license = stdenv.lib.licenses.bsd3;

17306+ }) {};

17307+ "yesod-websockets" = callPackage

17308+ ({ mkDerivation, async, base, conduit, monad-control, transformers

17309+ , wai, wai-websockets, websockets, yesod-core

17310+ }:

17311+ mkDerivation {

17312+ pname = "yesod-websockets";

17313+ version = "0.2.0";

17314+ sha256 = "11inlw447n558kndzdhnz80589jzg81mrww8xk573am905q57zb0";

17315+ configureFlags = [

17316+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17317+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17318+ "-fsplitbase" "-f-test-hlint"

17319+ ];

17320+ libraryHaskellDepends = [

17321+ async base conduit monad-control transformers wai wai-websockets

17322+ websockets yesod-core

17323+ ];

17324+ homepage = "https://github.com/yesodweb/yesod";

17325+ description = "WebSockets support for Yesod";

17326+ license = stdenv.lib.licenses.mit;

17327+ }) {};

17328+ "zeromq4-haskell" = callPackage

17329+ ({ mkDerivation, async, base, bytestring, containers, exceptions

17330+ , QuickCheck, semigroups, tasty, tasty-hunit, tasty-quickcheck

17331+ , transformers, zeromq

17332+ }:

17333+ mkDerivation {

17334+ pname = "zeromq4-haskell";

17335+ version = "0.6.2";

17336+ sha256 = "07dbsapzc4hqq9sg63v4wyjad13sqh9zsx3ckwc5hg5z6vknpafb";

17337+ configureFlags = [

17338+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17339+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17340+ "-fsplitbase" "-f-test-hlint"

17341+ ];

17342+ libraryHaskellDepends = [

17343+ async base bytestring containers exceptions semigroups transformers

17344+ ];

17345+ libraryPkgconfigDepends = [ zeromq ];

17346+ testHaskellDepends = [

17347+ async base bytestring QuickCheck tasty tasty-hunit tasty-quickcheck

17348+ ];

17349+ homepage = "http://github.com/twittner/zeromq-haskell/";

17350+ description = "Bindings to ZeroMQ 4.x";

17351+ license = stdenv.lib.licenses.mit;

17352+ }) {inherit (pkgs) zeromq;};

17353+ "zip-archive" = callPackage

17354+ ({ mkDerivation, array, base, binary, bytestring, containers

17355+ , digest, directory, filepath, HUnit, mtl, old-time, pretty

17356+ , process, text, time, unix, zlib

17357+ }:

17358+ mkDerivation {

17359+ pname = "zip-archive";

17360+ version = "0.2.3.5";

17361+ sha256 = "0qa3qvaj0xkh4qw7s96rkbdmkyhnql6g92yplm7m6n7z7nxrcs18";

17362+ configureFlags = [

17363+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17364+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17365+ "-fsplitbase" "-f-test-hlint"

17366+ ];

17367+ isLibrary = true;

17368+ isExecutable = true;

17369+ libraryHaskellDepends = [

17370+ array base binary bytestring containers digest directory filepath

17371+ mtl old-time pretty text time unix zlib

17372+ ];

17373+ executableHaskellDepends = [ base bytestring directory ];

17374+ testHaskellDepends = [

17375+ base bytestring directory HUnit old-time process time

17376+ ];

17377+ homepage = "http://github.com/jgm/zip-archive";

17378+ description = "Library for creating and modifying zip archives";

17379+ license = stdenv.lib.licenses.bsd3;

17380+ }) {};

17381+ "zlib" = callPackage

17382+ ({ mkDerivation, base, bytestring, zlib }:

17383+ mkDerivation {

17384+ pname = "zlib";

17385+ version = "0.5.4.2";

17386+ sha256 = "15hhsk7z3gvm7sz2ic2z1ca5c6rpsln2rr391mdbm1bxlzc1gmkm";

17387+ configureFlags = [

17388+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17389+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17390+ "-fsplitbase" "-f-test-hlint"

17391+ ];

17392+ libraryHaskellDepends = [ base bytestring ];

17393+ librarySystemDepends = [ zlib ];

17394+ description = "Compression and decompression in the gzip and zlib formats";

17395+ license = stdenv.lib.licenses.bsd3;

17396+ }) {inherit (pkgs) zlib;};

17397+ "zlib-bindings" = callPackage

17398+ ({ mkDerivation, base, bytestring, hspec, QuickCheck, zlib }:

17399+ mkDerivation {

17400+ pname = "zlib-bindings";

17401+ version = "0.1.1.5";

17402+ sha256 = "02ciywlz4wdlymgc3jsnicz9kzvymjw1www2163gxidnz4wb8fy8";

17403+ revision = "2";

17404+ editedCabalFile = "0fq49694gqkab8m0vq4i879blswczwd66n7xh4r4gwiahf0ryvqc";

17405+ configureFlags = [

17406+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17407+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17408+ "-fsplitbase" "-f-test-hlint"

17409+ ];

17410+ libraryHaskellDepends = [ base bytestring zlib ];

17411+ testHaskellDepends = [ base bytestring hspec QuickCheck zlib ];

17412+ homepage = "http://github.com/snapframework/zlib-bindings";

17413+ description = "Low-level bindings to the zlib package";

17414+ license = stdenv.lib.licenses.bsd3;

17415+ }) {};

17416+ "zlib-enum" = callPackage

17417+ ({ mkDerivation, base, bytestring, enumerator, transformers

17418+ , zlib-bindings

17419+ }:

17420+ mkDerivation {

17421+ pname = "zlib-enum";

17422+ version = "0.2.3.1";

17423+ sha256 = "1nfczminxafzk69ry1sqkj1ha0jlv3l9ak10yk205snfhpmcjgg4";

17424+ configureFlags = [

17425+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17426+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17427+ "-fsplitbase" "-f-test-hlint"

17428+ ];

17429+ isLibrary = true;

17430+ isExecutable = true;

17431+ libraryHaskellDepends = [

17432+ base bytestring enumerator transformers zlib-bindings

17433+ ];

17434+ homepage = "http://github.com/maltem/zlib-enum";

17435+ description = "Enumerator interface for zlib compression";

17436+ license = stdenv.lib.licenses.mit;

17437+ }) {};

17438+ "zlib-lens" = callPackage

17439+ ({ mkDerivation, base, bytestring, lens, zlib }:

17440+ mkDerivation {

17441+ pname = "zlib-lens";

17442+ version = "0.1";

17443+ sha256 = "1sdvdfw2kimi7pxmv4xdha9q19sglfhaxacypfz3za1rajk0bfzx";

17444+ configureFlags = [

17445+ "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17446+ "-f-network-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17447+ "-fsplitbase" "-f-test-hlint"

17448+ ];

17449+ libraryHaskellDepends = [ base bytestring lens zlib ];

17450+ homepage = "lens.github.io";

17451+ description = "Lenses for zlib";

17452+ license = stdenv.lib.licenses.bsd3;

17453+ }) {};

17454+

17455+}

stackage/lts-0.1/configuration-packages.nixnew file+47

@@ -0,0 +1,47 @@

1+# Generated by stackage2nix 0.5.0 from "/nix/store/5hv357jpjvwz6dk84fmcz1mj7agww772-stackage-lts/lts-0.1.yaml"

2+{ pkgs, haskellLib }:

4+with haskellLib; self: super: {

6+ # core packages

7+ "Cabal" = null;

8+ "array" = null;

9+ "base" = null;

10+ "bin-package-db" = null;

11+ "binary" = null;

12+ "bytestring" = null;

13+ "containers" = null;

14+ "deepseq" = null;

15+ "directory" = null;

16+ "filepath" = null;

17+ "ghc-prim" = null;

18+ "haskeline" = null;

19+ "haskell2010" = null;

20+ "haskell98" = null;

21+ "hoopl" = null;

22+ "hpc" = null;

23+ "integer-gmp" = null;

24+ "old-locale" = null;

25+ "old-time" = null;

26+ "pretty" = null;

27+ "process" = null;

28+ "rts" = null;

29+ "template-haskell" = null;

30+ "terminfo" = null;

31+ "time" = null;

32+ "transformers" = null;

33+ "unix" = null;

34+ "xhtml" = null;

35+ # break cycle: text QuickCheck test-framework xml test-framework-hunit test-framework-quickcheck2

36+ "QuickCheck" = dontCheck super.QuickCheck;

37+ "text" = dontCheck super.text;

38+ # break cycle: hspec-meta hspec-expectations hspec hspec-core silently nanospec hspec-discover stringbuilder markdown-unlit

39+ "markdown-unlit" = dontCheck super.markdown-unlit;

40+ "stringbuilder" = dontCheck super.stringbuilder;

41+ "hspec-discover" = dontCheck super.hspec-discover;

42+ "nanospec" = dontCheck super.nanospec;

43+ "hspec-expectations" = dontCheck super.hspec-expectations;

44+ # break cycle: statistics monad-par mwc-random vector-algorithms

45+ "mwc-random" = dontCheck super.mwc-random;

46+

47+}

stackage/lts-0.1/default.nixnew file+14

@@ -0,0 +1,14 @@

1+# Generated by stackage2nix 0.5.0 from "/nix/store/5hv357jpjvwz6dk84fmcz1mj7agww772-stackage-lts/lts-0.1.yaml"

2+{ callPackage, pkgs, overrides ? (self: super: {})

3+, packageSetConfig ? (sefl: super: {})

4+}:

6+let

7+ haskellLib = pkgs.haskell.lib;

8+in callPackage (<nixpkgs/pkgs/development/haskell-modules>) {

9+ ghc = pkgs.haskell.compiler.ghc783;

10+ compilerConfig = import ./configuration-packages.nix { inherit pkgs haskellLib; };

11+ initialPackages = import ./packages.nix;

12+ configurationCommon = if builtins.pathExists ./configuration-common.nix then import ./configuration-common.nix else args: self: super: {};

13+ inherit haskellLib overrides packageSetConfig;

14+}

stackage/lts-0.1/packages.nixnew file+17456