stackage/lts-1.15/packages.nix · nixpkgs-stackage

git.iko.soy/nixpkgs-stackage

on master help sign in

nixpkgs-stackage/stackage/lts-1.15/packages.nix

18219 lines 759 kB history raw

1# Generated by stackage2nix 0.6.1 from "/nix/store/jwic59nw202khsy06b5hy9irq3zipzb8-stackage-lts/lts-1.15.yaml"

2{ pkgs, stdenv, callPackage }:

4self: {

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 "-fnetwork-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 "-fnetwork-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 "-fnetwork-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 "-fnetwork-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 "-fnetwork-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 "-fnetwork-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.3";

136 sha256 = "1shq0320mc47kjbfw3vqrmjshb8fd3afd009kqxd8nn9g7m48019";

137 configureFlags = [

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

139 "-fnetwork-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.3";

159 sha256 = "1bvlfy2gmv0w99jr32srdvrh7g0fzgvwhmzw8sf2iii12a7xwf56";

160 configureFlags = [

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

162 "-fnetwork-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.11";

182 sha256 = "00z3h4qpy7n9khygwjzn5dziv4fgvgj72fkan3m7f27d2y3cbw4w";

183 configureFlags = [

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

185 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

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

187 ];

188 libraryHaskellDepends = [

189 base containers mtl QuickCheck random syb

190 ];

191 testHaskellDepends = [

192 array base containers mtl QuickCheck random syb

193 ];

194 description = "For testing partial and infinite values";

195 license = stdenv.lib.licenses.mit;

196 }) {};

197 "DAV" = callPackage

198 ({ mkDerivation, base, bytestring, case-insensitive, containers

199 , data-default, either, errors, exceptions, http-client

200 , http-client-tls, http-types, lens, mtl, network, network-uri

201 , optparse-applicative, transformers, transformers-base

202 , utf8-string, xml-conduit, xml-hamlet

203 }:

204 mkDerivation {

205 pname = "DAV";

206 version = "1.0.3";

207 sha256 = "1wrs3rdk4sarzi4w1pma8h751mjw5x1l8c6w30wv7fg0rmk2cayd";

208 configureFlags = [

209 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

210 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

211 "-fsplitbase" "-f-test-hlint"

212 ];

213 isLibrary = true;

214 isExecutable = true;

215 libraryHaskellDepends = [

216 base bytestring case-insensitive containers data-default either

217 errors exceptions http-client http-client-tls http-types lens mtl

218 transformers transformers-base utf8-string xml-conduit xml-hamlet

219 ];

220 executableHaskellDepends = [

221 base bytestring case-insensitive containers data-default either

222 errors exceptions http-client http-client-tls http-types lens mtl

223 network network-uri optparse-applicative transformers

224 transformers-base utf8-string xml-conduit xml-hamlet

225 ];

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

227 description = "RFC 4918 WebDAV support";

228 license = stdenv.lib.licenses.gpl3;

229 }) {};

230 "Decimal" = callPackage

231 ({ mkDerivation, base, deepseq, HUnit, QuickCheck, test-framework

232 , test-framework-hunit, test-framework-quickcheck2

233 }:

234 mkDerivation {

235 pname = "Decimal";

236 version = "0.4.2";

237 sha256 = "0qa2z2lq1hrvakhyhj624mg8sd05ikhb66zwpa6x9vcyji93dxf5";

238 configureFlags = [

239 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

240 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

241 "-fsplitbase" "-f-test-hlint"

242 ];

243 libraryHaskellDepends = [ base deepseq ];

244 testHaskellDepends = [

245 base deepseq HUnit QuickCheck test-framework test-framework-hunit

246 test-framework-quickcheck2

247 ];

248 homepage = "https://github.com/PaulJohnson/Haskell-Decimal";

249 description = "Decimal numbers with variable precision";

250 license = stdenv.lib.licenses.bsd3;

251 }) {};

252 "Diff" = callPackage

253 ({ mkDerivation, array, base, pretty }:

254 mkDerivation {

255 pname = "Diff";

256 version = "0.3.1";

257 sha256 = "10saybbmd3qa4k11g0nqjfja7c87vi540y53j59778y0hhvykfif";

258 revision = "1";

259 editedCabalFile = "1p1kf8iq4j9v8aihw89ln02q92ipv4pqvdw3lvj939k3m60xs9yl";

260 configureFlags = [

261 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

262 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

263 "-fsplitbase" "-f-test-hlint"

264 ];

265 libraryHaskellDepends = [ array base pretty ];

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

267 license = stdenv.lib.licenses.bsd3;

268 }) {};

269 "FenwickTree" = callPackage

270 ({ mkDerivation, base, QuickCheck, template-haskell }:

271 mkDerivation {

272 pname = "FenwickTree";

273 version = "0.1.2.1";

274 sha256 = "0g7hhkim16wsjf8l79hqkiv1lain6jm8wpiml1iycra3n9i2s5ww";

275 configureFlags = [

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

277 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

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

279 ];

280 enableSeparateDataOutput = true;

281 libraryHaskellDepends = [ base QuickCheck template-haskell ];

282 testHaskellDepends = [ base QuickCheck template-haskell ];

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

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

285 license = stdenv.lib.licenses.bsd3;

286 }) {};

287 "FontyFruity" = callPackage

288 ({ mkDerivation, base, binary, bytestring, containers, deepseq

289 , directory, filepath, text, vector

290 }:

291 mkDerivation {

292 pname = "FontyFruity";

293 version = "0.4.1";

294 sha256 = "1rvb7if434lj7hb4ji0idarg2rmz4vn6l5k39nglv1lr7v9kz1y0";

295 configureFlags = [

296 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

297 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

298 "-fsplitbase" "-f-test-hlint"

299 ];

300 libraryHaskellDepends = [

301 base binary bytestring containers deepseq directory filepath text

302 vector

303 ];

304 description = "A true type file format loader";

305 license = stdenv.lib.licenses.bsd3;

306 }) {};

307 "GLURaw" = callPackage

308 ({ mkDerivation, base, freeglut, mesa, OpenGLRaw }:

309 mkDerivation {

310 pname = "GLURaw";

311 version = "1.4.0.2";

312 sha256 = "10sy0zag1wfrrq137azv3xazcgs21zb6bp84xzh518qbhiiycjhg";

313 revision = "1";

314 editedCabalFile = "020kyflci4wacgi3cc8rcf7rvhzxr1lzlm50sd6fmgf8179z2038";

315 configureFlags = [

316 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

317 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

318 "-fsplitbase" "-f-test-hlint"

319 ];

320 libraryHaskellDepends = [ base OpenGLRaw ];

321 librarySystemDepends = [ freeglut mesa ];

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

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

324 license = stdenv.lib.licenses.bsd3;

325 }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

326 "GLUT" = callPackage

327 ({ mkDerivation, array, base, containers, freeglut, mesa, OpenGL

328 , OpenGLRaw

329 }:

330 mkDerivation {

331 pname = "GLUT";

332 version = "2.5.1.1";

333 sha256 = "0n9dkdjmpnbcjg0ll0ny7mw21xwwix0gxy0hq6yagmgaakhpg0aa";

334 revision = "1";

335 editedCabalFile = "00mv87skns5gh81hb028nfiqz5xdl9ap0mv6nbw6w42naam6wflm";

336 configureFlags = [

337 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

338 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

339 "-fsplitbase" "-f-test-hlint"

340 ];

341 libraryHaskellDepends = [ array base containers OpenGL OpenGLRaw ];

342 librarySystemDepends = [ freeglut mesa ];

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

344 description = "A binding for the OpenGL Utility Toolkit";

345 license = stdenv.lib.licenses.bsd3;

346 }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

347 "GenericPretty" = callPackage

348 ({ mkDerivation, base, ghc-prim, pretty }:

349 mkDerivation {

350 pname = "GenericPretty";

351 version = "1.2.1";

352 sha256 = "0bb70mic7srr7x8k83d1i0m0a32gm72zr78ccdf3ckchj9136php";

353 configureFlags = [

354 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

355 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

356 "-fsplitbase" "-f-test-hlint"

357 ];

358 libraryHaskellDepends = [ base ghc-prim pretty ];

359 homepage = "https://github.com/RazvanRanca/GenericPretty";

360 description = "A generic, derivable, haskell pretty printer";

361 license = stdenv.lib.licenses.bsd3;

362 }) {};

363 "Glob" = callPackage

364 ({ mkDerivation, base, containers, directory, dlist, filepath

365 , transformers

366 }:

367 mkDerivation {

368 pname = "Glob";

369 version = "0.7.5";

370 sha256 = "0hdyi49zp2yr4h4wgngl8ajrss1p309c3pn0alj543yrh33bnqq0";

371 revision = "1";

372 editedCabalFile = "16whzn47hxs8miihs3iplc2dh33z07v44ln7kav2m75g3aprr6r1";

373 configureFlags = [

374 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

375 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

376 "-fsplitbase" "-f-test-hlint"

377 ];

378 libraryHaskellDepends = [

379 base containers directory dlist filepath transformers

380 ];

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

382 description = "Globbing library";

383 license = stdenv.lib.licenses.bsd3;

384 }) {};

385 "HCodecs" = callPackage

386 ({ mkDerivation, array, base, bytestring, QuickCheck, random }:

387 mkDerivation {

388 pname = "HCodecs";

389 version = "0.5";

390 sha256 = "0mhp1alx0p9lzq3vm0k802f8ndm2386sshprn9zb8xq8bsd11gxi";

391 configureFlags = [

392 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

393 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

394 "-fsplitbase" "-f-test-hlint"

395 ];

396 libraryHaskellDepends = [

397 array base bytestring QuickCheck random

398 ];

399 testHaskellDepends = [ array base bytestring QuickCheck random ];

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

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

402 license = stdenv.lib.licenses.bsd3;

403 }) {};

404 "HStringTemplate" = callPackage

405 ({ mkDerivation, array, base, blaze-builder, bytestring, containers

406 , deepseq, directory, filepath, mtl, old-locale, old-time, parsec

407 , pretty, syb, template-haskell, text, time, utf8-string, void

408 }:

409 mkDerivation {

410 pname = "HStringTemplate";

411 version = "0.7.3";

412 sha256 = "1gw4v16nk0878qplcx6by2bl4280lwyn9a252p6ldaqlbk9vygw8";

413 revision = "2";

414 editedCabalFile = "1jsl7wgagccbznasz8swllb2wpa2hd6d7k46s7b0g5f2wnj2xd7k";

415 configureFlags = [

416 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

417 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

418 "-fsplitbase" "-f-test-hlint"

419 ];

420 libraryHaskellDepends = [

421 array base blaze-builder bytestring containers deepseq directory

422 filepath mtl old-locale old-time parsec pretty syb template-haskell

423 text time utf8-string void

424 ];

425 description = "StringTemplate implementation in Haskell";

426 license = stdenv.lib.licenses.bsd3;

427 }) {};

428 "HTF" = callPackage

429 ({ mkDerivation, aeson, aeson-pretty, array, base

430 , base64-bytestring, bytestring, containers, cpphs, Diff, directory

431 , filepath, haskell-lexer, haskell-src, HUnit, lifted-base

432 , monad-control, mtl, old-time, pretty, process, QuickCheck, random

433 , regex-compat, temporary, text, time, unix, unordered-containers

434 , vector, xmlgen

435 }:

436 mkDerivation {

437 pname = "HTF";

438 version = "0.12.2.4";

439 sha256 = "0f538wqihj8i1ys3aciz7n1asxvg73bm9zg0p8qazzx9ghpcgy6m";

440 configureFlags = [

441 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

442 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

443 "-fsplitbase" "-f-test-hlint"

444 ];

445 isLibrary = true;

446 isExecutable = true;

447 libraryHaskellDepends = [

448 aeson array base base64-bytestring bytestring containers cpphs Diff

449 directory haskell-lexer haskell-src HUnit lifted-base monad-control

450 mtl old-time pretty process QuickCheck random regex-compat text

451 time unix vector xmlgen

452 ];

453 executableHaskellDepends = [

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

455 text

456 ];

457 testHaskellDepends = [

458 aeson aeson-pretty base bytestring directory filepath HUnit mtl

459 process random regex-compat temporary text unordered-containers

460 ];

461 doCheck = false;

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

463 description = "The Haskell Test Framework";

464 license = "LGPL";

465 }) {};

466 "HTTP" = callPackage

467 ({ mkDerivation, array, base, bytestring, mtl, network, network-uri

468 , old-time, parsec

469 }:

470 mkDerivation {

471 pname = "HTTP";

472 version = "4000.2.19";

473 sha256 = "1yzm8gimh8g0wwbixcbxg60v4l3vgi63w9v55ms0x9qnm6vrgysz";

474 configureFlags = [

475 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

476 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

477 "-fsplitbase" "-f-test-hlint"

478 ];

479 libraryHaskellDepends = [

480 array base bytestring mtl network network-uri old-time parsec

481 ];

482 doCheck = false;

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

484 description = "A library for client-side HTTP";

485 license = stdenv.lib.licenses.bsd3;

486 }) {};

487 "HUnit" = callPackage

488 ({ mkDerivation, base, deepseq }:

489 mkDerivation {

490 pname = "HUnit";

491 version = "1.2.5.2";

492 sha256 = "0hcs6qh8bqhip1kkjjnw7ccgcsmawdz5yvffjj5y8zd2vcsavx8a";

493 configureFlags = [

494 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

495 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

496 "-fsplitbase" "-f-test-hlint"

497 ];

498 enableSeparateDataOutput = true;

499 libraryHaskellDepends = [ base deepseq ];

500 homepage = "http://hunit.sourceforge.net/";

501 description = "A unit testing framework for Haskell";

502 license = stdenv.lib.licenses.bsd3;

503 }) {};

504 "HaTeX" = callPackage

505 ({ mkDerivation, base, bytestring, containers, matrix, parsec

506 , QuickCheck, tasty, tasty-quickcheck, text, transformers

507 , wl-pprint-extras

508 }:

509 mkDerivation {

510 pname = "HaTeX";

511 version = "3.16.1.1";

512 sha256 = "0xi89wclnkrl17jl3ymvsvg802aj201m4lp0rg9adgmrrdgz042p";

513 configureFlags = [

514 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

515 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

516 "-fsplitbase" "-f-test-hlint"

517 ];

518 libraryHaskellDepends = [

519 base bytestring containers matrix parsec QuickCheck text

520 transformers wl-pprint-extras

521 ];

522 testHaskellDepends = [

523 base QuickCheck tasty tasty-quickcheck text

524 ];

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

526 description = "The Haskell LaTeX library";

527 license = stdenv.lib.licenses.bsd3;

528 }) {};

529 "HaXml" = callPackage

530 ({ mkDerivation, base, bytestring, containers, directory, filepath

531 , polyparse, pretty, random

532 }:

533 mkDerivation {

534 pname = "HaXml";

535 version = "1.25.3";

536 sha256 = "1iq74dnxvannx9x1whqc3ixn93r4v5z7b4yv21n9q5963kpafj34";

537 configureFlags = [

538 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

539 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

540 "-fsplitbase" "-f-test-hlint"

541 ];

542 isLibrary = true;

543 isExecutable = true;

544 libraryHaskellDepends = [

545 base bytestring containers filepath polyparse pretty random

546 ];

547 executableHaskellDepends = [ base directory polyparse pretty ];

548 doHaddock = false;

549 homepage = "http://projects.haskell.org/HaXml/";

550 description = "Utilities for manipulating XML documents";

551 license = "LGPL";

552 }) {};

553 "HandsomeSoup" = callPackage

554 ({ mkDerivation, base, containers, hspec, HTTP, hxt, hxt-http

555 , MaybeT, mtl, network, network-uri, parsec, transformers

556 }:

557 mkDerivation {

558 pname = "HandsomeSoup";

559 version = "0.3.5";

560 sha256 = "1d1zanlr1mdxjc69xvbxg5kn5bc08gd960j6lb1x3grhcgmj9krm";

561 configureFlags = [

562 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

563 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

564 "-fsplitbase" "-f-test-hlint"

565 ];

566 isLibrary = true;

567 isExecutable = true;

568 enableSeparateDataOutput = true;

569 libraryHaskellDepends = [

570 base containers HTTP hxt hxt-http MaybeT mtl network network-uri

571 parsec transformers

572 ];

573 executableHaskellDepends = [ base hxt ];

574 testHaskellDepends = [ base hspec hxt ];

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

576 description = "Work with HTML more easily in HXT";

577 license = stdenv.lib.licenses.bsd3;

578 }) {};

579 "IfElse" = callPackage

580 ({ mkDerivation, base, mtl }:

581 mkDerivation {

582 pname = "IfElse";

583 version = "0.85";

584 sha256 = "1kfx1bwfjczj93a8yqz1n8snqiq5655qgzwv1lrycry8wb1vzlwa";

585 configureFlags = [

586 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

587 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

588 "-fsplitbase" "-f-test-hlint"

589 ];

590 libraryHaskellDepends = [ base mtl ];

591 description = "Anaphoric and miscellaneous useful control-flow";

592 license = stdenv.lib.licenses.bsd3;

593 }) {};

594 "JuicyPixels" = callPackage

595 ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl

596 , primitive, transformers, vector, zlib

597 }:

598 mkDerivation {

599 pname = "JuicyPixels";

600 version = "3.2.3";

601 sha256 = "0nfq6c1kgmw1jj20686bp4rf52vpb8qc3whmz3jh0pwk489b2lwm";

602 revision = "1";

603 editedCabalFile = "0lpfhgc2alzr1i09a62h3dr03lh9g63ngysj3b1p3w24r93pjr5g";

604 configureFlags = [

605 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

606 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

607 "-fsplitbase" "-f-test-hlint"

608 ];

609 libraryHaskellDepends = [

610 base binary bytestring containers deepseq mtl primitive

611 transformers vector zlib

612 ];

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

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

615 license = stdenv.lib.licenses.bsd3;

616 }) {};

617 "JuicyPixels-repa" = callPackage

618 ({ mkDerivation, base, bytestring, JuicyPixels, repa, vector }:

619 mkDerivation {

620 pname = "JuicyPixels-repa";

621 version = "0.7";

622 sha256 = "0fn9i3w8s2ifyg0zsdryyw1nm0c5ybaq0c6jxcggs79x0ngi0mm5";

623 revision = "1";

624 editedCabalFile = "1a4879p2wnb4parg8zax1cwcxrpcpfp349qxf9bn0l0bwvdddp5h";

625 configureFlags = [

626 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

627 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

628 "-fsplitbase" "-f-test-hlint"

629 ];

630 libraryHaskellDepends = [

631 base bytestring JuicyPixels repa vector

632 ];

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

634 license = stdenv.lib.licenses.bsd3;

635 }) {};

636 "MaybeT" = callPackage

637 ({ mkDerivation, base, mtl }:

638 mkDerivation {

639 pname = "MaybeT";

640 version = "0.1.2";

641 sha256 = "0cmnfs22ldai0z172rdsvryzsh33a70yax21v03nhr92a4b62plr";

642 revision = "1";

643 editedCabalFile = "1045p10l7smabidysk52m16sgqgfpa70ny8nwyn56238i02cd7ir";

644 configureFlags = [

645 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

646 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

647 "-fsplitbase" "-f-test-hlint"

648 ];

649 libraryHaskellDepends = [ base mtl ];

650 description = "MaybeT monad transformer";

651 license = stdenv.lib.licenses.bsd3;

652 }) {};

653 "MemoTrie" = callPackage

654 ({ mkDerivation, base, void }:

655 mkDerivation {

656 pname = "MemoTrie";

657 version = "0.6.2";

658 sha256 = "1g4b82s30bqkfids3iywf873nyn8h7l8rp8l3xl58smj5lbi3p4x";

659 revision = "1";

660 editedCabalFile = "0n0k85vvn423nkbjq3q23lzxbam9pvqj9fgby1n8bnp386v4gb2a";

661 configureFlags = [

662 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

663 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

664 "-fsplitbase" "-f-test-hlint"

665 ];

666 libraryHaskellDepends = [ base void ];

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

668 description = "Trie-based memo functions";

669 license = stdenv.lib.licenses.bsd3;

670 }) {};

671 "MissingH" = callPackage

672 ({ mkDerivation, array, base, containers, directory

673 , errorcall-eq-instance, filepath, hslogger, HUnit, mtl, network

674 , old-locale, old-time, parsec, process, QuickCheck, random

675 , regex-compat, testpack, time, unix

676 }:

677 mkDerivation {

678 pname = "MissingH";

679 version = "1.3.0.1";

680 sha256 = "1cwdhgqqv2riqwhsgyrpmqyzvg19lx6zp1g7xdp4rikh7rkn03ds";

681 revision = "1";

682 editedCabalFile = "181ql081aw6j27c2192hb56clsp60gfa0gn4km58qvps3v7gjysx";

683 configureFlags = [

684 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

685 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

686 "-fsplitbase" "-f-test-hlint"

687 ];

688 libraryHaskellDepends = [

689 array base containers directory filepath hslogger HUnit mtl network

690 old-locale old-time parsec process random regex-compat time unix

691 ];

692 testHaskellDepends = [

693 array base containers directory errorcall-eq-instance filepath

694 hslogger HUnit mtl network old-locale old-time parsec process

695 QuickCheck random regex-compat testpack time unix

696 ];

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

698 description = "Large utility library";

699 license = stdenv.lib.licenses.bsd3;

700 }) {};

701 "MonadCatchIO-transformers" = callPackage

702 ({ mkDerivation, base, extensible-exceptions, monads-tf

703 , transformers

704 }:

705 mkDerivation {

706 pname = "MonadCatchIO-transformers";

707 version = "0.3.1.3";

708 sha256 = "1g840h7whsvgyrh4v58mdmsb7hinq785irbz6x9y08r1q8r9r90h";

709 configureFlags = [

710 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

711 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

712 "-fsplitbase" "-f-test-hlint"

713 ];

714 libraryHaskellDepends = [

715 base extensible-exceptions monads-tf transformers

716 ];

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

718 license = stdenv.lib.licenses.bsd3;

719 }) {};

720 "MonadPrompt" = callPackage

721 ({ mkDerivation, base, mtl }:

722 mkDerivation {

723 pname = "MonadPrompt";

724 version = "1.0.0.5";

725 sha256 = "1nmy7dfzrkd8yfv5i9vlmjq9khnyi76ayvkzgcf783v5hfzcn4mh";

726 configureFlags = [

727 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

728 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

729 "-fsplitbase" "-f-test-hlint"

730 ];

731 libraryHaskellDepends = [ base mtl ];

732 description = "MonadPrompt, implementation & examples";

733 license = stdenv.lib.licenses.bsd3;

734 }) {};

735 "MonadRandom" = callPackage

736 ({ mkDerivation, base, mtl, random, transformers }:

737 mkDerivation {

738 pname = "MonadRandom";

739 version = "0.3.0.1";

740 sha256 = "0bbj6rkxskrvl14lngpggql4q41pw21cj4z8h592mizrxjfa3rj0";

741 revision = "2";

742 editedCabalFile = "1cbxcf2igzv8qd7lssczdph1vr3y73mz30mh7g9scjql7g621zji";

743 configureFlags = [

744 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

745 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

746 "-fsplitbase" "-f-test-hlint"

747 ];

748 libraryHaskellDepends = [ base mtl random transformers ];

749 description = "Random-number generation monad";

750 license = "unknown";

751 }) {};

752 "MusicBrainz" = callPackage

753 ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra

754 , HTTP, http-conduit, http-types, monad-control, old-locale

755 , resourcet, text, time, transformers, vector, xml-conduit

756 , xml-types

757 }:

758 mkDerivation {

759 pname = "MusicBrainz";

760 version = "0.2.3";

761 sha256 = "0xwyrjxrff38ijyppfbxsr2nbhg6zd7k0i2avch10dn15xfxapk8";

762 revision = "1";

763 editedCabalFile = "1ja0ms3vf3vnh67sli2hmp7saz0627zd8bc5zwr1vgm31kls6r7k";

764 configureFlags = [

765 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

766 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

767 "-fsplitbase" "-f-test-hlint"

768 ];

769 libraryHaskellDepends = [

770 aeson base bytestring conduit conduit-extra HTTP http-conduit

771 http-types monad-control old-locale resourcet text time

772 transformers vector xml-conduit xml-types

773 ];

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

775 description = "interface to MusicBrainz XML2 web service";

776 license = stdenv.lib.licenses.gpl3;

777 }) {};

778 "NumInstances" = callPackage

779 ({ mkDerivation, base }:

780 mkDerivation {

781 pname = "NumInstances";

782 version = "1.4";

783 sha256 = "0ycnwn09izajv330l7a31mc0alifqmxjsn9qmfswwnbg6i4jmnyb";

784 configureFlags = [

785 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

786 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

787 "-fsplitbase" "-f-test-hlint"

788 ];

789 libraryHaskellDepends = [ base ];

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

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

792 license = stdenv.lib.licenses.bsd3;

793 }) {};

794 "Octree" = callPackage

795 ({ mkDerivation, AC-Vector, base, QuickCheck }:

796 mkDerivation {

797 pname = "Octree";

798 version = "0.5.4.2";

799 sha256 = "0q07jylv5ggvnp32h3b63pk1rcvvxh7bzi3dyx4ga2s0zwfaq1q2";

800 configureFlags = [

801 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

802 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

803 "-fsplitbase" "-f-test-hlint"

804 ];

805 libraryHaskellDepends = [ AC-Vector base QuickCheck ];

806 doCheck = false;

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

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

809 license = stdenv.lib.licenses.bsd3;

810 }) {};

811 "OneTuple" = callPackage

812 ({ mkDerivation, base }:

813 mkDerivation {

814 pname = "OneTuple";

815 version = "0.2.1";

816 sha256 = "1x52b68zh3k9lnps5s87kzan7dzvqp6mrwgayjq15w9dv6v78vsb";

817 configureFlags = [

818 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

819 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

820 "-fsplitbase" "-f-test-hlint"

821 ];

822 libraryHaskellDepends = [ base ];

823 description = "Singleton Tuple";

824 license = stdenv.lib.licenses.bsd3;

825 }) {};

826 "OpenGL" = callPackage

827 ({ mkDerivation, base, bytestring, GLURaw, OpenGLRaw, text }:

828 mkDerivation {

829 pname = "OpenGL";

830 version = "2.9.2.0";

831 sha256 = "1sa5jmhj0az6sik6swv2vgzhv9gj34dbq2px23ag1a4yrk5gcn0p";

832 revision = "3";

833 editedCabalFile = "18bbn7rk82flszhq5kgfn2bhh5cfvxjhwn6q50jfaiprsd0gk85g";

834 configureFlags = [

835 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

836 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

837 "-fsplitbase" "-f-test-hlint"

838 ];

839 libraryHaskellDepends = [ base bytestring GLURaw OpenGLRaw text ];

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

841 description = "A binding for the OpenGL graphics system";

842 license = stdenv.lib.licenses.bsd3;

843 }) {};

844 "OpenGLRaw" = callPackage

845 ({ mkDerivation, base, mesa }:

846 mkDerivation {

847 pname = "OpenGLRaw";

848 version = "1.5.0.1";

849 sha256 = "0hnsmijgvy04d02d0gwk4bl6imhlpwgdcsp1livvca59hzc7r8m3";

850 configureFlags = [

851 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

852 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

853 "-fsplitbase" "-f-test-hlint"

854 ];

855 libraryHaskellDepends = [ base ];

856 librarySystemDepends = [ mesa ];

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

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

859 license = stdenv.lib.licenses.bsd3;

860 }) {inherit (pkgs) mesa;};

861 "QuasiText" = callPackage

862 ({ mkDerivation, attoparsec, base, haskell-src-meta

863 , template-haskell, text

864 }:

865 mkDerivation {

866 pname = "QuasiText";

867 version = "0.1.2.5";

868 sha256 = "10y2lirprxyh9m47qxq0plihc22xvmkhq6lfbx3i19vfvkbhnbwx";

869 configureFlags = [

870 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

871 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

872 "-fsplitbase" "-f-test-hlint"

873 ];

874 libraryHaskellDepends = [

875 attoparsec base haskell-src-meta template-haskell text

876 ];

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

878 description = "A QuasiQuoter for Text";

879 license = stdenv.lib.licenses.bsd3;

880 }) {};

881 "QuickCheck" = callPackage

882 ({ mkDerivation, base, random, template-haskell, test-framework

883 , tf-random, transformers

884 }:

885 mkDerivation {

886 pname = "QuickCheck";

887 version = "2.7.6";

888 sha256 = "09y5l0062l9i5jp9v6811kvkk4zpy0mizwaw44abgz0x1h59gn40";

889 revision = "1";

890 editedCabalFile = "0d9hr7kwpg9akdhzypds22l3wslxnkb2ipns3821c1nailrldzs5";

891 configureFlags = [

892 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

893 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

894 "-fsplitbase" "-f-test-hlint"

895 ];

896 libraryHaskellDepends = [

897 base random template-haskell tf-random transformers

898 ];

899 testHaskellDepends = [ base template-haskell test-framework ];

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

901 description = "Automatic testing of Haskell programs";

902 license = stdenv.lib.licenses.bsd3;

903 }) {};

904 "Rasterific" = callPackage

905 ({ mkDerivation, base, dlist, FontyFruity, free, JuicyPixels, mtl

906 , primitive, vector, vector-algorithms

907 }:

908 mkDerivation {

909 pname = "Rasterific";

910 version = "0.4.2";

911 sha256 = "0lblx6ih8rrvrdfni4x9ldn2r3ikx3xki7qrxg3kbvhdcz56wlq3";

912 configureFlags = [

913 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

914 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

915 "-fsplitbase" "-f-test-hlint"

916 ];

917 libraryHaskellDepends = [

918 base dlist FontyFruity free JuicyPixels mtl primitive vector

919 vector-algorithms

920 ];

921 doCheck = false;

922 description = "A pure haskell drawing engine";

923 license = stdenv.lib.licenses.bsd3;

924 }) {};

925 "ReadArgs" = callPackage

926 ({ mkDerivation, base, system-filepath, text }:

927 mkDerivation {

928 pname = "ReadArgs";

929 version = "1.2.2";

930 sha256 = "1v6yr5zzrrj31prfzxxh1n27sfnkqpkw34v3a47rcnm444ba58a7";

931 configureFlags = [

932 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

933 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

934 "-fsplitbase" "-f-test-hlint"

935 ];

936 isLibrary = true;

937 isExecutable = true;

938 libraryHaskellDepends = [ base system-filepath text ];

939 executableHaskellDepends = [ base system-filepath text ];

940 doCheck = false;

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

942 description = "Simple command line argument parsing";

943 license = stdenv.lib.licenses.bsd3;

944 }) {};

945 "SHA" = callPackage

946 ({ mkDerivation, array, base, binary, bytestring, directory

947 , QuickCheck, test-framework, test-framework-quickcheck2

948 }:

949 mkDerivation {

950 pname = "SHA";

951 version = "1.6.4.2";

952 sha256 = "134ajm87fm4lpsw86m9q8apv20dw4bpk46raa389zr6bcdpifw64";

953 configureFlags = [

954 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

955 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

956 "-fsplitbase" "-f-test-hlint"

957 ];

958 isLibrary = true;

959 isExecutable = true;

960 libraryHaskellDepends = [ array base binary bytestring ];

961 executableHaskellDepends = [ base bytestring directory ];

962 testHaskellDepends = [

963 array base binary bytestring QuickCheck test-framework

964 test-framework-quickcheck2

965 ];

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

967 license = stdenv.lib.licenses.bsd3;

968 }) {};

969 "SVGFonts" = callPackage

970 ({ mkDerivation, attoparsec, base, blaze-markup, blaze-svg

971 , containers, data-default-class, diagrams-lib, directory, parsec

972 , split, text, tuple, vector, vector-space, xml

973 }:

974 mkDerivation {

975 pname = "SVGFonts";

976 version = "1.4.0.3";

977 sha256 = "0jkjcf27xqjzv9lny7j181kcma26wngrq3vzw2sp2hwkdcjryyin";

978 configureFlags = [

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

980 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

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

982 ];

983 enableSeparateDataOutput = true;

984 libraryHaskellDepends = [

985 attoparsec base blaze-markup blaze-svg containers

986 data-default-class diagrams-lib directory parsec split text tuple

987 vector vector-space xml

988 ];

989 description = "Fonts from the SVG-Font format";

990 license = stdenv.lib.licenses.bsd3;

991 }) {};

992 "Spock" = callPackage

993 ({ mkDerivation, aeson, base, base64-bytestring, bytestring

994 , case-insensitive, containers, directory, hashable, hspec

995 , hspec-wai, http-types, monad-control, mtl, old-locale

996 , path-pieces, random, reroute, resource-pool, resourcet, stm, text

997 , time, transformers, transformers-base, unordered-containers

998 , vault, wai, wai-extra, warp

999 }:

1000 mkDerivation {

1001 pname = "Spock";

1002 version = "0.7.7.0";

1003 sha256 = "0jswrqbkqfznbiih603l59rp375nb73kvscjl8jrgw7a5d0qiy8c";

1004 revision = "1";

1005 editedCabalFile = "0zmcdd8yj8v0d0jbr0nckjdwg0mqkgi2ihyifxkcwgcj20dcbx2s";

1006 configureFlags = [

1007 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1008 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1009 "-fsplitbase" "-f-test-hlint"

1010 ];

1011 libraryHaskellDepends = [

1012 aeson base base64-bytestring bytestring case-insensitive containers

1013 directory hashable http-types monad-control mtl old-locale

1014 path-pieces random reroute resource-pool resourcet stm text time

1015 transformers transformers-base unordered-containers vault wai

1016 wai-extra warp

1017 ];

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

1019 benchmarkHaskellDepends = [ base ];

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

1021 description = "Another Haskell web framework for rapid development";

1022 license = stdenv.lib.licenses.bsd3;

1023 }) {};

1024 "Spock-digestive" = callPackage

1025 ({ mkDerivation, base, digestive-functors, http-types, mtl, Spock

1026 , text, unordered-containers, wai

1027 }:

1028 mkDerivation {

1029 pname = "Spock-digestive";

1030 version = "0.1.0.0";

1031 sha256 = "044cw2hfgwa21kjbmby5asfmdjahhadk8iyqk221pixddw7z6s67";

1032 configureFlags = [

1033 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1034 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1035 "-fsplitbase" "-f-test-hlint"

1036 ];

1037 libraryHaskellDepends = [

1038 base digestive-functors http-types mtl Spock text

1039 unordered-containers wai

1040 ];

1041 homepage = "https://github.com/agrafix/Spock-digestive";

1042 description = "Digestive functors support for Spock";

1043 license = stdenv.lib.licenses.mit;

1044 }) {};

1045 "Spock-worker" = callPackage

1046 ({ mkDerivation, base, containers, HTF, lifted-base, mtl, Spock

1047 , stm, text, time, transformers, vector

1048 }:

1049 mkDerivation {

1050 pname = "Spock-worker";

1051 version = "0.2.1.3";

1052 sha256 = "0pxh7ccqb6xpab0807vsfb65lk4bafa44fram1f4d84slggyn1a1";

1053 configureFlags = [

1054 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1055 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1056 "-fsplitbase" "-f-test-hlint"

1057 ];

1058 libraryHaskellDepends = [

1059 base containers lifted-base mtl Spock stm text time transformers

1060 vector

1061 ];

1062 testHaskellDepends = [ base containers HTF stm vector ];

1063 homepage = "http://github.com/agrafix/Spock-worker";

1064 description = "Background workers for Spock";

1065 license = stdenv.lib.licenses.mit;

1066 }) {};

1067 "X11" = callPackage

1068 ({ mkDerivation, base, data-default, libX11, libXext, libXinerama

1069 , libXrandr, libXrender

1070 }:

1071 mkDerivation {

1072 pname = "X11";

1073 version = "1.6.1.2";

1074 sha256 = "1kzjcynm3rr83ihqx2y2d852jc49da4p18gv6jzm7g87z22x85jj";

1075 configureFlags = [

1076 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1077 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1078 "-fsplitbase" "-f-test-hlint"

1079 ];

1080 libraryHaskellDepends = [ base data-default ];

1081 librarySystemDepends = [

1082 libX11 libXext libXinerama libXrandr libXrender

1083 ];

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

1085 description = "A binding to the X11 graphics library";

1086 license = stdenv.lib.licenses.bsd3;

1087 }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXext;

1088 inherit (pkgs.xorg) libXinerama; inherit (pkgs.xorg) libXrandr;

1089 inherit (pkgs.xorg) libXrender;};

1090 "Yampa" = callPackage

1091 ({ mkDerivation, base, random }:

1092 mkDerivation {

1093 pname = "Yampa";

1094 version = "0.9.6";

1095 sha256 = "0a1m0sb0i3kkxbp10vpqd6iw83ksm4alavrg04arzrv71p3skyg0";

1096 revision = "1";

1097 editedCabalFile = "13jvcb1ak0yzq5036x8pymrphl1v7i2sa23kjn2v5gcxig2kvxxc";

1098 configureFlags = [

1099 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1100 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1101 "-fsplitbase" "-f-test-hlint"

1102 ];

1103 libraryHaskellDepends = [ base random ];

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

1105 description = "Library for programming hybrid systems";

1106 license = stdenv.lib.licenses.bsd3;

1107 }) {};

1108 "YampaSynth" = callPackage

1109 ({ mkDerivation, array, base, bytestring, containers, HCodecs

1110 , Yampa

1111 }:

1112 mkDerivation {

1113 pname = "YampaSynth";

1114 version = "0.2";

1115 sha256 = "028a7lrfyikvky52s19kffssnry1grnip3sm7z55bs5fazma1im1";

1116 configureFlags = [

1117 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1118 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1119 "-fsplitbase" "-f-test-hlint"

1120 ];

1121 isLibrary = false;

1122 isExecutable = true;

1123 enableSeparateDataOutput = true;

1124 executableHaskellDepends = [

1125 array base bytestring containers HCodecs Yampa

1126 ];

1127 doHaddock = false;

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

1129 description = "Software synthesizer";

1130 license = stdenv.lib.licenses.bsd3;

1131 }) {};

1132 "abstract-deque" = callPackage

1133 ({ mkDerivation, array, base, containers, random, time }:

1134 mkDerivation {

1135 pname = "abstract-deque";

1136 version = "0.3";

1137 sha256 = "18jwswjxwzc9bjiy4ds6hw2a74ki797jmfcifxd2ga4kh7ri1ah9";

1138 configureFlags = [

1139 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1140 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1141 "-fsplitbase" "-f-test-hlint"

1142 ];

1143 libraryHaskellDepends = [ array base containers random time ];

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

1145 description = "Abstract, parameterized interface to mutable Deques";

1146 license = stdenv.lib.licenses.bsd3;

1147 }) {};

1148 "abstract-par" = callPackage

1149 ({ mkDerivation, base, deepseq }:

1150 mkDerivation {

1151 pname = "abstract-par";

1152 version = "0.3.3";

1153 sha256 = "0q6qsniw4wks2pw6wzncb1p1j3k6al5njnvm2v5n494hplwqg2i4";

1154 configureFlags = [

1155 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1156 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1157 "-fsplitbase" "-f-test-hlint"

1158 ];

1159 libraryHaskellDepends = [ base deepseq ];

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

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

1162 license = stdenv.lib.licenses.bsd3;

1163 }) {};

1164 "accelerate" = callPackage

1165 ({ mkDerivation, array, base, containers, fclabels, ghc-prim

1166 , hashable, hashtables, pretty, template-haskell

1167 , unordered-containers

1168 }:

1169 mkDerivation {

1170 pname = "accelerate";

1171 version = "0.15.0.0";

1172 sha256 = "1hi3zm1swm9fank9w98009pwcgccw6w2j2ilb970sbxyb0xf8nps";

1173 revision = "2";

1174 editedCabalFile = "0k6damdq8kjxlscrc7rbbag0a05q9vjiyx86rda5lnfvgxya9klq";

1175 configureFlags = [

1176 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1177 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1178 "-fsplitbase" "-f-test-hlint"

1179 ];

1180 libraryHaskellDepends = [

1181 array base containers fclabels ghc-prim hashable hashtables pretty

1182 template-haskell unordered-containers

1183 ];

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

1185 description = "An embedded language for accelerated array processing";

1186 license = stdenv.lib.licenses.bsd3;

1187 }) {};

1188 "ace" = callPackage

1189 ({ mkDerivation, attoparsec, base, bifunctors, blaze-html

1190 , blaze-markup, data-default, hspec, HUnit, mtl, parsec, text

1191 }:

1192 mkDerivation {

1193 pname = "ace";

1194 version = "0.6";

1195 sha256 = "0f07j2rj9ylvdrijwwlpx66mj503mhjfq1x2mylpxkr6kmjjniyk";

1196 configureFlags = [

1197 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1198 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1199 "-fsplitbase" "-f-test-hlint"

1200 ];

1201 libraryHaskellDepends = [

1202 attoparsec base blaze-html blaze-markup data-default parsec text

1203 ];

1204 testHaskellDepends = [

1205 base bifunctors hspec HUnit mtl parsec text

1206 ];

1207 description = "Attempto Controlled English parser and printer";

1208 license = stdenv.lib.licenses.bsd3;

1209 }) {};

1210 "action-permutations" = callPackage

1211 ({ mkDerivation, base }:

1212 mkDerivation {

1213 pname = "action-permutations";

1214 version = "0.0.0.1";

1215 sha256 = "0rhlzpwshixpnqma7sk28f22dkwz39b6lcwnzmd31rcnz5cyw6d4";

1216 configureFlags = [

1217 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1218 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1219 "-fsplitbase" "-f-test-hlint"

1220 ];

1221 libraryHaskellDepends = [ base ];

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

1223 license = stdenv.lib.licenses.bsd3;

1224 }) {};

1225 "active" = callPackage

1226 ({ mkDerivation, array, base, newtype, QuickCheck, semigroupoids

1227 , semigroups, vector-space

1228 }:

1229 mkDerivation {

1230 pname = "active";

1231 version = "0.1.0.18";

1232 sha256 = "1q2j7mx8a3mwsb809iyrr2d66bwn4na3y7hmisy6dq8jx4ajfrbk";

1233 configureFlags = [

1234 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1235 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1236 "-fsplitbase" "-f-test-hlint"

1237 ];

1238 libraryHaskellDepends = [

1239 array base newtype semigroupoids semigroups vector-space

1240 ];

1241 testHaskellDepends = [

1242 array base newtype QuickCheck semigroupoids semigroups vector-space

1243 ];

1244 description = "Abstractions for animation";

1245 license = stdenv.lib.licenses.bsd3;

1246 }) {};

1247 "ad" = callPackage

1248 ({ mkDerivation, array, base, comonad, containers, criterion

1249 , data-reify, directory, doctest, erf, filepath, free, nats

1250 , reflection, transformers

1251 }:

1252 mkDerivation {

1253 pname = "ad";

1254 version = "4.2.1.1";

1255 sha256 = "1zdpfh4k93ygrm91m7lw1la6n4yvaq3k2sqswgia04naf2wcmjka";

1256 configureFlags = [

1257 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1258 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1259 "-fsplitbase" "-f-test-hlint"

1260 ];

1261 libraryHaskellDepends = [

1262 array base comonad containers data-reify erf free nats reflection

1263 transformers

1264 ];

1265 testHaskellDepends = [ base directory doctest filepath ];

1266 benchmarkHaskellDepends = [ base criterion erf ];

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

1268 description = "Automatic Differentiation";

1269 license = stdenv.lib.licenses.bsd3;

1270 }) {};

1271 "adjunctions" = callPackage

1272 ({ mkDerivation, array, base, comonad, containers, contravariant

1273 , distributive, free, mtl, profunctors, semigroupoids, semigroups

1274 , tagged, transformers, void

1275 }:

1276 mkDerivation {

1277 pname = "adjunctions";

1278 version = "4.2";

1279 sha256 = "07r56r6kyd6wlcxxnsnnyv59pyc8s1gsy54kzwmk9yknks5rij9i";

1280 configureFlags = [

1281 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1282 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1283 "-fsplitbase" "-f-test-hlint"

1284 ];

1285 libraryHaskellDepends = [

1286 array base comonad containers contravariant distributive free mtl

1287 profunctors semigroupoids semigroups tagged transformers void

1288 ];

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

1290 description = "Adjunctions and representable functors";

1291 license = stdenv.lib.licenses.bsd3;

1292 }) {};

1293 "aeson" = callPackage

1294 ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq

1295 , dlist, ghc-prim, hashable, HUnit, mtl, old-locale, QuickCheck

1296 , scientific, syb, template-haskell, test-framework

1297 , test-framework-hunit, test-framework-quickcheck2, text, time

1298 , unordered-containers, vector

1299 }:

1300 mkDerivation {

1301 pname = "aeson";

1302 version = "0.8.0.2";

1303 sha256 = "1mc8cwmswx69r77wv7dfim525jqajnlxbcx5xf3ygpszzf6mh1q7";

1304 revision = "1";

1305 editedCabalFile = "0g4l7iq24klbmfprj4j31jcskzg0igwq6abp30vi6vlmr9rfcql0";

1306 configureFlags = [

1307 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1308 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1309 "-fsplitbase" "-f-test-hlint"

1310 ];

1311 libraryHaskellDepends = [

1312 attoparsec base bytestring containers deepseq dlist ghc-prim

1313 hashable mtl old-locale scientific syb template-haskell text time

1314 unordered-containers vector

1315 ];

1316 testHaskellDepends = [

1317 attoparsec base bytestring containers ghc-prim HUnit QuickCheck

1318 template-haskell test-framework test-framework-hunit

1319 test-framework-quickcheck2 text time unordered-containers vector

1320 ];

1321 homepage = "https://github.com/bos/aeson";

1322 description = "Fast JSON parsing and encoding";

1323 license = stdenv.lib.licenses.bsd3;

1324 }) {};

1325 "aeson-pretty" = callPackage

1326 ({ mkDerivation, aeson, attoparsec, base, bytestring, cmdargs, text

1327 , unordered-containers, vector

1328 }:

1329 mkDerivation {

1330 pname = "aeson-pretty";

1331 version = "0.7.2";

1332 sha256 = "03ap81853qi8yd9kdgczllrrni23a6glsfxrwj8zab6ipjrbh234";

1333 configureFlags = [

1334 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1335 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1336 "-fsplitbase" "-f-test-hlint"

1337 ];

1338 isLibrary = true;

1339 isExecutable = true;

1340 libraryHaskellDepends = [

1341 aeson base bytestring text unordered-containers vector

1342 ];

1343 executableHaskellDepends = [

1344 aeson attoparsec base bytestring cmdargs

1345 ];

1346 homepage = "http://github.com/informatikr/aeson-pretty";

1347 description = "JSON pretty-printing library and command-line tool";

1348 license = stdenv.lib.licenses.bsd3;

1349 }) {};

1350 "aeson-qq" = callPackage

1351 ({ mkDerivation, aeson, base, ghc-prim, haskell-src-meta, hspec

1352 , parsec, template-haskell, text, vector

1353 }:

1354 mkDerivation {

1355 pname = "aeson-qq";

1356 version = "0.7.4";

1357 sha256 = "0wnc9pdjvd15gfkdxzf084393vwmxv2xaxdchzgal1qhwa1mak4v";

1358 configureFlags = [

1359 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1360 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1361 "-fsplitbase" "-f-test-hlint"

1362 ];

1363 libraryHaskellDepends = [

1364 aeson base haskell-src-meta parsec template-haskell text vector

1365 ];

1366 testHaskellDepends = [

1367 aeson base ghc-prim haskell-src-meta hspec parsec template-haskell

1368 text vector

1369 ];

1370 homepage = "http://github.com/zalora/aeson-qq";

1371 description = "JSON quasiquoter for Haskell";

1372 license = stdenv.lib.licenses.mit;

1373 }) {};

1374 "aeson-utils" = callPackage

1375 ({ mkDerivation, aeson, attoparsec, base, bytestring, scientific

1376 , text

1377 }:

1378 mkDerivation {

1379 pname = "aeson-utils";

1380 version = "0.2.2.1";

1381 sha256 = "0sj4kdcxcj2wnf3s109yxq8gghz976hkiqs19bjcp6qkzdf5w6sd";

1382 revision = "2";

1383 editedCabalFile = "0b9ks5b6y5xajb499903sc684wknrzfx2pygrn3s0s4drwxa01pk";

1384 configureFlags = [

1385 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1386 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1387 "-fsplitbase" "-f-test-hlint"

1388 ];

1389 libraryHaskellDepends = [

1390 aeson attoparsec base bytestring scientific text

1391 ];

1392 description = "Utilities for working with Aeson";

1393 license = stdenv.lib.licenses.bsd3;

1394 }) {};

1395 "alarmclock" = callPackage

1396 ({ mkDerivation, base, stm, time, unbounded-delays }:

1397 mkDerivation {

1398 pname = "alarmclock";

1399 version = "0.2.0.5";

1400 sha256 = "1j0g4xff6i69wx5m45xmx6dsdb5sdl85id967mflnrczgj36d1fd";

1401 configureFlags = [

1402 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1403 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1404 "-fsplitbase" "-f-test-hlint"

1405 ];

1406 libraryHaskellDepends = [ base stm time unbounded-delays ];

1407 testHaskellDepends = [ base time ];

1408 homepage = "https://bitbucket.org/davecturner/alarmclock";

1409 description = "Wake up and perform an action at a certain time";

1410 license = stdenv.lib.licenses.bsd3;

1411 }) {};

1412 "alex" = callPackage

1413 ({ mkDerivation, array, base, containers, directory, happy, perl

1414 , process, QuickCheck

1415 }:

1416 mkDerivation {

1417 pname = "alex";

1418 version = "3.1.4";

1419 sha256 = "17x13nbbr79xgdlzywjqw19vcl6iygjnssjnxnajgijkv764wknn";

1420 configureFlags = [

1421 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1422 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1423 "-fsplitbase" "-f-test-hlint"

1424 ];

1425 isLibrary = false;

1426 isExecutable = true;

1427 executableHaskellDepends = [

1428 array base containers directory QuickCheck

1429 ];

1430 executableToolDepends = [ happy ];

1431 testHaskellDepends = [ base process ];

1432 testToolDepends = [ perl ];

1433 doHaddock = false;

1434 homepage = "http://www.haskell.org/alex/";

1435 description = "Alex is a tool for generating lexical analysers in Haskell";

1436 license = stdenv.lib.licenses.bsd3;

1437 }) {inherit (pkgs) perl;};

1438 "amqp" = callPackage

1439 ({ mkDerivation, base, binary, bytestring, clock, connection

1440 , containers, data-binary-ieee754, hspec, hspec-expectations

1441 , monad-control, network, network-uri, split, text, vector, xml

1442 }:

1443 mkDerivation {

1444 pname = "amqp";

1445 version = "0.10.1";

1446 sha256 = "1a2d17h1zhd2yv1zhd0vvr4g1v6nr188gwv12qwljs1v9y4jkbmc";

1447 configureFlags = [

1448 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1449 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1450 "-fsplitbase" "-f-test-hlint"

1451 ];

1452 isLibrary = true;

1453 isExecutable = true;

1454 libraryHaskellDepends = [

1455 base binary bytestring clock connection containers

1456 data-binary-ieee754 monad-control network network-uri split text

1457 vector

1458 ];

1459 executableHaskellDepends = [ base containers xml ];

1460 testHaskellDepends = [

1461 base binary bytestring clock connection containers

1462 data-binary-ieee754 hspec hspec-expectations network split text

1463 vector

1464 ];

1465 doCheck = false;

1466 homepage = "https://github.com/hreinhardt/amqp";

1467 description = "Client library for AMQP servers (currently only RabbitMQ)";

1468 license = stdenv.lib.licenses.bsd3;

1469 }) {};

1470 "ansi-terminal" = callPackage

1471 ({ mkDerivation, base, unix }:

1472 mkDerivation {

1473 pname = "ansi-terminal";

1474 version = "0.6.2.1";

1475 sha256 = "1xmp8wpcyvqys777qpyfx99bhlnvmr7jil7r78j5n6fx3mkkhnln";

1476 configureFlags = [

1477 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1478 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1479 "-fsplitbase" "-f-test-hlint"

1480 ];

1481 isLibrary = true;

1482 isExecutable = true;

1483 libraryHaskellDepends = [ base unix ];

1484 executableHaskellDepends = [ base unix ];

1485 homepage = "https://github.com/feuerbach/ansi-terminal";

1486 description = "Simple ANSI terminal support, with Windows compatibility";

1487 license = stdenv.lib.licenses.bsd3;

1488 }) {};

1489 "ansi-wl-pprint" = callPackage

1490 ({ mkDerivation, ansi-terminal, base }:

1491 mkDerivation {

1492 pname = "ansi-wl-pprint";

1493 version = "0.6.7.2";

1494 sha256 = "0x0pv7hq4q2n103pzzxghmgzmd3b5cwpnmkdbpzry222890w8ph1";

1495 configureFlags = [

1496 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1497 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1498 "-fsplitbase" "-f-test-hlint"

1499 ];

1500 isLibrary = true;

1501 isExecutable = true;

1502 libraryHaskellDepends = [ ansi-terminal base ];

1503 executableHaskellDepends = [ ansi-terminal base ];

1504 homepage = "http://github.com/batterseapower/ansi-wl-pprint";

1505 description = "The Wadler/Leijen Pretty Printer for colored ANSI terminal output";

1506 license = stdenv.lib.licenses.bsd3;

1507 }) {};

1508 "appar" = callPackage

1509 ({ mkDerivation, base, bytestring }:

1510 mkDerivation {

1511 pname = "appar";

1512 version = "0.1.4";

1513 sha256 = "09jb9ij78fdkz2qk66rw99q19qnm504dpv0yq0pjsl6xwjmndsjq";

1514 configureFlags = [

1515 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1516 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1517 "-fsplitbase" "-f-test-hlint"

1518 ];

1519 libraryHaskellDepends = [ base bytestring ];

1520 description = "A simple applicative parser";

1521 license = stdenv.lib.licenses.bsd3;

1522 }) {};

1523 "approximate" = callPackage

1524 ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq

1525 , directory, distributive, doctest, filepath, generic-deriving

1526 , ghc-prim, hashable, hashable-extras, lens, log-domain, pointed

1527 , safecopy, semigroupoids, semigroups, simple-reflect, vector

1528 }:

1529 mkDerivation {

1530 pname = "approximate";

1531 version = "0.2.1.1";

1532 sha256 = "18ac2z1yqqksqmq9ch36ja3qjn9v6cgyzxs64lnnp98mgcwsmhwr";

1533 configureFlags = [

1534 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1535 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1536 "-fsplitbase" "-f-test-hlint"

1537 ];

1538 libraryHaskellDepends = [

1539 base binary bytes cereal comonad deepseq distributive

1540 generic-deriving ghc-prim hashable hashable-extras lens log-domain

1541 pointed safecopy semigroupoids semigroups vector

1542 ];

1543 testHaskellDepends = [

1544 base directory doctest filepath generic-deriving semigroups

1545 simple-reflect

1546 ];

1547 homepage = "http://github.com/analytics/approximate/";

1548 description = "Approximate discrete values and numbers";

1549 license = stdenv.lib.licenses.bsd3;

1550 }) {};

1551 "arbtt" = callPackage

1552 ({ mkDerivation, aeson, array, base, binary, bytestring

1553 , bytestring-progress, containers, deepseq, directory, filepath

1554 , HUnit, libXScrnSaver, old-locale, parsec, pcre-light

1555 , process-extras, strict, tasty, tasty-golden, tasty-hunit

1556 , terminal-progress-bar, time, transformers, unix, utf8-string, X11

1557 }:

1558 mkDerivation {

1559 pname = "arbtt";

1560 version = "0.8.1.4";

1561 sha256 = "15ydb425nvqfzajx09q713wy5xa7awbzfjlsidk17vf7qbhfjn7z";

1562 configureFlags = [

1563 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1564 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1565 "-fsplitbase" "-f-test-hlint"

1566 ];

1567 isLibrary = false;

1568 isExecutable = true;

1569 executableHaskellDepends = [

1570 aeson array base binary bytestring bytestring-progress containers

1571 deepseq directory filepath old-locale parsec pcre-light strict

1572 terminal-progress-bar time transformers unix utf8-string X11

1573 ];

1574 executableSystemDepends = [ libXScrnSaver ];

1575 testHaskellDepends = [

1576 base binary bytestring containers deepseq directory HUnit

1577 old-locale parsec pcre-light process-extras tasty tasty-golden

1578 tasty-hunit time transformers unix utf8-string

1579 ];

1580 doHaddock = false;

1581 homepage = "http://arbtt.nomeata.de/";

1582 description = "Automatic Rule-Based Time Tracker";

1583 license = "GPL";

1584 }) {inherit (pkgs.xorg) libXScrnSaver;};

1585 "arithmoi" = callPackage

1586 ({ mkDerivation, array, base, containers, ghc-prim, integer-gmp

1587 , mtl, random

1588 }:

1589 mkDerivation {

1590 pname = "arithmoi";

1591 version = "0.4.1.2";

1592 sha256 = "0i0cndldf426cc8dv6swqfnljv9lgba9vp1ac4xk0vdbmbwqan9m";

1593 configureFlags = [

1594 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1595 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1596 "-fsplitbase" "-f-test-hlint"

1597 ];

1598 libraryHaskellDepends = [

1599 array base containers ghc-prim integer-gmp mtl random

1600 ];

1601 homepage = "https://github.com/cartazio/arithmoi";

1602 description = "Efficient basic number-theoretic functions. Primes, powers, integer logarithms.";

1603 license = stdenv.lib.licenses.mit;

1604 }) {};

1605 "arrow-list" = callPackage

1606 ({ mkDerivation, base, containers, mtl }:

1607 mkDerivation {

1608 pname = "arrow-list";

1609 version = "0.6.1.5";

1610 sha256 = "0i0rwjrrvbi9fmwdzmz6vzkkr63pl2df653anjwcw3xr7ccb16xm";

1611 configureFlags = [

1612 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1613 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1614 "-fsplitbase" "-f-test-hlint"

1615 ];

1616 libraryHaskellDepends = [ base containers mtl ];

1617 homepage = "https://github.com/silkapp/arrow-list";

1618 description = "List arrows for Haskell";

1619 license = stdenv.lib.licenses.bsd3;

1620 }) {};

1621 "asn1-data" = callPackage

1622 ({ mkDerivation, base, bytestring, cereal, mtl, text }:

1623 mkDerivation {

1624 pname = "asn1-data";

1625 version = "0.7.1";

1626 sha256 = "10s7mxygw6w8a8mx090msvbl8pji8m68lsxxyr5bp7p887naia7r";

1627 revision = "1";

1628 editedCabalFile = "07zdlmgf5yp7sv4gpvadplr86rfw14mzmdg95h7ymfc8d83h33vc";

1629 configureFlags = [

1630 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1631 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1632 "-fsplitbase" "-f-test-hlint"

1633 ];

1634 isLibrary = true;

1635 isExecutable = true;

1636 enableSeparateDataOutput = true;

1637 libraryHaskellDepends = [ base bytestring cereal mtl text ];

1638 homepage = "http://github.com/vincenthz/hs-asn1-data";

1639 description = "ASN1 data reader and writer in RAW, BER and DER forms";

1640 license = stdenv.lib.licenses.bsd3;

1641 }) {};

1642 "asn1-encoding" = callPackage

1643 ({ mkDerivation, asn1-types, base, bytestring, hourglass, mtl

1644 , tasty, tasty-quickcheck, text

1645 }:

1646 mkDerivation {

1647 pname = "asn1-encoding";

1648 version = "0.9.0";

1649 sha256 = "02x3lzyl4gavl3lc2lrg8rknyvs6r2hf8kmm7xrmma5m857iks8p";

1650 configureFlags = [

1651 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1652 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1653 "-fsplitbase" "-f-test-hlint"

1654 ];

1655 libraryHaskellDepends = [

1656 asn1-types base bytestring hourglass mtl

1657 ];

1658 testHaskellDepends = [

1659 asn1-types base bytestring hourglass mtl tasty tasty-quickcheck

1660 text

1661 ];

1662 homepage = "http://github.com/vincenthz/hs-asn1";

1663 description = "ASN1 data reader and writer in RAW, BER and DER forms";

1664 license = stdenv.lib.licenses.bsd3;

1665 }) {};

1666 "asn1-parse" = callPackage

1667 ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring, mtl

1668 , text

1669 }:

1670 mkDerivation {

1671 pname = "asn1-parse";

1672 version = "0.9.0";

1673 sha256 = "0m093wwndyxvy72qlnb70bp8w5ahimrlv1dp972l9s9l5jc4pjg3";

1674 revision = "1";

1675 editedCabalFile = "134wf7szi4zg88wvi4awhkndbzawgprz3059jxpp4jhmd0hxs97n";

1676 configureFlags = [

1677 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1678 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1679 "-fsplitbase" "-f-test-hlint"

1680 ];

1681 libraryHaskellDepends = [

1682 asn1-encoding asn1-types base bytestring mtl text

1683 ];

1684 homepage = "http://github.com/vincenthz/hs-asn1";

1685 description = "Simple monadic parser for ASN1 stream types";

1686 license = stdenv.lib.licenses.bsd3;

1687 }) {};

1688 "asn1-types" = callPackage

1689 ({ mkDerivation, base, bytestring, hourglass }:

1690 mkDerivation {

1691 pname = "asn1-types";

1692 version = "0.3.0";

1693 sha256 = "1am8nmfarv7ymy3rqm0js2i82v6n6qwz0lnzb1qdmy4ligcdm65r";

1694 configureFlags = [

1695 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1696 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1697 "-fsplitbase" "-f-test-hlint"

1698 ];

1699 libraryHaskellDepends = [ base bytestring hourglass ];

1700 homepage = "http://github.com/vincenthz/hs-asn1-types";

1701 description = "ASN.1 types";

1702 license = stdenv.lib.licenses.bsd3;

1703 }) {};

1704 "async" = callPackage

1705 ({ mkDerivation, base, HUnit, stm, test-framework

1706 , test-framework-hunit

1707 }:

1708 mkDerivation {

1709 pname = "async";

1710 version = "2.0.2";

1711 sha256 = "0azx4qk65a9a2gvqsfmz3w89m6shzr2iz0i5lly2zvly4n2d6m6v";

1712 configureFlags = [

1713 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1714 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1715 "-fsplitbase" "-f-test-hlint"

1716 ];

1717 libraryHaskellDepends = [ base stm ];

1718 testHaskellDepends = [

1719 base HUnit test-framework test-framework-hunit

1720 ];

1721 homepage = "https://github.com/simonmar/async";

1722 description = "Run IO operations asynchronously and wait for their results";

1723 license = stdenv.lib.licenses.bsd3;

1724 }) {};

1725 "atto-lisp" = callPackage

1726 ({ mkDerivation, attoparsec, base, blaze-builder, blaze-textual

1727 , bytestring, containers, deepseq, HUnit, test-framework

1728 , test-framework-hunit, text

1729 }:

1730 mkDerivation {

1731 pname = "atto-lisp";

1732 version = "0.2.2";

1733 sha256 = "13lhdalam4gn9faa58c3c7nssdwp2y0jsfl1lnnvr3dx6wzp0jhc";

1734 revision = "1";

1735 editedCabalFile = "1ypjd6cknbr8dfrgfs9wv0amv2s28ibgxlvyfsnann4wv19rgczy";

1736 configureFlags = [

1737 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1738 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1739 "-fsplitbase" "-f-test-hlint"

1740 ];

1741 libraryHaskellDepends = [

1742 attoparsec base blaze-builder blaze-textual bytestring containers

1743 deepseq text

1744 ];

1745 testHaskellDepends = [

1746 attoparsec base bytestring HUnit test-framework

1747 test-framework-hunit text

1748 ];

1749 homepage = "http://github.com/nominolo/atto-lisp";

1750 description = "Efficient parsing and serialisation of S-Expressions";

1751 license = stdenv.lib.licenses.bsd3;

1752 }) {};

1753 "attoparsec" = callPackage

1754 ({ mkDerivation, array, base, bytestring, case-insensitive

1755 , containers, criterion, deepseq, directory, filepath, ghc-prim

1756 , http-types, parsec, QuickCheck, quickcheck-unicode, scientific

1757 , test-framework, test-framework-quickcheck2, text

1758 , unordered-containers, vector

1759 }:

1760 mkDerivation {

1761 pname = "attoparsec";

1762 version = "0.12.1.5";

1763 sha256 = "131l2qax0qnc157r9llp3lbwy7390g8r3ckzvdqbif6lfy0zg2rq";

1764 configureFlags = [

1765 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1766 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1767 "-fsplitbase" "-f-test-hlint"

1768 ];

1769 libraryHaskellDepends = [

1770 array base bytestring containers deepseq scientific text

1771 ];

1772 testHaskellDepends = [

1773 array base bytestring deepseq QuickCheck quickcheck-unicode

1774 scientific test-framework test-framework-quickcheck2 text vector

1775 ];

1776 benchmarkHaskellDepends = [

1777 array base bytestring case-insensitive criterion deepseq directory

1778 filepath ghc-prim http-types parsec scientific text

1779 unordered-containers vector

1780 ];

1781 homepage = "https://github.com/bos/attoparsec";

1782 description = "Fast combinator parsing for bytestrings and text";

1783 license = stdenv.lib.licenses.bsd3;

1784 }) {};

1785 "attoparsec-conduit" = callPackage

1786 ({ mkDerivation, base, conduit }:

1787 mkDerivation {

1788 pname = "attoparsec-conduit";

1789 version = "1.1.0";

1790 sha256 = "18xn3nzxfghcd88cana1jw85ijv0ysw3bp36fb6r5wsf6m79z01y";

1791 configureFlags = [

1792 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1793 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1794 "-fsplitbase" "-f-test-hlint"

1795 ];

1796 libraryHaskellDepends = [ base conduit ];

1797 doHaddock = false;

1798 homepage = "http://github.com/snoyberg/conduit";

1799 description = "Consume attoparsec parsers via conduit. (deprecated)";

1800 license = stdenv.lib.licenses.mit;

1801 }) {};

1802 "attoparsec-enumerator" = callPackage

1803 ({ mkDerivation, attoparsec, base, bytestring, enumerator, text }:

1804 mkDerivation {

1805 pname = "attoparsec-enumerator";

1806 version = "0.3.3";

1807 sha256 = "0z57bbw97v92dkjp57zj9nfzsdas2n1qfw472k1aa84iqb6hbw9w";

1808 configureFlags = [

1809 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1810 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1811 "-fsplitbase" "-f-test-hlint"

1812 ];

1813 libraryHaskellDepends = [

1814 attoparsec base bytestring enumerator text

1815 ];

1816 homepage = "https://john-millikin.com/software/attoparsec-enumerator/";

1817 description = "Pass input from an enumerator to an Attoparsec parser";

1818 license = stdenv.lib.licenses.mit;

1819 }) {};

1820 "attoparsec-expr" = callPackage

1821 ({ mkDerivation, attoparsec, base }:

1822 mkDerivation {

1823 pname = "attoparsec-expr";

1824 version = "0.1.1.1";

1825 sha256 = "09305lp9q3cgvpv4d878c34dk07g7p13hc07hrp2xlwl7rc3nac3";

1826 configureFlags = [

1827 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1828 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1829 "-fsplitbase" "-f-test-hlint"

1830 ];

1831 libraryHaskellDepends = [ attoparsec base ];

1832 description = "Port of parsec's expression parser to attoparsec";

1833 license = stdenv.lib.licenses.bsd3;

1834 }) {};

1835 "authenticate" = callPackage

1836 ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring

1837 , case-insensitive, conduit, containers, http-conduit, http-types

1838 , monad-control, network-uri, resourcet, tagstream-conduit, text

1839 , transformers, unordered-containers, xml-conduit

1840 }:

1841 mkDerivation {

1842 pname = "authenticate";

1843 version = "1.3.2.11";

1844 sha256 = "1xkzaw9a338yclbm10cfa9cnjdjpmzif2qj4hprig45z5szqi4q4";

1845 configureFlags = [

1846 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1847 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1848 "-fsplitbase" "-f-test-hlint"

1849 ];

1850 libraryHaskellDepends = [

1851 aeson attoparsec base blaze-builder bytestring case-insensitive

1852 conduit containers http-conduit http-types monad-control

1853 network-uri resourcet tagstream-conduit text transformers

1854 unordered-containers xml-conduit

1855 ];

1856 homepage = "http://github.com/yesodweb/authenticate";

1857 description = "Authentication methods for Haskell web applications";

1858 license = stdenv.lib.licenses.bsd3;

1859 }) {};

1860 "auto-update" = callPackage

1861 ({ mkDerivation, base }:

1862 mkDerivation {

1863 pname = "auto-update";

1864 version = "0.1.2.1";

1865 sha256 = "0cj1pjf22x02h3d1ln1p69g90kz2dfsiq04ahfq29jj4ny525lwp";

1866 configureFlags = [

1867 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1868 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1869 "-fsplitbase" "-f-test-hlint"

1870 ];

1871 libraryHaskellDepends = [ base ];

1872 homepage = "https://github.com/yesodweb/wai";

1873 description = "Efficiently run periodic, on-demand actions";

1874 license = stdenv.lib.licenses.mit;

1875 }) {};

1876 "aws" = callPackage

1877 ({ mkDerivation, aeson, attoparsec, base, base16-bytestring

1878 , base64-bytestring, blaze-builder, byteable, bytestring

1879 , case-insensitive, cereal, conduit, conduit-extra, containers

1880 , cryptohash, data-default, directory, errors, filepath

1881 , http-client, http-conduit, http-types, lifted-base, monad-control

1882 , mtl, network, old-locale, QuickCheck, quickcheck-instances

1883 , resourcet, safe, scientific, tagged, tasty, tasty-quickcheck

1884 , text, time, transformers, transformers-base, unordered-containers

1885 , utf8-string, vector, xml-conduit

1886 }:

1887 mkDerivation {

1888 pname = "aws";

1889 version = "0.11.3";

1890 sha256 = "02p3dn380qj8wg6alm7yqw4svwwkw9ln9rjd6shbk4jz8gsaka8l";

1891 revision = "2";

1892 editedCabalFile = "1xmwsq3b9j7bqn182wb777a0k1zzmxrjsyyjpxarxh01wh6d1qvk";

1893 configureFlags = [

1894 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1895 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1896 "-fsplitbase" "-f-test-hlint"

1897 ];

1898 isLibrary = true;

1899 isExecutable = true;

1900 libraryHaskellDepends = [

1901 aeson attoparsec base base16-bytestring base64-bytestring

1902 blaze-builder byteable bytestring case-insensitive cereal conduit

1903 conduit-extra containers cryptohash data-default directory filepath

1904 http-conduit http-types lifted-base monad-control mtl network

1905 old-locale resourcet safe scientific tagged text time transformers

1906 unordered-containers utf8-string vector xml-conduit

1907 ];

1908 testHaskellDepends = [

1909 aeson base bytestring errors http-client lifted-base monad-control

1910 mtl QuickCheck quickcheck-instances resourcet tagged tasty

1911 tasty-quickcheck text time transformers transformers-base

1912 ];

1913 doCheck = false;

1914 homepage = "http://github.com/aristidb/aws";

1915 description = "Amazon Web Services (AWS) for Haskell";

1916 license = stdenv.lib.licenses.bsd3;

1917 }) {};

1918 "bake" = callPackage

1919 ({ mkDerivation, aeson, base, bytestring, cmdargs, deepseq

1920 , directory, extra, filepath, hashable, HTTP, http-types, process

1921 , random, shake, text, time, wai, warp

1922 }:

1923 mkDerivation {

1924 pname = "bake";

1925 version = "0.2";

1926 sha256 = "1j7m9q5vk35sqs6if9rzb72avi7xbjhbcv0hpg9qvn9nvs38dgiw";

1927 configureFlags = [

1928 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1929 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1930 "-fsplitbase" "-f-test-hlint"

1931 ];

1932 isLibrary = true;

1933 isExecutable = true;

1934 enableSeparateDataOutput = true;

1935 libraryHaskellDepends = [

1936 aeson base bytestring cmdargs deepseq directory extra filepath

1937 hashable HTTP http-types random shake text time wai warp

1938 ];

1939 executableHaskellDepends = [

1940 aeson base bytestring cmdargs deepseq directory extra filepath

1941 hashable HTTP http-types process random shake text time wai warp

1942 ];

1943 homepage = "https://github.com/ndmitchell/bake#readme";

1944 description = "Continuous integration system";

1945 license = stdenv.lib.licenses.bsd3;

1946 }) {};

1947 "bank-holidays-england" = callPackage

1948 ({ mkDerivation, base, containers, hspec, QuickCheck, time }:

1949 mkDerivation {

1950 pname = "bank-holidays-england";

1951 version = "0.1.0.2";

1952 sha256 = "0kjn5f76w9ff73blg8apxkhfsk1clv2i52gr4frgqn7l6f32yp22";

1953 configureFlags = [

1954 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1955 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1956 "-fsplitbase" "-f-test-hlint"

1957 ];

1958 libraryHaskellDepends = [ base containers time ];

1959 testHaskellDepends = [ base containers hspec QuickCheck time ];

1960 homepage = "https://bitbucket.org/davecturner/bank-holidays-england";

1961 description = "Calculation of bank holidays in England and Wales";

1962 license = stdenv.lib.licenses.bsd3;

1963 }) {};

1964 "barecheck" = callPackage

1965 ({ mkDerivation, base, containers, QuickCheck, text, time }:

1966 mkDerivation {

1967 pname = "barecheck";

1968 version = "0.2.0.8";

1969 sha256 = "0hja4lrgv1faqaq41wzf1r88aw4pin8jh60k9n65yd0sxi1103a7";

1970 configureFlags = [

1971 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1972 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1973 "-fsplitbase" "-f-test-hlint"

1974 ];

1975 libraryHaskellDepends = [ base containers QuickCheck text time ];

1976 homepage = "http://github.com/massysett/barecheck";

1977 description = "QuickCheck implementations for common types";

1978 license = stdenv.lib.licenses.bsd3;

1979 }) {};

1980 "base-compat" = callPackage

1981 ({ mkDerivation, base, errorcall-eq-instance, hspec, QuickCheck

1982 , setenv

1983 }:

1984 mkDerivation {

1985 pname = "base-compat";

1986 version = "0.5.0";

1987 sha256 = "1zlpfpfnaqf8rrha19arh882bc560dcw2zwi4j3qrn3lzyh8s1d1";

1988 revision = "1";

1989 editedCabalFile = "04s7a4v2z8bjxlrynbx12xbmj3yraalppp7k6ad019zspzmf0bzy";

1990 configureFlags = [

1991 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

1992 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

1993 "-fsplitbase" "-f-test-hlint"

1994 ];

1995 libraryHaskellDepends = [ base errorcall-eq-instance setenv ];

1996 testHaskellDepends = [ base hspec QuickCheck ];

1997 description = "A compatibility layer for base";

1998 license = stdenv.lib.licenses.mit;

1999 }) {};

2000 "base-prelude" = callPackage

2001 ({ mkDerivation, base }:

2002 mkDerivation {

2003 pname = "base-prelude";

2004 version = "0.1.17";

2005 sha256 = "0ddhnbfiaszqgdbr9j5xkz724llfrv2dr3wf0470amssf91d67dq";

2006 configureFlags = [

2007 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2008 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2009 "-fsplitbase" "-f-test-hlint"

2010 ];

2011 libraryHaskellDepends = [ base ];

2012 doCheck = false;

2013 homepage = "https://github.com/nikita-volkov/base-prelude";

2014 description = "The most complete prelude formed from only the \"base\" package";

2015 license = stdenv.lib.licenses.mit;

2016 }) {};

2017 "base-unicode-symbols" = callPackage

2018 ({ mkDerivation, base }:

2019 mkDerivation {

2020 pname = "base-unicode-symbols";

2021 version = "0.2.2.4";

2022 sha256 = "1afc5pchd3vw33bmjbjygkd0l5zh7glbsx4bfyxfscpc1x1l3y52";

2023 configureFlags = [

2024 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2025 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2026 "-fsplitbase" "-f-test-hlint"

2027 ];

2028 libraryHaskellDepends = [ base ];

2029 homepage = "http://haskell.org/haskellwiki/Unicode-symbols";

2030 description = "Unicode alternatives for common functions and operators";

2031 license = stdenv.lib.licenses.bsd3;

2032 }) {};

2033 "base16-bytestring" = callPackage

2034 ({ mkDerivation, base, bytestring, ghc-prim }:

2035 mkDerivation {

2036 pname = "base16-bytestring";

2037 version = "0.1.1.6";

2038 sha256 = "0jf40m3yijqw6wd1rwwvviww46fasphaay9m9rgqyhf5aahnbzjs";

2039 configureFlags = [

2040 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2041 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2042 "-fsplitbase" "-f-test-hlint"

2043 ];

2044 libraryHaskellDepends = [ base bytestring ghc-prim ];

2045 homepage = "http://github.com/bos/base16-bytestring";

2046 description = "Fast base16 (hex) encoding and decoding for ByteStrings";

2047 license = stdenv.lib.licenses.bsd3;

2048 }) {};

2049 "base64-bytestring" = callPackage

2050 ({ mkDerivation, base, bytestring, containers, HUnit, QuickCheck

2051 , test-framework, test-framework-hunit, test-framework-quickcheck2

2052 }:

2053 mkDerivation {

2054 pname = "base64-bytestring";

2055 version = "1.0.0.1";

2056 sha256 = "0l1v4ddjdsgi9nqzyzcxxj76rwar3lzx8gmwf2r54bqan3san9db";

2057 configureFlags = [

2058 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2059 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2060 "-fsplitbase" "-f-test-hlint"

2061 ];

2062 libraryHaskellDepends = [ base bytestring ];

2063 testHaskellDepends = [

2064 base bytestring containers HUnit QuickCheck test-framework

2065 test-framework-hunit test-framework-quickcheck2

2066 ];

2067 homepage = "https://github.com/bos/base64-bytestring";

2068 description = "Fast base64 encoding and decoding for ByteStrings";

2069 license = stdenv.lib.licenses.bsd3;

2070 }) {};

2071 "basic-prelude" = callPackage

2072 ({ mkDerivation, base, bytestring, containers, hashable

2073 , lifted-base, ReadArgs, safe, system-filepath, text, transformers

2074 , unordered-containers, vector

2075 }:

2076 mkDerivation {

2077 pname = "basic-prelude";

2078 version = "0.3.11.1";

2079 sha256 = "057sq6jm8vskw9d9maqc6a85x45lslyiw3j1q7kaczl3851zaxl3";

2080 configureFlags = [

2081 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2082 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2083 "-fsplitbase" "-f-test-hlint"

2084 ];

2085 libraryHaskellDepends = [

2086 base bytestring containers hashable lifted-base ReadArgs safe

2087 system-filepath text transformers unordered-containers vector

2088 ];

2089 homepage = "https://github.com/snoyberg/basic-prelude";

2090 description = "An enhanced core prelude; a common foundation for alternate preludes";

2091 license = stdenv.lib.licenses.mit;

2092 }) {};

2093 "bifunctors" = callPackage

2094 ({ mkDerivation, base, semigroupoids, semigroups, tagged }:

2095 mkDerivation {

2096 pname = "bifunctors";

2097 version = "4.2.1";

2098 sha256 = "0zy4lz08r60h8lgrf67zqqrcslrnbmdi254ydv5mw69z57nnx3ng";

2099 revision = "2";

2100 editedCabalFile = "0kbfz317qax7si4wxnkxdp58b3w880aflwgjx6kcvg32p5wcjpbd";

2101 configureFlags = [

2102 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2103 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2104 "-fsplitbase" "-f-test-hlint"

2105 ];

2106 libraryHaskellDepends = [ base semigroupoids semigroups tagged ];

2107 homepage = "http://github.com/ekmett/bifunctors/";

2108 description = "Bifunctors";

2109 license = stdenv.lib.licenses.bsd3;

2110 }) {};

2111 "binary-conduit" = callPackage

2112 ({ mkDerivation, base, binary, bytestring, conduit, hspec

2113 , QuickCheck, quickcheck-assertions, resourcet, vector

2114 }:

2115 mkDerivation {

2116 pname = "binary-conduit";

2117 version = "1.2.3";

2118 sha256 = "0ymhxyf754j1pki7ap2vay8f9j49rzsjzp5yr253sn5wpw3qg8fr";

2119 revision = "2";

2120 editedCabalFile = "0agymrfvf7vvnqgn7xi0zsj4yglr9yjp5iwszv6988y6vfwkk228";

2121 configureFlags = [

2122 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2123 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2124 "-fsplitbase" "-f-test-hlint"

2125 ];

2126 libraryHaskellDepends = [

2127 base binary bytestring conduit resourcet vector

2128 ];

2129 testHaskellDepends = [

2130 base binary bytestring conduit hspec QuickCheck

2131 quickcheck-assertions resourcet

2132 ];

2133 homepage = "http://github.com/qnikst/binary-conduit/";

2134 description = "data serialization/deserialization conduit library";

2135 license = stdenv.lib.licenses.mit;

2136 }) {};

2137 "binary-list" = callPackage

2138 ({ mkDerivation, base, binary, bytestring, criterion, deepseq

2139 , phantom-state, transformers

2140 }:

2141 mkDerivation {

2142 pname = "binary-list";

2143 version = "1.0.1.0";

2144 sha256 = "1d83ka79nnq5pw4djs6x3ccgygkq89q9wakgykx4wvyf7l0xj7d9";

2145 configureFlags = [

2146 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2147 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2148 "-fsplitbase" "-f-test-hlint"

2149 ];

2150 libraryHaskellDepends = [

2151 base binary bytestring deepseq phantom-state transformers

2152 ];

2153 benchmarkHaskellDepends = [ base criterion ];

2154 description = "Lists of length a power of two";

2155 license = stdenv.lib.licenses.bsd3;

2156 }) {};

2157 "bindings-DSL" = callPackage

2158 ({ mkDerivation, base }:

2159 mkDerivation {

2160 pname = "bindings-DSL";

2161 version = "1.0.22";

2162 sha256 = "0xkr1x3klpfwbh1yimah1dqmqcilifyblnf3kr6ay4gsvw74zkwr";

2163 configureFlags = [

2164 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2165 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2166 "-fsplitbase" "-f-test-hlint"

2167 ];

2168 libraryHaskellDepends = [ base ];

2169 homepage = "https://github.com/jwiegley/bindings-dsl/wiki";

2170 description = "FFI domain specific language, on top of hsc2hs";

2171 license = stdenv.lib.licenses.bsd3;

2172 }) {};

2173 "bioace" = callPackage

2174 ({ mkDerivation, base, bioalign, biocore, bytestring, parsec }:

2175 mkDerivation {

2176 pname = "bioace";

2177 version = "0.0.1";

2178 sha256 = "08k2w66gpysjk038pi50lc21gbn2dyp5z8ls0qhcmjqc59dn8hvg";

2179 configureFlags = [

2180 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2181 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2182 "-fsplitbase" "-f-test-hlint"

2183 ];

2184 libraryHaskellDepends = [

2185 base bioalign biocore bytestring parsec

2186 ];

2187 homepage = "https://patch-tag.com/r/dfornika/bioace/home";

2188 description = "Library for reading ace assembly files";

2189 license = "GPL";

2190 }) {};

2191 "bioalign" = callPackage

2192 ({ mkDerivation, base, biocore, bytestring }:

2193 mkDerivation {

2194 pname = "bioalign";

2195 version = "0.0.5";

2196 sha256 = "006gg8ds6klrl9rc1csi247rf8gzlgn9mdi0jl4pjz5xmf0jw5dr";

2197 configureFlags = [

2198 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2199 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2200 "-fsplitbase" "-f-test-hlint"

2201 ];

2202 libraryHaskellDepends = [ base biocore bytestring ];

2203 homepage = "https://patch-tag.com/r/dfornika/biophd/home";

2204 description = "Data structures and helper functions for calculating alignments";

2205 license = "GPL";

2206 }) {};

2207 "biocore" = callPackage

2208 ({ mkDerivation, base, bytestring, stringable }:

2209 mkDerivation {

2210 pname = "biocore";

2211 version = "0.3.1";

2212 sha256 = "06ml9p144bv0c9hv6pkcvhdgc0vw0jxzbqb834ilr38kjmrpsar1";

2213 configureFlags = [

2214 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2215 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2216 "-fsplitbase" "-f-test-hlint"

2217 ];

2218 libraryHaskellDepends = [ base bytestring stringable ];

2219 description = "A bioinformatics library";

2220 license = "LGPL";

2221 }) {};

2222 "biofasta" = callPackage

2223 ({ mkDerivation, base, biocore, bytestring }:

2224 mkDerivation {

2225 pname = "biofasta";

2226 version = "0.0.3";

2227 sha256 = "1l770sg2gcg7wl5yfrrk9nr7hgd5m0q158ad5nd8z7i5vsfah8b2";

2228 configureFlags = [

2229 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2230 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2231 "-fsplitbase" "-f-test-hlint"

2232 ];

2233 libraryHaskellDepends = [ base biocore bytestring ];

2234 homepage = "https://patch-tag.com/r/dfornika/biofasta/home";

2235 description = "Library for reading fasta sequence files";

2236 license = "GPL";

2237 }) {};

2238 "biofastq" = callPackage

2239 ({ mkDerivation, base, biocore, bytestring }:

2240 mkDerivation {

2241 pname = "biofastq";

2242 version = "0.1";

2243 sha256 = "0453cb2sw6x9hx3z7w3fvymwi0l0s86wlvi6vvsh0jcwas3iirbl";

2244 configureFlags = [

2245 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2246 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2247 "-fsplitbase" "-f-test-hlint"

2248 ];

2249 libraryHaskellDepends = [ base biocore bytestring ];

2250 homepage = "http://biohaskell.org/";

2251 description = "A library for reading FASTQ files";

2252 license = "LGPL";

2253 }) {};

2254 "biophd" = callPackage

2255 ({ mkDerivation, base, binary, biocore, bytestring, parsec, text }:

2256 mkDerivation {

2257 pname = "biophd";

2258 version = "0.0.5";

2259 sha256 = "15bsrhwhgmdhl6l6xad1di4p1hslnlydawhqkf3z8y3pih1sasy7";

2260 configureFlags = [

2261 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2262 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2263 "-fsplitbase" "-f-test-hlint"

2264 ];

2265 libraryHaskellDepends = [

2266 base binary biocore bytestring parsec text

2267 ];

2268 homepage = "https://patch-tag.com/r/dfornika/biophd/home";

2269 description = "Library for reading phd sequence files";

2270 license = "GPL";

2271 }) {};

2272 "biopsl" = callPackage

2273 ({ mkDerivation, base, biocore, bytestring, cmdargs

2274 , unordered-containers

2275 }:

2276 mkDerivation {

2277 pname = "biopsl";

2278 version = "0.4";

2279 sha256 = "1v9vg9gnrf606raqlzcd15irg60v3cf5m0yy5qsdyxm24102bgmj";

2280 configureFlags = [

2281 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2282 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2283 "-fsplitbase" "-f-test-hlint"

2284 ];

2285 isLibrary = true;

2286 isExecutable = true;

2287 libraryHaskellDepends = [ base biocore bytestring ];

2288 executableHaskellDepends = [ cmdargs unordered-containers ];

2289 homepage = "http://biohaskell.org/";

2290 description = "Library and executables for working with PSL files";

2291 license = "LGPL";

2292 }) {};

2293 "biosff" = callPackage

2294 ({ mkDerivation, array, base, binary, biocore, bytestring, cmdargs

2295 , mtl

2296 }:

2297 mkDerivation {

2298 pname = "biosff";

2299 version = "0.3.7.1";

2300 sha256 = "1mxsqxcf5sh37gpfqil499i9n8wi3sk5sl2cx6x6agbc0n726bwq";

2301 configureFlags = [

2302 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2303 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2304 "-fsplitbase" "-f-test-hlint"

2305 ];

2306 isLibrary = true;

2307 isExecutable = true;

2308 libraryHaskellDepends = [ array base binary biocore bytestring ];

2309 executableHaskellDepends = [ array base cmdargs mtl ];

2310 homepage = "http://biohaskell.org/";

2311 description = "Library and executables for working with SFF files";

2312 license = stdenv.lib.licenses.lgpl21;

2313 }) {};

2314 "bits" = callPackage

2315 ({ mkDerivation, base, bytes, directory, doctest, filepath, mtl

2316 , transformers

2317 }:

2318 mkDerivation {

2319 pname = "bits";

2320 version = "0.4";

2321 sha256 = "12s5yk47y0zqzqiyaw9jchyl3crf1id9dk67m638b070d46k29p6";

2322 configureFlags = [

2323 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2324 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2325 "-fsplitbase" "-f-test-hlint"

2326 ];

2327 libraryHaskellDepends = [ base bytes mtl transformers ];

2328 testHaskellDepends = [ base directory doctest filepath ];

2329 doCheck = false;

2330 homepage = "http://github.com/analytics/bits";

2331 description = "Various bit twiddling and bitwise serialization primitives";

2332 license = stdenv.lib.licenses.bsd3;

2333 }) {};

2334 "blastxml" = callPackage

2335 ({ mkDerivation, base, biocore, bytestring, parallel, tagsoup }:

2336 mkDerivation {

2337 pname = "blastxml";

2338 version = "0.3.2";

2339 sha256 = "0slqvv8729vlniwswwipw3yss9id6xvmd416kad1ij064g28j00c";

2340 configureFlags = [

2341 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2342 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2343 "-fsplitbase" "-f-test-hlint"

2344 ];

2345 libraryHaskellDepends = [

2346 base biocore bytestring parallel tagsoup

2347 ];

2348 homepage = "http://biohaskell.org/";

2349 description = "Library for reading Blast XML output";

2350 license = "LGPL";

2351 }) {};

2352 "blaze-builder" = callPackage

2353 ({ mkDerivation, base, bytestring, text }:

2354 mkDerivation {

2355 pname = "blaze-builder";

2356 version = "0.3.3.4";

2357 sha256 = "12xgmi8bc3h3cfk31rrfaklmwvyxgdwzwmxzw22yxd0dd8g11hg5";

2358 configureFlags = [

2359 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2360 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2361 "-fsplitbase" "-f-test-hlint"

2362 ];

2363 libraryHaskellDepends = [ base bytestring text ];

2364 homepage = "http://github.com/meiersi/blaze-builder";

2365 description = "Efficient buffered output";

2366 license = stdenv.lib.licenses.bsd3;

2367 }) {};

2368 "blaze-builder-enumerator" = callPackage

2369 ({ mkDerivation, base, blaze-builder, bytestring, enumerator

2370 , transformers

2371 }:

2372 mkDerivation {

2373 pname = "blaze-builder-enumerator";

2374 version = "0.2.0.6";

2375 sha256 = "0pdw18drvikb465qh43b8wjyvpqj3wcilyczc21fri5ma4mxdkyp";

2376 configureFlags = [

2377 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2378 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2379 "-fsplitbase" "-f-test-hlint"

2380 ];

2381 libraryHaskellDepends = [

2382 base blaze-builder bytestring enumerator transformers

2383 ];

2384 homepage = "https://github.com/meiersi/blaze-builder-enumerator";

2385 description = "Enumeratees for the incremental conversion of builders to bytestrings";

2386 license = stdenv.lib.licenses.bsd3;

2387 }) {};

2388 "blaze-html" = callPackage

2389 ({ mkDerivation, base, blaze-builder, blaze-markup, bytestring

2390 , containers, HUnit, QuickCheck, test-framework

2391 , test-framework-hunit, test-framework-quickcheck2, text

2392 }:

2393 mkDerivation {

2394 pname = "blaze-html";

2395 version = "0.7.1.0";

2396 sha256 = "0krvyik9hdizvyx3r499vah34b1jnnv4ivm9h1ij7rgh9xjw34ja";

2397 configureFlags = [

2398 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2399 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2400 "-fsplitbase" "-f-test-hlint"

2401 ];

2402 libraryHaskellDepends = [

2403 base blaze-builder blaze-markup bytestring text

2404 ];

2405 testHaskellDepends = [

2406 base blaze-builder blaze-markup bytestring containers HUnit

2407 QuickCheck test-framework test-framework-hunit

2408 test-framework-quickcheck2 text

2409 ];

2410 homepage = "http://jaspervdj.be/blaze";

2411 description = "A blazingly fast HTML combinator library for Haskell";

2412 license = stdenv.lib.licenses.bsd3;

2413 }) {};

2414 "blaze-markup" = callPackage

2415 ({ mkDerivation, base, blaze-builder, bytestring, containers, HUnit

2416 , QuickCheck, test-framework, test-framework-hunit

2417 , test-framework-quickcheck2, text

2418 }:

2419 mkDerivation {

2420 pname = "blaze-markup";

2421 version = "0.6.3.0";

2422 sha256 = "1x057jlp89js6xbbyp4ky7xf5wq1ckl516b8bzp4y3knz50jshll";

2423 configureFlags = [

2424 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2425 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2426 "-fsplitbase" "-f-test-hlint"

2427 ];

2428 libraryHaskellDepends = [ base blaze-builder bytestring text ];

2429 testHaskellDepends = [

2430 base blaze-builder bytestring containers HUnit QuickCheck

2431 test-framework test-framework-hunit test-framework-quickcheck2 text

2432 ];

2433 homepage = "http://jaspervdj.be/blaze";

2434 description = "A blazingly fast markup combinator library for Haskell";

2435 license = stdenv.lib.licenses.bsd3;

2436 }) {};

2437 "blaze-svg" = callPackage

2438 ({ mkDerivation, base, blaze-markup, mtl }:

2439 mkDerivation {

2440 pname = "blaze-svg";

2441 version = "0.3.4.1";

2442 sha256 = "1bfxl2jwr622kgf4gz4gqpdrvscciqpfyzy6qad8j7w633xg8vrp";

2443 configureFlags = [

2444 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2445 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2446 "-fsplitbase" "-f-test-hlint"

2447 ];

2448 libraryHaskellDepends = [ base blaze-markup mtl ];

2449 homepage = "https://github.com/deepakjois/blaze-svg";

2450 description = "SVG combinator library";

2451 license = stdenv.lib.licenses.bsd3;

2452 }) {};

2453 "blaze-textual" = callPackage

2454 ({ mkDerivation, base, blaze-builder, bytestring, double-conversion

2455 , ghc-prim, integer-gmp, old-locale, QuickCheck, test-framework

2456 , test-framework-quickcheck2, text, time, vector

2457 }:

2458 mkDerivation {

2459 pname = "blaze-textual";

2460 version = "0.2.0.9";

2461 sha256 = "1gwy1pjnc2ikxfxn9c751rnydry1hmlfk13k29xnns9vwglf81f0";

2462 configureFlags = [

2463 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2464 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2465 "-fsplitbase" "-f-test-hlint"

2466 ];

2467 libraryHaskellDepends = [

2468 base blaze-builder bytestring ghc-prim integer-gmp old-locale text

2469 time vector

2470 ];

2471 testHaskellDepends = [

2472 base blaze-builder bytestring double-conversion QuickCheck

2473 test-framework test-framework-quickcheck2

2474 ];

2475 homepage = "http://github.com/bos/blaze-textual";

2476 description = "Fast rendering of common datatypes";

2477 license = stdenv.lib.licenses.bsd3;

2478 }) {};

2479 "bloodhound" = callPackage

2480 ({ mkDerivation, aeson, base, bytestring, conduit, containers

2481 , http-client, http-types, semigroups, text, time, vector

2482 }:

2483 mkDerivation {

2484 pname = "bloodhound";

2485 version = "0.5.0.1";

2486 sha256 = "1wvqj8fz3b6jvhmmi3calx6fsqjyvcpznks67bd0iiz9z0igh0ha";

2487 configureFlags = [

2488 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2489 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2490 "-fsplitbase" "-f-test-hlint"

2491 ];

2492 libraryHaskellDepends = [

2493 aeson base bytestring conduit containers http-client http-types

2494 semigroups text time vector

2495 ];

2496 doCheck = false;

2497 homepage = "https://github.com/bitemyapp/bloodhound";

2498 description = "ElasticSearch client library for Haskell";

2499 license = stdenv.lib.licenses.bsd3;

2500 }) {};

2501 "bmp" = callPackage

2502 ({ mkDerivation, base, binary, bytestring }:

2503 mkDerivation {

2504 pname = "bmp";

2505 version = "1.2.5.2";

2506 sha256 = "0f88f2ynm1fpzbjijy5fa8blfrdv42h5h28hfjlpd4fp0h96in5x";

2507 configureFlags = [

2508 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2509 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2510 "-fsplitbase" "-f-test-hlint"

2511 ];

2512 libraryHaskellDepends = [ base binary bytestring ];

2513 homepage = "http://code.ouroborus.net/bmp";

2514 description = "Read and write uncompressed BMP image files";

2515 license = stdenv.lib.licenses.mit;

2516 }) {};

2517 "bool-extras" = callPackage

2518 ({ mkDerivation, base }:

2519 mkDerivation {

2520 pname = "bool-extras";

2521 version = "0.4.0";

2522 sha256 = "008m43f04ncx2c24c241gzwjyyglw8rwpq2gsakqkw0nwz3czs61";

2523 configureFlags = [

2524 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2525 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2526 "-fsplitbase" "-f-test-hlint"

2527 ];

2528 libraryHaskellDepends = [ base ];

2529 homepage = "http://tom.lokhorst.eu/bool-extras";

2530 description = "A fold function for Bool";

2531 license = stdenv.lib.licenses.bsd3;

2532 }) {};

2533 "bound" = callPackage

2534 ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad

2535 , directory, doctest, filepath, hashable, hashable-extras

2536 , prelude-extras, profunctors, transformers, vector

2537 }:

2538 mkDerivation {

2539 pname = "bound";

2540 version = "1.0.4";

2541 sha256 = "17qnrjmqhx07cpzwd1z4lp2d42jx1lfxl6b86d65g4fd79miipky";

2542 configureFlags = [

2543 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2544 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2545 "-fsplitbase" "-f-test-hlint"

2546 ];

2547 libraryHaskellDepends = [

2548 base bifunctors binary bytes cereal comonad hashable

2549 hashable-extras prelude-extras profunctors transformers

2550 ];

2551 testHaskellDepends = [

2552 base directory doctest filepath prelude-extras transformers vector

2553 ];

2554 homepage = "http://github.com/ekmett/bound/";

2555 description = "Making de Bruijn Succ Less";

2556 license = stdenv.lib.licenses.bsd3;

2557 }) {};

2558 "broadcast-chan" = callPackage

2559 ({ mkDerivation, base }:

2560 mkDerivation {

2561 pname = "broadcast-chan";

2562 version = "0.1.0";

2563 sha256 = "1dympzv8gwh31hd0x6ap29rm83rf2klkj34as2xjrayfs9kbp87s";

2564 configureFlags = [

2565 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2566 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2567 "-fsplitbase" "-f-test-hlint"

2568 ];

2569 libraryHaskellDepends = [ base ];

2570 homepage = "https://github.com/merijn/broadcast-chan";

2571 description = "Broadcast channel type that avoids 0 reader space leaks";

2572 license = stdenv.lib.licenses.bsd3;

2573 }) {};

2574 "bson" = callPackage

2575 ({ mkDerivation, base, binary, bytestring, cryptohash

2576 , data-binary-ieee754, mtl, network, QuickCheck, test-framework

2577 , test-framework-quickcheck2, text, time

2578 }:

2579 mkDerivation {

2580 pname = "bson";

2581 version = "0.3.1";

2582 sha256 = "1kihsjws8sqb44gvilh1zxrqn2bml8gxq2bbanxqb7nr4ymwfkiv";

2583 configureFlags = [

2584 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2585 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2586 "-fsplitbase" "-f-test-hlint"

2587 ];

2588 libraryHaskellDepends = [

2589 base binary bytestring cryptohash data-binary-ieee754 mtl network

2590 text time

2591 ];

2592 testHaskellDepends = [

2593 base binary bytestring cryptohash data-binary-ieee754 mtl network

2594 QuickCheck test-framework test-framework-quickcheck2 text time

2595 ];

2596 homepage = "http://github.com/mongodb-haskell/bson";

2597 description = "BSON documents are JSON-like objects with a standard binary encoding";

2598 license = "unknown";

2599 }) {};

2600 "bumper" = callPackage

2601 ({ mkDerivation, base, Cabal, containers, fclabels, process

2602 , regex-compat, split, strict

2603 }:

2604 mkDerivation {

2605 pname = "bumper";

2606 version = "0.6.0.3";

2607 sha256 = "1a6sqkdzq05az6yj3zmlcbx6bmhw4zjx2aijxfi481z3ifiy7z3w";

2608 revision = "3";

2609 editedCabalFile = "0r4fj5mxl452786jw6pr2nwhs5sszlxb9nwcrakr44jysm181lhw";

2610 configureFlags = [

2611 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2612 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2613 "-fsplitbase" "-f-test-hlint"

2614 ];

2615 isLibrary = false;

2616 isExecutable = true;

2617 executableHaskellDepends = [

2618 base Cabal containers fclabels process regex-compat split strict

2619 ];

2620 doHaddock = false;

2621 homepage = "http://github.com/silkapp/bumper";

2622 description = "Automatically bump package versions, also transitively";

2623 license = stdenv.lib.licenses.bsd3;

2624 }) {};

2625 "byteable" = callPackage

2626 ({ mkDerivation, base, bytestring }:

2627 mkDerivation {

2628 pname = "byteable";

2629 version = "0.1.1";

2630 sha256 = "1qizg0kxxjqnd3cbrjhhidk5pbbciz0pb3z5kzikjjxnnnhk8fr4";

2631 configureFlags = [

2632 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2633 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2634 "-fsplitbase" "-f-test-hlint"

2635 ];

2636 enableSeparateDataOutput = true;

2637 libraryHaskellDepends = [ base bytestring ];

2638 homepage = "http://github.com/vincenthz/hs-byteable";

2639 description = "Type class for sequence of bytes";

2640 license = stdenv.lib.licenses.bsd3;

2641 }) {};

2642 "bytedump" = callPackage

2643 ({ mkDerivation, base, bytestring }:

2644 mkDerivation {

2645 pname = "bytedump";

2646 version = "1.0";

2647 sha256 = "1pf01mna3isx3i7m50yz3pw5ygz5sg8i8pshjb3yw8q41w2ba5xf";

2648 configureFlags = [

2649 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2650 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2651 "-fsplitbase" "-f-test-hlint"

2652 ];

2653 isLibrary = true;

2654 isExecutable = true;

2655 enableSeparateDataOutput = true;

2656 libraryHaskellDepends = [ base bytestring ];

2657 homepage = "http://github.com/vincenthz/hs-bytedump";

2658 description = "Flexible byte dump helpers for human readers";

2659 license = stdenv.lib.licenses.bsd3;

2660 }) {};

2661 "byteorder" = callPackage

2662 ({ mkDerivation, base }:

2663 mkDerivation {

2664 pname = "byteorder";

2665 version = "1.0.4";

2666 sha256 = "06995paxbxk8lldvarqpb3ygcjbg4v8dk4scib1rjzwlhssvn85x";

2667 configureFlags = [

2668 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2669 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2670 "-fsplitbase" "-f-test-hlint"

2671 ];

2672 libraryHaskellDepends = [ base ];

2673 homepage = "http://community.haskell.org/~aslatter/code/byteorder";

2674 description = "Exposes the native endianness or byte ordering of the system";

2675 license = stdenv.lib.licenses.bsd3;

2676 }) {};

2677 "bytes" = callPackage

2678 ({ mkDerivation, base, binary, bytestring, cereal, containers

2679 , directory, doctest, filepath, mtl, text, time, transformers

2680 , transformers-compat, void

2681 }:

2682 mkDerivation {

2683 pname = "bytes";

2684 version = "0.14.1.3";

2685 sha256 = "18pbn7qz93hwkdlbdld2mh91hki1smbcz0gsn6d816gr7whf1fhx";

2686 revision = "1";

2687 editedCabalFile = "1glk22is4ajmr6f2kg3b62vzknjgnkvs0n9w0jd1l2cfvqwvw3ij";

2688 configureFlags = [

2689 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2690 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2691 "-fsplitbase" "-f-test-hlint"

2692 ];

2693 libraryHaskellDepends = [

2694 base binary bytestring cereal containers mtl text time transformers

2695 transformers-compat void

2696 ];

2697 testHaskellDepends = [ base directory doctest filepath ];

2698 homepage = "http://github.com/analytics/bytes";

2699 description = "Sharing code for serialization between binary and cereal";

2700 license = stdenv.lib.licenses.bsd3;

2701 }) {};

2702 "bytestring-builder" = callPackage

2703 ({ mkDerivation, base, bytestring, deepseq }:

2704 mkDerivation {

2705 pname = "bytestring-builder";

2706 version = "0.10.4.1.2";

2707 sha256 = "0gp0ymz551qhxx3n3lxjhrr1fwcyd2qpn2y690k8qi6nc09sn14y";

2708 configureFlags = [

2709 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2710 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2711 "-fsplitbase" "-f-test-hlint"

2712 ];

2713 libraryHaskellDepends = [ base bytestring deepseq ];

2714 doHaddock = false;

2715 description = "The new bytestring builder, packaged outside of GHC";

2716 license = stdenv.lib.licenses.bsd3;

2717 }) {};

2718 "bytestring-lexing" = callPackage

2719 ({ mkDerivation, alex, array, base, bytestring }:

2720 mkDerivation {

2721 pname = "bytestring-lexing";

2722 version = "0.4.3.2";

2723 sha256 = "09ymg1n21668wn4harxg0cqlz98fz990bangpy99w2z7d6cwbc05";

2724 revision = "1";

2725 editedCabalFile = "0w9ybkvafgxiiq9sazppxb4pjyqpyv3abzy8isyp3vhxpmc4jzfc";

2726 configureFlags = [

2727 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2728 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2729 "-fsplitbase" "-f-test-hlint"

2730 ];

2731 libraryHaskellDepends = [ array base bytestring ];

2732 libraryToolDepends = [ alex ];

2733 homepage = "http://code.haskell.org/~wren/";

2734 description = "Parse and produce literals efficiently from strict or lazy bytestrings";

2735 license = stdenv.lib.licenses.bsd3;

2736 }) {};

2737 "bytestring-mmap" = callPackage

2738 ({ mkDerivation, base, bytestring, unix }:

2739 mkDerivation {

2740 pname = "bytestring-mmap";

2741 version = "0.2.2";

2742 sha256 = "1bv9xf4cpph1cbdwv6rbmq8ppi5wjpgd97lwln5l9ky5rvnaxg3v";

2743 configureFlags = [

2744 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2745 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2746 "-fsplitbase" "-f-test-hlint"

2747 ];

2748 libraryHaskellDepends = [ base bytestring unix ];

2749 homepage = "http://code.haskell.org/~dons/code/bytestring-mmap/";

2750 description = "mmap support for strict ByteStrings";

2751 license = stdenv.lib.licenses.bsd3;

2752 }) {};

2753 "bytestring-progress" = callPackage

2754 ({ mkDerivation, base, bytestring, terminal-progress-bar, time }:

2755 mkDerivation {

2756 pname = "bytestring-progress";

2757 version = "1.0.3";

2758 sha256 = "1v9cl7d4fcchbdrpbgjj4ilg79cj241vzijiifdsgkq30ikv2yxs";

2759 configureFlags = [

2760 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2761 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2762 "-fsplitbase" "-f-test-hlint"

2763 ];

2764 enableSeparateDataOutput = true;

2765 libraryHaskellDepends = [

2766 base bytestring terminal-progress-bar time

2767 ];

2768 doHaddock = false;

2769 homepage = "http://github.com/acw/bytestring-progress";

2770 description = "A library for tracking the consumption of a lazy ByteString";

2771 license = stdenv.lib.licenses.bsd3;

2772 }) {};

2773 "bytestring-show" = callPackage

2774 ({ mkDerivation, array, base, binary, bytestring, containers

2775 , integer-gmp

2776 }:

2777 mkDerivation {

2778 pname = "bytestring-show";

2779 version = "0.3.5.6";

2780 sha256 = "04h81a0bh2fvnkby1qafnydb29gzk6d4d311i2lbn7lm2vyjw919";

2781 revision = "1";

2782 editedCabalFile = "0n6qi0q2a18w3g8xza1c9cz3g5mv175xbs56zsk3kz6b32rga8x9";

2783 configureFlags = [

2784 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2785 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2786 "-fsplitbase" "-f-test-hlint"

2787 ];

2788 libraryHaskellDepends = [

2789 array base binary bytestring containers integer-gmp

2790 ];

2791 homepage = "http://code.haskell.org/~dolio/";

2792 description = "Efficient conversion of values into readable byte strings";

2793 license = stdenv.lib.licenses.bsd3;

2794 }) {};

2795 "bytestring-trie" = callPackage

2796 ({ mkDerivation, base, binary, bytestring }:

2797 mkDerivation {

2798 pname = "bytestring-trie";

2799 version = "0.2.4";

2800 sha256 = "1fv3xh52hqhzdbq78c3lrgx5vd49cabwp9ww5ki1888zlq29pyck";

2801 configureFlags = [

2802 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2803 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2804 "-fsplitbase" "-f-test-hlint"

2805 ];

2806 libraryHaskellDepends = [ base binary bytestring ];

2807 homepage = "http://code.haskell.org/~wren/";

2808 description = "An efficient finite map from (byte)strings to values";

2809 license = stdenv.lib.licenses.bsd3;

2810 }) {};

2811 "bzlib" = callPackage

2812 ({ mkDerivation, base, bytestring, bzip2 }:

2813 mkDerivation {

2814 pname = "bzlib";

2815 version = "0.5.0.5";

2816 sha256 = "0zh130vw719a8d11q5qzc3ilzgv8cqyc2a7r1a131cv1fjnd1rwy";

2817 configureFlags = [

2818 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2819 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2820 "-fsplitbase" "-f-test-hlint"

2821 ];

2822 libraryHaskellDepends = [ base bytestring ];

2823 librarySystemDepends = [ bzip2 ];

2824 description = "Compression and decompression in the bzip2 format";

2825 license = stdenv.lib.licenses.bsd3;

2826 }) {inherit (pkgs) bzip2;};

2827 "bzlib-conduit" = callPackage

2828 ({ mkDerivation, base, bindings-DSL, bytestring, bzip2, conduit

2829 , conduit-extra, data-default, hspec, mtl, QuickCheck, random

2830 , resourcet

2831 }:

2832 mkDerivation {

2833 pname = "bzlib-conduit";

2834 version = "0.2.1.3";

2835 sha256 = "0jqg38zvxc0fpp74az0vm8klb88zwy076ncwzgq2zr0nrmr5cghm";

2836 configureFlags = [

2837 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2838 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2839 "-fsplitbase" "-f-test-hlint"

2840 ];

2841 enableSeparateDataOutput = true;

2842 libraryHaskellDepends = [

2843 base bindings-DSL bytestring conduit conduit-extra data-default mtl

2844 resourcet

2845 ];

2846 librarySystemDepends = [ bzip2 ];

2847 testHaskellDepends = [

2848 base bytestring conduit conduit-extra hspec QuickCheck random

2849 resourcet

2850 ];

2851 benchmarkHaskellDepends = [ base conduit conduit-extra ];

2852 homepage = "https://github.com/snoyberg/bzlib-conduit";

2853 description = "Streaming compression/decompression via conduits";

2854 license = stdenv.lib.licenses.bsd3;

2855 }) {inherit (pkgs) bzip2;};

2856 "c2hs" = callPackage

2857 ({ mkDerivation, array, base, containers, directory, dlist

2858 , filepath, HUnit, language-c, pretty, process, shelly

2859 , test-framework, test-framework-hunit, text, transformers

2860 }:

2861 mkDerivation {

2862 pname = "c2hs";

2863 version = "0.20.1";

2864 sha256 = "1w2w9zxirzjd5lniwqakq59glgsh4mw3565x2l9qrin0bfjxkn3h";

2865 configureFlags = [

2866 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2867 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2868 "-fsplitbase" "-f-test-hlint"

2869 ];

2870 isLibrary = false;

2871 isExecutable = true;

2872 enableSeparateDataOutput = true;

2873 executableHaskellDepends = [

2874 array base containers directory dlist filepath language-c pretty

2875 process

2876 ];

2877 testHaskellDepends = [

2878 base filepath HUnit shelly test-framework test-framework-hunit text

2879 transformers

2880 ];

2881 doHaddock = false;

2882 homepage = "https://github.com/haskell/c2hs";

2883 description = "C->Haskell FFI tool that gives some cross-language type safety";

2884 license = stdenv.lib.licenses.gpl2;

2885 }) {};

2886 "cabal-install" = callPackage

2887 ({ mkDerivation, array, base, bytestring, Cabal, containers

2888 , directory, filepath, HTTP, HUnit, mtl, network, network-uri

2889 , pretty, process, QuickCheck, random, stm, test-framework

2890 , test-framework-hunit, test-framework-quickcheck2, time, unix

2891 , zlib

2892 }:

2893 mkDerivation {

2894 pname = "cabal-install";

2895 version = "1.18.0.8";

2896 sha256 = "1yx7vgyi2hs934z4ln7d8m2yrsakidb551ib01l9hxnmc3jbskwi";

2897 revision = "1";

2898 editedCabalFile = "1r875z5nrj80wzqya9qp1ypk9rjli35p49ihrir4jn6nc09njk1h";

2899 configureFlags = [

2900 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2901 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2902 "-fsplitbase" "-f-test-hlint"

2903 ];

2904 isLibrary = false;

2905 isExecutable = true;

2906 executableHaskellDepends = [

2907 array base bytestring Cabal containers directory filepath HTTP mtl

2908 network network-uri pretty process random stm time unix zlib

2909 ];

2910 testHaskellDepends = [

2911 array base bytestring Cabal containers directory filepath HTTP

2912 HUnit mtl network network-uri pretty process QuickCheck stm

2913 test-framework test-framework-hunit test-framework-quickcheck2 time

2914 unix zlib

2915 ];

2916 doHaddock = false;

2917 doCheck = false;

2918 postInstall = ''

2919 mkdir $out/etc

2920 mv bash-completion $out/etc/bash_completion.d

2921 '';

2922 homepage = "http://www.haskell.org/cabal/";

2923 description = "The command-line interface for Cabal and Hackage";

2924 license = stdenv.lib.licenses.bsd3;

2925 }) {};

2926 "cabal-src" = callPackage

2927 ({ mkDerivation, base, bytestring, Cabal, classy-prelude-conduit

2928 , conduit, conduit-extra, containers, directory, filepath

2929 , http-client, http-client-tls, http-conduit, http-types, network

2930 , process, resourcet, shelly, system-fileio, system-filepath, tar

2931 , temporary, text, transformers

2932 }:

2933 mkDerivation {

2934 pname = "cabal-src";

2935 version = "0.2.5";

2936 sha256 = "07nxnr011i50lpmahvj6q113zd6jmmxv83y4rby2rjnimjvgj3z7";

2937 configureFlags = [

2938 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2939 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2940 "-fsplitbase" "-f-test-hlint"

2941 ];

2942 isLibrary = false;

2943 isExecutable = true;

2944 executableHaskellDepends = [

2945 base bytestring Cabal classy-prelude-conduit conduit conduit-extra

2946 containers directory filepath http-client http-client-tls

2947 http-conduit http-types network process resourcet shelly

2948 system-fileio system-filepath tar temporary text transformers

2949 ];

2950 doHaddock = false;

2951 homepage = "https://github.com/yesodweb/cabal-src";

2952 description = "Alternative install procedure to avoid the diamond dependency issue";

2953 license = stdenv.lib.licenses.bsd3;

2954 }) {};

2955 "cairo" = callPackage

2956 ({ mkDerivation, array, base, bytestring, cairo, gtk2hs-buildtools

2957 , mtl, text, utf8-string

2958 }:

2959 mkDerivation {

2960 pname = "cairo";

2961 version = "0.13.1.0";

2962 sha256 = "0vi7glzizi2nvv0p5wsdxlpkx3f1875jpij26k2j4h0h6z53z3kb";

2963 configureFlags = [

2964 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2965 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2966 "-fsplitbase" "-f-test-hlint"

2967 ];

2968 enableSeparateDataOutput = true;

2969 libraryHaskellDepends = [

2970 array base bytestring mtl text utf8-string

2971 ];

2972 libraryPkgconfigDepends = [ cairo ];

2973 libraryToolDepends = [ gtk2hs-buildtools ];

2974 homepage = "http://projects.haskell.org/gtk2hs/";

2975 description = "Binding to the Cairo library";

2976 license = stdenv.lib.licenses.bsd3;

2977 }) {inherit (pkgs) cairo;};

2978 "case-insensitive" = callPackage

2979 ({ mkDerivation, base, bytestring, criterion, deepseq, hashable

2980 , HUnit, test-framework, test-framework-hunit, text

2981 }:

2982 mkDerivation {

2983 pname = "case-insensitive";

2984 version = "1.2.0.4";

2985 sha256 = "07nm40r9yw2p9qsfp3pjbsmyn4dabrxw34p48171zmccdd5hv0v3";

2986 configureFlags = [

2987 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

2988 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

2989 "-fsplitbase" "-f-test-hlint"

2990 ];

2991 libraryHaskellDepends = [ base bytestring deepseq hashable text ];

2992 testHaskellDepends = [

2993 base bytestring HUnit test-framework test-framework-hunit text

2994 ];

2995 benchmarkHaskellDepends = [ base bytestring criterion deepseq ];

2996 homepage = "https://github.com/basvandijk/case-insensitive";

2997 description = "Case insensitive string comparison";

2998 license = stdenv.lib.licenses.bsd3;

2999 }) {};

3000 "cases" = callPackage

3001 ({ mkDerivation, attoparsec, base-prelude, loch-th, text }:

3002 mkDerivation {

3003 pname = "cases";

3004 version = "0.1.2";

3005 sha256 = "02m4dlp0l4jd53j1ziq9hkxsj61m74b886ch7vx74n6caz90qnph";

3006 configureFlags = [

3007 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3008 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3009 "-fsplitbase" "-f-test-hlint"

3010 ];

3011 libraryHaskellDepends = [ attoparsec base-prelude loch-th text ];

3012 doCheck = false;

3013 homepage = "https://github.com/nikita-volkov/cases";

3014 description = "A converter for spinal, snake and camel cases";

3015 license = stdenv.lib.licenses.mit;

3016 }) {};

3017 "cassava" = callPackage

3018 ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring

3019 , containers, criterion, deepseq, ghc-prim, HUnit, lazy-csv

3020 , QuickCheck, test-framework, test-framework-hunit

3021 , test-framework-quickcheck2, text, unordered-containers, vector

3022 }:

3023 mkDerivation {

3024 pname = "cassava";

3025 version = "0.4.2.2";

3026 sha256 = "0apprj3qqxhwkplfzmhsi9x0a2acg8crxm28r3wl0vrk58rczvrf";

3027 configureFlags = [

3028 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3029 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3030 "-fsplitbase" "-f-test-hlint"

3031 ];

3032 libraryHaskellDepends = [

3033 array attoparsec base blaze-builder bytestring containers deepseq

3034 ghc-prim text unordered-containers vector

3035 ];

3036 testHaskellDepends = [

3037 attoparsec base bytestring HUnit QuickCheck test-framework

3038 test-framework-hunit test-framework-quickcheck2 text

3039 unordered-containers vector

3040 ];

3041 benchmarkHaskellDepends = [

3042 array attoparsec base blaze-builder bytestring containers criterion

3043 deepseq ghc-prim lazy-csv text unordered-containers vector

3044 ];

3045 homepage = "https://github.com/tibbe/cassava";

3046 description = "A CSV parsing and encoding library";

3047 license = stdenv.lib.licenses.bsd3;

3048 }) {};

3049 "cautious-file" = callPackage

3050 ({ mkDerivation, base, bytestring, directory, filepath, unix }:

3051 mkDerivation {

3052 pname = "cautious-file";

3053 version = "1.0.2";

3054 sha256 = "1sw5ngwrarq1lsd4c6v2wdmgbhkkq6kpybb62r8ccm11ddgn3yiq";

3055 revision = "1";

3056 editedCabalFile = "14yqf1wljrham5k4i4189h2pdlwgj3v59ff4p346fivdzh234666";

3057 configureFlags = [

3058 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3059 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3060 "-fsplitbase" "-f-test-hlint"

3061 ];

3062 libraryHaskellDepends = [

3063 base bytestring directory filepath unix

3064 ];

3065 doCheck = false;

3066 description = "Ways to write a file cautiously, to reduce the chances of problems such as data loss due to crashes or power failures";

3067 license = stdenv.lib.licenses.bsd3;

3068 }) {};

3069 "cereal" = callPackage

3070 ({ mkDerivation, array, base, bytestring, containers, ghc-prim }:

3071 mkDerivation {

3072 pname = "cereal";

3073 version = "0.4.1.1";

3074 sha256 = "15rhfn9hrjm01ksh9xpz9syxsp9vkvpp6b736iqq38wv2wb7416z";

3075 configureFlags = [

3076 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3077 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3078 "-fsplitbase" "-f-test-hlint"

3079 ];

3080 libraryHaskellDepends = [

3081 array base bytestring containers ghc-prim

3082 ];

3083 description = "A binary serialization library";

3084 license = stdenv.lib.licenses.bsd3;

3085 }) {};

3086 "cereal-conduit" = callPackage

3087 ({ mkDerivation, base, bytestring, cereal, conduit, HUnit, mtl

3088 , resourcet, transformers

3089 }:

3090 mkDerivation {

3091 pname = "cereal-conduit";

3092 version = "0.7.2.3";

3093 sha256 = "0s1s8jm25wxj44x44vjz4kz5qblkyjaz7f8rw5i81bzam32afj9s";

3094 configureFlags = [

3095 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3096 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3097 "-fsplitbase" "-f-test-hlint"

3098 ];

3099 libraryHaskellDepends = [

3100 base bytestring cereal conduit resourcet transformers

3101 ];

3102 testHaskellDepends = [

3103 base bytestring cereal conduit HUnit mtl resourcet transformers

3104 ];

3105 homepage = "https://github.com/snoyberg/conduit";

3106 description = "Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits";

3107 license = stdenv.lib.licenses.bsd3;

3108 }) {};

3109 "certificate" = callPackage

3110 ({ mkDerivation, asn1-data, base, bytestring, containers

3111 , crypto-pubkey-types, cryptohash, directory, filepath, mtl, pem

3112 , process, time

3113 }:

3114 mkDerivation {

3115 pname = "certificate";

3116 version = "1.3.9";

3117 sha256 = "18g5rq7lpxmvmlnz610537w6mix6z6kxjrfj2ylbhkc81r5pn9g6";

3118 revision = "1";

3119 editedCabalFile = "1fipx0vmc8kq8k9imnjiffdpng0qjqkzzwr308zgma9l3hx70jvb";

3120 configureFlags = [

3121 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3122 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3123 "-fsplitbase" "-f-test-hlint"

3124 ];

3125 isLibrary = true;

3126 isExecutable = true;

3127 libraryHaskellDepends = [

3128 asn1-data base bytestring containers crypto-pubkey-types cryptohash

3129 directory filepath mtl pem process time

3130 ];

3131 homepage = "http://github.com/vincenthz/hs-certificate";

3132 description = "Certificates and Key Reader/Writer";

3133 license = stdenv.lib.licenses.bsd3;

3134 }) {};

3135 "charset" = callPackage

3136 ({ mkDerivation, array, base, bytestring, containers, semigroups

3137 , unordered-containers

3138 }:

3139 mkDerivation {

3140 pname = "charset";

3141 version = "0.3.7";

3142 sha256 = "1x912dx5650x8ql3ivhpiwmxd6kv7zghark3s8ljvl1g3qr1pxd6";

3143 configureFlags = [

3144 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3145 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3146 "-fsplitbase" "-f-test-hlint"

3147 ];

3148 libraryHaskellDepends = [

3149 array base bytestring containers semigroups unordered-containers

3150 ];

3151 homepage = "http://github.com/ekmett/charset";

3152 description = "Fast unicode character sets based on complemented PATRICIA tries";

3153 license = stdenv.lib.licenses.bsd3;

3154 }) {};

3155 "check-email" = callPackage

3156 ({ mkDerivation, base, bytestring, email-validate, resolv }:

3157 mkDerivation {

3158 pname = "check-email";

3159 version = "1.0";

3160 sha256 = "1drw8rspdc4a7jw2ql3fi1dcmw56ah5csf2bil6ii8ccq5vsbfyz";

3161 revision = "1";

3162 editedCabalFile = "0x8dq8ja9di728b2fcqji655xrp9ckw58ryd02286rg7xrp63y1r";

3163 configureFlags = [

3164 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3165 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3166 "-fsplitbase" "-f-test-hlint"

3167 ];

3168 libraryHaskellDepends = [ base bytestring email-validate ];

3169 librarySystemDepends = [ resolv ];

3170 description = "Confirm whether an email is valid and probably existant";

3171 license = stdenv.lib.licenses.bsd3;

3172 }) {resolv = null;};

3173 "checkers" = callPackage

3174 ({ mkDerivation, array, base, QuickCheck, random }:

3175 mkDerivation {

3176 pname = "checkers";

3177 version = "0.4.2";

3178 sha256 = "0v2qvd0g0k2j3h07003wc2vkrknq6y3ld1qgh69j4r6049x9qhaj";

3179 configureFlags = [

3180 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3181 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3182 "-fsplitbase" "-f-test-hlint"

3183 ];

3184 libraryHaskellDepends = [ array base QuickCheck random ];

3185 description = "Check properties on standard classes and data structures";

3186 license = stdenv.lib.licenses.bsd3;

3187 }) {};

3188 "chell" = callPackage

3189 ({ mkDerivation, ansi-terminal, base, bytestring, options, patience

3190 , random, template-haskell, text, transformers

3191 }:

3192 mkDerivation {

3193 pname = "chell";

3194 version = "0.4.0.1";

3195 sha256 = "0lb95abzxl4a87nfqxsxpb3a39pd52cci43hcvj8615hyhqvs2jz";

3196 configureFlags = [

3197 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3198 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3199 "-fsplitbase" "-f-test-hlint"

3200 ];

3201 libraryHaskellDepends = [

3202 ansi-terminal base bytestring options patience random

3203 template-haskell text transformers

3204 ];

3205 homepage = "https://john-millikin.com/software/chell/";

3206 description = "A simple and intuitive library for automated testing";

3207 license = stdenv.lib.licenses.mit;

3208 }) {};

3209 "chell-quickcheck" = callPackage

3210 ({ mkDerivation, base, chell, QuickCheck, random }:

3211 mkDerivation {

3212 pname = "chell-quickcheck";

3213 version = "0.2.5";

3214 sha256 = "02bkcnx5k6r5csdnnkvk4wfd0l36nxb87i1463ynw17n7ym9s4cs";

3215 configureFlags = [

3216 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3217 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3218 "-fsplitbase" "-f-test-hlint"

3219 ];

3220 libraryHaskellDepends = [ base chell QuickCheck random ];

3221 homepage = "https://john-millikin.com/software/chell/";

3222 description = "QuickCheck support for the Chell testing library";

3223 license = stdenv.lib.licenses.mit;

3224 }) {};

3225 "chunked-data" = callPackage

3226 ({ mkDerivation, base, blaze-builder, bytestring, containers

3227 , mono-traversable, semigroups, system-filepath, text, transformers

3228 , vector

3229 }:

3230 mkDerivation {

3231 pname = "chunked-data";

3232 version = "0.1.0.1";

3233 sha256 = "0kdq79mxi9nhy3dqw283f5ffx4rxwfrdq9cfw46ql5wmqrg2qw7r";

3234 revision = "1";

3235 editedCabalFile = "179m2da2b8q08cqnryrsviawc7d5ml67rah0pa9wmnbpwdpq0ynj";

3236 configureFlags = [

3237 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3238 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3239 "-fsplitbase" "-f-test-hlint"

3240 ];

3241 libraryHaskellDepends = [

3242 base blaze-builder bytestring containers mono-traversable

3243 semigroups system-filepath text transformers vector

3244 ];

3245 homepage = "https://github.com/fpco/chunked-data";

3246 description = "Typeclasses for dealing with various chunked data representations";

3247 license = stdenv.lib.licenses.mit;

3248 }) {};

3249 "cipher-aes" = callPackage

3250 ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests

3251 , crypto-cipher-types, QuickCheck, securemem, test-framework

3252 , test-framework-quickcheck2

3253 }:

3254 mkDerivation {

3255 pname = "cipher-aes";

3256 version = "0.2.10";

3257 sha256 = "1sglxv66byib2bcwhilcf4m4glhz02vxy2lxa0hvpwa9c0ifhcxz";

3258 configureFlags = [

3259 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3260 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3261 "-fsplitbase" "-f-test-hlint"

3262 ];

3263 libraryHaskellDepends = [

3264 base byteable bytestring crypto-cipher-types securemem

3265 ];

3266 testHaskellDepends = [

3267 base byteable bytestring crypto-cipher-tests crypto-cipher-types

3268 QuickCheck test-framework test-framework-quickcheck2

3269 ];

3270 homepage = "https://github.com/vincenthz/hs-cipher-aes";

3271 description = "Fast AES cipher implementation with advanced mode of operations";

3272 license = stdenv.lib.licenses.bsd3;

3273 }) {};

3274 "cipher-blowfish" = callPackage

3275 ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests

3276 , crypto-cipher-types, QuickCheck, securemem, test-framework

3277 , test-framework-quickcheck2, vector

3278 }:

3279 mkDerivation {

3280 pname = "cipher-blowfish";

3281 version = "0.0.3";

3282 sha256 = "0hb67gmiyqrknynz5am8nada1b1v47rqla87dw5nvfhxhl51fhcg";

3283 configureFlags = [

3284 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3285 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3286 "-fsplitbase" "-f-test-hlint"

3287 ];

3288 libraryHaskellDepends = [

3289 base byteable bytestring crypto-cipher-types securemem vector

3290 ];

3291 testHaskellDepends = [

3292 base byteable bytestring crypto-cipher-tests crypto-cipher-types

3293 QuickCheck test-framework test-framework-quickcheck2

3294 ];

3295 homepage = "http://github.com/vincenthz/hs-crypto-cipher";

3296 description = "Blowfish cipher";

3297 license = stdenv.lib.licenses.bsd3;

3298 }) {};

3299 "cipher-camellia" = callPackage

3300 ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests

3301 , crypto-cipher-types, QuickCheck, securemem, test-framework

3302 , test-framework-quickcheck2, vector

3303 }:

3304 mkDerivation {

3305 pname = "cipher-camellia";

3306 version = "0.0.2";

3307 sha256 = "19z2mi1rvp8fsqjdbmrm1hdlxmx61yr55fyknmmn945qrlvx234d";

3308 configureFlags = [

3309 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3310 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3311 "-fsplitbase" "-f-test-hlint"

3312 ];

3313 libraryHaskellDepends = [

3314 base byteable bytestring crypto-cipher-types securemem vector

3315 ];

3316 testHaskellDepends = [

3317 base byteable bytestring crypto-cipher-tests crypto-cipher-types

3318 QuickCheck test-framework test-framework-quickcheck2

3319 ];

3320 homepage = "http://github.com/vincenthz/hs-crypto-cipher";

3321 description = "Camellia block cipher primitives";

3322 license = stdenv.lib.licenses.bsd3;

3323 }) {};

3324 "cipher-des" = callPackage

3325 ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests

3326 , crypto-cipher-types, QuickCheck, securemem, test-framework

3327 , test-framework-quickcheck2

3328 }:

3329 mkDerivation {

3330 pname = "cipher-des";

3331 version = "0.0.6";

3332 sha256 = "1isazxa2nr1y13y0danfk7wghy34rfpn3f43rw714nk2xk6vrwc5";

3333 configureFlags = [

3334 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3335 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3336 "-fsplitbase" "-f-test-hlint"

3337 ];

3338 libraryHaskellDepends = [

3339 base byteable bytestring crypto-cipher-types securemem

3340 ];

3341 testHaskellDepends = [

3342 base byteable bytestring crypto-cipher-tests crypto-cipher-types

3343 QuickCheck test-framework test-framework-quickcheck2

3344 ];

3345 homepage = "http://github.com/vincenthz/hs-crypto-cipher";

3346 description = "DES and 3DES primitives";

3347 license = stdenv.lib.licenses.bsd3;

3348 }) {};

3349 "cipher-rc4" = callPackage

3350 ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests

3351 , crypto-cipher-types, QuickCheck, test-framework

3352 , test-framework-quickcheck2

3353 }:

3354 mkDerivation {

3355 pname = "cipher-rc4";

3356 version = "0.1.4";

3357 sha256 = "0k9qf0cn5yxc4qlqikcm5yyrnkkvr6g3v7306cp8iwz7r4dp6zn6";

3358 configureFlags = [

3359 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3360 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3361 "-fsplitbase" "-f-test-hlint"

3362 ];

3363 libraryHaskellDepends = [

3364 base byteable bytestring crypto-cipher-types

3365 ];

3366 testHaskellDepends = [

3367 base bytestring crypto-cipher-tests crypto-cipher-types QuickCheck

3368 test-framework test-framework-quickcheck2

3369 ];

3370 homepage = "http://github.com/vincenthz/hs-cipher-rc4";

3371 description = "Fast RC4 cipher implementation";

3372 license = stdenv.lib.licenses.bsd3;

3373 }) {};

3374 "circle-packing" = callPackage

3375 ({ mkDerivation, base }:

3376 mkDerivation {

3377 pname = "circle-packing";

3378 version = "0.1.0.4";

3379 sha256 = "1sysyzhkjb7z4mn9hgxqiq0nd7ap3rs7w22swjrpnf8l1sv09xgv";

3380 configureFlags = [

3381 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3382 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3383 "-fsplitbase" "-f-test-hlint"

3384 ];

3385 libraryHaskellDepends = [ base ];

3386 description = "Simple heuristic for packing discs of varying radii in a circle";

3387 license = stdenv.lib.licenses.bsd3;

3388 }) {};

3389 "classy-prelude" = callPackage

3390 ({ mkDerivation, base, basic-prelude, bifunctors, bytestring

3391 , chunked-data, containers, enclosed-exceptions, exceptions

3392 , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl

3393 , mutable-containers, old-locale, primitive, QuickCheck, semigroups

3394 , stm, system-filepath, text, time, transformers

3395 , unordered-containers, vector, vector-instances

3396 }:

3397 mkDerivation {

3398 pname = "classy-prelude";

3399 version = "0.10.5";

3400 sha256 = "1s9hydjs7x522w9hgrxjzx1d2zir80g140y4vdqd7mizv0yzisy3";

3401 revision = "1";

3402 editedCabalFile = "1gwd3s3sp8qkqh04gzmh7j0x0w9vnz7z236vzsg7k2zycnxn1ij6";

3403 configureFlags = [

3404 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3405 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3406 "-fsplitbase" "-f-test-hlint"

3407 ];

3408 libraryHaskellDepends = [

3409 base basic-prelude bifunctors bytestring chunked-data containers

3410 enclosed-exceptions exceptions ghc-prim hashable lifted-base

3411 mono-traversable mtl mutable-containers old-locale primitive

3412 semigroups stm system-filepath text time transformers

3413 unordered-containers vector vector-instances

3414 ];

3415 testHaskellDepends = [

3416 base containers hspec QuickCheck transformers unordered-containers

3417 ];

3418 homepage = "https://github.com/snoyberg/classy-prelude";

3419 description = "A typeclass-based Prelude";

3420 license = stdenv.lib.licenses.mit;

3421 }) {};

3422 "classy-prelude-conduit" = callPackage

3423 ({ mkDerivation, base, bytestring, classy-prelude, conduit

3424 , conduit-combinators, hspec, monad-control, QuickCheck, resourcet

3425 , system-fileio, transformers, void

3426 }:

3427 mkDerivation {

3428 pname = "classy-prelude-conduit";

3429 version = "0.10.5";

3430 sha256 = "1dy9jj260hn571z1wdm0v5zpgalwgij99clmh541b41h6pjbism2";

3431 configureFlags = [

3432 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3433 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3434 "-fsplitbase" "-f-test-hlint"

3435 ];

3436 libraryHaskellDepends = [

3437 base bytestring classy-prelude conduit conduit-combinators

3438 monad-control resourcet system-fileio transformers void

3439 ];

3440 testHaskellDepends = [

3441 base bytestring conduit hspec QuickCheck transformers

3442 ];

3443 homepage = "https://github.com/snoyberg/classy-prelude";

3444 description = "conduit instances for classy-prelude";

3445 license = stdenv.lib.licenses.mit;

3446 }) {};

3447 "classy-prelude-yesod" = callPackage

3448 ({ mkDerivation, aeson, base, classy-prelude

3449 , classy-prelude-conduit, data-default, http-conduit, http-types

3450 , persistent, yesod, yesod-newsfeed, yesod-static

3451 }:

3452 mkDerivation {

3453 pname = "classy-prelude-yesod";

3454 version = "0.10.5";

3455 sha256 = "0phaczjsn3blca3y6cwnqwhd9wrl7im1r2kh4i6a83c9kirsa5cx";

3456 configureFlags = [

3457 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3458 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3459 "-fsplitbase" "-f-test-hlint"

3460 ];

3461 libraryHaskellDepends = [

3462 aeson base classy-prelude classy-prelude-conduit data-default

3463 http-conduit http-types persistent yesod yesod-newsfeed

3464 yesod-static

3465 ];

3466 homepage = "https://github.com/snoyberg/classy-prelude";

3467 description = "Provide a classy prelude including common Yesod functionality";

3468 license = stdenv.lib.licenses.mit;

3469 }) {};

3470 "clientsession" = callPackage

3471 ({ mkDerivation, base, base64-bytestring, bytestring, cereal

3472 , cipher-aes, containers, cprng-aes, crypto-api, crypto-random

3473 , directory, entropy, hspec, HUnit, QuickCheck, setenv, skein

3474 , tagged, transformers

3475 }:

3476 mkDerivation {

3477 pname = "clientsession";

3478 version = "0.9.1.1";

3479 sha256 = "08h0461ydhfymw2pya472n81kx5rqp7awfgxlbz2r851rl5kqmn9";

3480 configureFlags = [

3481 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3482 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3483 "-fsplitbase" "-f-test-hlint"

3484 ];

3485 isLibrary = true;

3486 isExecutable = true;

3487 libraryHaskellDepends = [

3488 base base64-bytestring bytestring cereal cipher-aes cprng-aes

3489 crypto-api crypto-random directory entropy setenv skein tagged

3490 ];

3491 executableHaskellDepends = [ base ];

3492 testHaskellDepends = [

3493 base bytestring cereal containers hspec HUnit QuickCheck

3494 transformers

3495 ];

3496 homepage = "http://github.com/yesodweb/clientsession/tree/master";

3497 description = "Securely store session data in a client-side cookie";

3498 license = stdenv.lib.licenses.bsd3;

3499 }) {};

3500 "clock" = callPackage

3501 ({ mkDerivation, base }:

3502 mkDerivation {

3503 pname = "clock";

3504 version = "0.4.1.3";

3505 sha256 = "0wqhg8gb10lby01f0v4fl4yp23l4ilizywp5xnsbja03svnb4f0d";

3506 revision = "1";

3507 editedCabalFile = "0h04y3qyqz6fc6zw7myyyy9ib4l6ys1lyq216awkzwl4rfgxcgv5";

3508 configureFlags = [

3509 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3510 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3511 "-fsplitbase" "-f-test-hlint"

3512 ];

3513 libraryHaskellDepends = [ base ];

3514 homepage = "http://corsis.github.com/clock/";

3515 description = "High-resolution clock functions: monotonic, realtime, cputime";

3516 license = stdenv.lib.licenses.bsd3;

3517 }) {};

3518 "cmdargs" = callPackage

3519 ({ mkDerivation, base, filepath, process, template-haskell

3520 , transformers

3521 }:

3522 mkDerivation {

3523 pname = "cmdargs";

3524 version = "0.10.12";

3525 sha256 = "0axn3ycw4rijh1ka5f73gz9w330s851cpxbv39ia4xnb0l95hrjy";

3526 revision = "1";

3527 editedCabalFile = "1p74npr3qy8hcslj1jai3bdjrxar0hfqm4vpbzcsrjvw6gk94z73";

3528 configureFlags = [

3529 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3530 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3531 "-fsplitbase" "-f-test-hlint"

3532 ];

3533 isLibrary = true;

3534 isExecutable = true;

3535 libraryHaskellDepends = [

3536 base filepath process template-haskell transformers

3537 ];

3538 homepage = "http://community.haskell.org/~ndm/cmdargs/";

3539 description = "Command line argument processing";

3540 license = stdenv.lib.licenses.bsd3;

3541 }) {};

3542 "code-builder" = callPackage

3543 ({ mkDerivation, base, containers }:

3544 mkDerivation {

3545 pname = "code-builder";

3546 version = "0.1.3";

3547 sha256 = "1ax4c19xkszahcxvwc1wa1hrgk6ajck5sbprbplsi1gc9jj4g7jm";

3548 configureFlags = [

3549 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3550 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3551 "-fsplitbase" "-f-test-hlint"

3552 ];

3553 libraryHaskellDepends = [ base containers ];

3554 description = "Simple system for generating code";

3555 license = stdenv.lib.licenses.bsd3;

3556 }) {};

3557 "colour" = callPackage

3558 ({ mkDerivation, base }:

3559 mkDerivation {

3560 pname = "colour";

3561 version = "2.3.3";

3562 sha256 = "1qmn1778xzg07jg9nx4k1spdz2llivpblf6wwrps1qpqjhsac5cd";

3563 configureFlags = [

3564 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3565 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3566 "-fsplitbase" "-f-test-hlint"

3567 ];

3568 enableSeparateDataOutput = true;

3569 libraryHaskellDepends = [ base ];

3570 homepage = "http://www.haskell.org/haskellwiki/Colour";

3571 description = "A model for human colour/color perception";

3572 license = stdenv.lib.licenses.mit;

3573 }) {};

3574 "comonad" = callPackage

3575 ({ mkDerivation, base, containers, contravariant, directory

3576 , distributive, doctest, filepath, semigroups, tagged, transformers

3577 , transformers-compat

3578 }:

3579 mkDerivation {

3580 pname = "comonad";

3581 version = "4.2.5";

3582 sha256 = "07ilryqgvnkr4vmifg0dncgzmx87i2fbfbgrgc3jn1yz808s7wqf";

3583 revision = "2";

3584 editedCabalFile = "16wg9qi92122cyilng08fw1099m7n920g1z7vrafxsmsy0qvfcks";

3585 configureFlags = [

3586 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3587 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3588 "-fsplitbase" "-f-test-hlint"

3589 ];

3590 libraryHaskellDepends = [

3591 base containers contravariant distributive semigroups tagged

3592 transformers transformers-compat

3593 ];

3594 testHaskellDepends = [ base directory doctest filepath ];

3595 homepage = "http://github.com/ekmett/comonad/";

3596 description = "Comonads";

3597 license = stdenv.lib.licenses.bsd3;

3598 }) {};

3599 "comonad-transformers" = callPackage

3600 ({ mkDerivation, base, comonad }:

3601 mkDerivation {

3602 pname = "comonad-transformers";

3603 version = "4.0";

3604 sha256 = "13zzp6r6s6c80skniphwvzxhpazbyal5854m53139kgcw560rv6z";

3605 configureFlags = [

3606 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3607 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3608 "-fsplitbase" "-f-test-hlint"

3609 ];

3610 libraryHaskellDepends = [ base comonad ];

3611 doHaddock = false;

3612 homepage = "http://github.com/ekmett/comonad-transformers/";

3613 description = "This package has been merged into comonad 4.0";

3614 license = stdenv.lib.licenses.bsd3;

3615 }) {};

3616 "comonads-fd" = callPackage

3617 ({ mkDerivation, base, comonad }:

3618 mkDerivation {

3619 pname = "comonads-fd";

3620 version = "4.0";

3621 sha256 = "19xpv0dsz7w3a1sq1gdxwzglfal45vj2s22zb12g9mpk5rp3hw1s";

3622 configureFlags = [

3623 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3624 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3625 "-fsplitbase" "-f-test-hlint"

3626 ];

3627 libraryHaskellDepends = [ base comonad ];

3628 doHaddock = false;

3629 homepage = "http://github.com/ekmett/comonads-fd/";

3630 description = "This package has been merged into comonad 4.0";

3631 license = stdenv.lib.licenses.bsd3;

3632 }) {};

3633 "compdata" = callPackage

3634 ({ mkDerivation, base, containers, criterion, deepseq, derive, mtl

3635 , QuickCheck, random, template-haskell, th-expand-syns

3636 , transformers, tree-view, uniplate

3637 }:

3638 mkDerivation {

3639 pname = "compdata";

3640 version = "0.9";

3641 sha256 = "1wk9vj834l3fc64fcsrgc9hz5f2z7461hs8lv1ldkfsixx4mxyqc";

3642 configureFlags = [

3643 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3644 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3645 "-fsplitbase" "-f-test-hlint"

3646 ];

3647 libraryHaskellDepends = [

3648 base containers deepseq derive mtl QuickCheck template-haskell

3649 th-expand-syns transformers tree-view

3650 ];

3651 benchmarkHaskellDepends = [

3652 base containers criterion deepseq derive mtl QuickCheck random

3653 template-haskell th-expand-syns transformers uniplate

3654 ];

3655 doCheck = false;

3656 description = "Compositional Data Types";

3657 license = stdenv.lib.licenses.bsd3;

3658 }) {};

3659 "compensated" = callPackage

3660 ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad

3661 , deepseq, directory, distributive, doctest, filepath

3662 , generic-deriving, hashable, lens, log-domain, safecopy

3663 , semigroupoids, semigroups, simple-reflect, vector

3664 }:

3665 mkDerivation {

3666 pname = "compensated";

3667 version = "0.6.1";

3668 sha256 = "026gq3ppk3id4bvkn3pdg6ljbl14gd8p4hg6i0rc13138b0mlxnh";

3669 configureFlags = [

3670 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3671 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3672 "-fsplitbase" "-f-test-hlint"

3673 ];

3674 libraryHaskellDepends = [

3675 base bifunctors binary bytes cereal comonad deepseq distributive

3676 generic-deriving hashable lens log-domain safecopy semigroupoids

3677 semigroups vector

3678 ];

3679 testHaskellDepends = [

3680 base directory doctest filepath generic-deriving semigroups

3681 simple-reflect

3682 ];

3683 homepage = "http://github.com/analytics/compensated/";

3684 description = "Compensated floating-point arithmetic";

3685 license = stdenv.lib.licenses.bsd3;

3686 }) {};

3687 "composition" = callPackage

3688 ({ mkDerivation }:

3689 mkDerivation {

3690 pname = "composition";

3691 version = "1.0.1.0";

3692 sha256 = "1gx27vz2djiiwygcjaygjmiwjnls084b5v9km3jpimlz312qh5hc";

3693 configureFlags = [

3694 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3695 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3696 "-fsplitbase" "-f-test-hlint"

3697 ];

3698 homepage = "http://patch-tag.com/r/DanBurton/composition/home";

3699 description = "Combinators for unorthodox function composition";

3700 license = stdenv.lib.licenses.bsd3;

3701 }) {};

3702 "compressed" = callPackage

3703 ({ mkDerivation, base, comonad, containers, fingertree, hashable

3704 , keys, pointed, reducers, semigroupoids, semigroups

3705 , unordered-containers

3706 }:

3707 mkDerivation {

3708 pname = "compressed";

3709 version = "3.10";

3710 sha256 = "1y290n421knfh8k8zbcabhw24hb13xj9pkxx4h4v15yji97p5mcw";

3711 revision = "1";

3712 editedCabalFile = "1fv1ix8bsqbsrzp44i7nz0wp1dwi3l2wdvqvp46a8vbakp5nif8a";

3713 configureFlags = [

3714 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3715 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3716 "-fsplitbase" "-f-test-hlint"

3717 ];

3718 libraryHaskellDepends = [

3719 base comonad containers fingertree hashable keys pointed reducers

3720 semigroupoids semigroups unordered-containers

3721 ];

3722 homepage = "http://github.com/ekmett/compressed/";

3723 description = "Compressed containers and reducers";

3724 license = stdenv.lib.licenses.bsd3;

3725 }) {};

3726 "concatenative" = callPackage

3727 ({ mkDerivation, base, template-haskell }:

3728 mkDerivation {

3729 pname = "concatenative";

3730 version = "1.0.1";

3731 sha256 = "05xwqvcdnk8bsyj698ab9jxpa1nk23pf3m7wi9mwmw0q8n99fngd";

3732 configureFlags = [

3733 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3734 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3735 "-fsplitbase" "-f-test-hlint"

3736 ];

3737 libraryHaskellDepends = [ base template-haskell ];

3738 homepage = "https://patch-tag.com/r/salazar/concatenative/snapshot/current/content/pretty";

3739 description = "A library for postfix control flow";

3740 license = stdenv.lib.licenses.bsd3;

3741 }) {};

3742 "concurrent-extra" = callPackage

3743 ({ mkDerivation, async, base, HUnit, random, stm, test-framework

3744 , test-framework-hunit, unbounded-delays

3745 }:

3746 mkDerivation {

3747 pname = "concurrent-extra";

3748 version = "0.7.0.9";

3749 sha256 = "19bqm0brnbhhmp5nypi995p27mna7kd33xzw0kf7yx2w2p2kb1aw";

3750 configureFlags = [

3751 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3752 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3753 "-fsplitbase" "-f-test-hlint"

3754 ];

3755 libraryHaskellDepends = [ base stm unbounded-delays ];

3756 testHaskellDepends = [

3757 async base HUnit random stm test-framework test-framework-hunit

3758 unbounded-delays

3759 ];

3760 doCheck = false;

3761 homepage = "https://github.com/basvandijk/concurrent-extra";

3762 description = "Extra concurrency primitives";

3763 license = stdenv.lib.licenses.bsd3;

3764 }) {};

3765 "concurrent-supply" = callPackage

3766 ({ mkDerivation, base, containers, ghc-prim, hashable }:

3767 mkDerivation {

3768 pname = "concurrent-supply";

3769 version = "0.1.7.1";

3770 sha256 = "050d1k4hvjjyap3w8spcx57lagnh77z131jbgsndpc9mjx8r4l5y";

3771 configureFlags = [

3772 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3773 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3774 "-fsplitbase" "-f-test-hlint"

3775 ];

3776 libraryHaskellDepends = [ base ghc-prim hashable ];

3777 testHaskellDepends = [ base containers ];

3778 homepage = "http://github.com/ekmett/concurrent-supply/";

3779 description = "A fast concurrent unique identifier supply with a pure API";

3780 license = stdenv.lib.licenses.bsd3;

3781 }) {};

3782 "cond" = callPackage

3783 ({ mkDerivation, base }:

3784 mkDerivation {

3785 pname = "cond";

3786 version = "0.4.1.1";

3787 sha256 = "12xcjxli1scd4asr4zc77i5q9qka2100gx97hv3vv12l7gj7d703";

3788 configureFlags = [

3789 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3790 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3791 "-fsplitbase" "-f-test-hlint"

3792 ];

3793 libraryHaskellDepends = [ base ];

3794 homepage = "https://github.com/kallisti-dev/cond";

3795 description = "Basic conditional and boolean operators with monadic variants";

3796 license = stdenv.lib.licenses.bsd3;

3797 }) {};

3798 "conduit" = callPackage

3799 ({ mkDerivation, base, containers, criterion, deepseq, exceptions

3800 , hspec, kan-extensions, lifted-base, mmorph, mtl, mwc-random

3801 , QuickCheck, resourcet, safe, transformers, transformers-base

3802 , vector, void

3803 }:

3804 mkDerivation {

3805 pname = "conduit";

3806 version = "1.2.4";

3807 sha256 = "1vqajj5mwnknqcjc5pj883jz4iwjj6is4jr701bzr0n6ngvn7qvh";

3808 configureFlags = [

3809 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3810 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3811 "-fsplitbase" "-f-test-hlint"

3812 ];

3813 libraryHaskellDepends = [

3814 base exceptions lifted-base mmorph mtl resourcet transformers

3815 transformers-base void

3816 ];

3817 testHaskellDepends = [

3818 base containers exceptions hspec mtl QuickCheck resourcet safe

3819 transformers void

3820 ];

3821 benchmarkHaskellDepends = [

3822 base containers criterion deepseq hspec kan-extensions mwc-random

3823 transformers vector

3824 ];

3825 homepage = "http://github.com/snoyberg/conduit";

3826 description = "Streaming data processing library";

3827 license = stdenv.lib.licenses.mit;

3828 }) {};

3829 "conduit-combinators" = callPackage

3830 ({ mkDerivation, base, base16-bytestring, base64-bytestring

3831 , bytestring, chunked-data, conduit, conduit-extra, containers

3832 , directory, hspec, monad-control, mono-traversable, mtl

3833 , mwc-random, primitive, QuickCheck, resourcet, safe, silently

3834 , system-fileio, system-filepath, text, transformers

3835 , transformers-base, unix, unix-compat, vector, void

3836 }:

3837 mkDerivation {

3838 pname = "conduit-combinators";

3839 version = "0.3.0.6";

3840 sha256 = "0z2nzs89sw2wxrgvyd2bxyh9vs87r1g6rbjqiwcjvhjs25ppq22b";

3841 configureFlags = [

3842 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3843 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3844 "-fsplitbase" "-f-test-hlint"

3845 ];

3846 libraryHaskellDepends = [

3847 base base16-bytestring base64-bytestring bytestring chunked-data

3848 conduit conduit-extra monad-control mono-traversable mwc-random

3849 primitive resourcet system-fileio system-filepath text transformers

3850 transformers-base unix unix-compat vector void

3851 ];

3852 testHaskellDepends = [

3853 base base16-bytestring base64-bytestring bytestring chunked-data

3854 conduit containers directory hspec mono-traversable mtl mwc-random

3855 QuickCheck safe silently system-filepath text transformers vector

3856 ];

3857 homepage = "https://github.com/fpco/conduit-combinators";

3858 description = "Commonly used conduit functions, for both chunked and unchunked data";

3859 license = stdenv.lib.licenses.mit;

3860 }) {};

3861 "conduit-extra" = callPackage

3862 ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring

3863 , bytestring-builder, conduit, criterion, directory, exceptions

3864 , filepath, hspec, monad-control, network, primitive, process

3865 , resourcet, stm, streaming-commons, text, transformers

3866 , transformers-base

3867 }:

3868 mkDerivation {

3869 pname = "conduit-extra";

3870 version = "1.1.7.1";

3871 sha256 = "1qpqjcqy44l92s21aivd2gvb7zz574102mld19a44w0n3yxvljx3";

3872 revision = "1";

3873 editedCabalFile = "0x56lx79ysbpy5lb4jziqw76176s37wprnxmqzvbl6bryfq9n065";

3874 configureFlags = [

3875 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3876 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3877 "-fsplitbase" "-f-test-hlint"

3878 ];

3879 libraryHaskellDepends = [

3880 attoparsec base blaze-builder bytestring conduit directory filepath

3881 monad-control network primitive process resourcet stm

3882 streaming-commons text transformers transformers-base

3883 ];

3884 testHaskellDepends = [

3885 async attoparsec base blaze-builder bytestring bytestring-builder

3886 conduit exceptions hspec process resourcet stm streaming-commons

3887 text transformers transformers-base

3888 ];

3889 benchmarkHaskellDepends = [

3890 base blaze-builder bytestring bytestring-builder conduit criterion

3891 transformers

3892 ];

3893 homepage = "http://github.com/snoyberg/conduit";

3894 description = "Batteries included conduit: adapters for common libraries";

3895 license = stdenv.lib.licenses.mit;

3896 }) {};

3897 "configurator" = callPackage

3898 ({ mkDerivation, attoparsec, base, bytestring, directory, filepath

3899 , hashable, HUnit, test-framework, test-framework-hunit, text

3900 , unix-compat, unordered-containers

3901 }:

3902 mkDerivation {

3903 pname = "configurator";

3904 version = "0.3.0.0";

3905 sha256 = "1d1iq1knwiq6ia5g64rw5hqm6dakz912qj13r89737rfcxmrkfbf";

3906 configureFlags = [

3907 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3908 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3909 "-fsplitbase" "-f-test-hlint"

3910 ];

3911 enableSeparateDataOutput = true;

3912 libraryHaskellDepends = [

3913 attoparsec base bytestring directory hashable text unix-compat

3914 unordered-containers

3915 ];

3916 testHaskellDepends = [

3917 base bytestring directory filepath HUnit test-framework

3918 test-framework-hunit text

3919 ];

3920 homepage = "http://github.com/bos/configurator";

3921 description = "Configuration management";

3922 license = stdenv.lib.licenses.bsd3;

3923 }) {};

3924 "connection" = callPackage

3925 ({ mkDerivation, base, byteable, bytestring, containers

3926 , crypto-random, data-default-class, network, securemem, socks, tls

3927 , x509, x509-store, x509-system, x509-validation

3928 }:

3929 mkDerivation {

3930 pname = "connection";

3931 version = "0.2.4";

3932 sha256 = "0sl0vxn02bbyk7lcclr7ml93wpap2f042da3c9v9ppvbvs8jmf7j";

3933 revision = "1";

3934 editedCabalFile = "0p47frbczm75ycim2qiygkx9dmfx5pvc4jsdh1qfgyvpv24syf8h";

3935 configureFlags = [

3936 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3937 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3938 "-fsplitbase" "-f-test-hlint"

3939 ];

3940 libraryHaskellDepends = [

3941 base byteable bytestring containers crypto-random

3942 data-default-class network securemem socks tls x509 x509-store

3943 x509-system x509-validation

3944 ];

3945 homepage = "http://github.com/vincenthz/hs-connection";

3946 description = "Simple and easy network connections API";

3947 license = stdenv.lib.licenses.bsd3;

3948 }) {};

3949 "constraints" = callPackage

3950 ({ mkDerivation, base, ghc-prim, newtype }:

3951 mkDerivation {

3952 pname = "constraints";

3953 version = "0.4.1.3";

3954 sha256 = "1w3ssvg30rfkp1y20vx0fbq1c0md2wys2rh50mih7645djv56hyx";

3955 revision = "1";

3956 editedCabalFile = "0n9l48c6dwm8yfcya9vxqgrdxzvv20jnccg0dp9kfvxmqgpsq147";

3957 configureFlags = [

3958 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3959 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3960 "-fsplitbase" "-f-test-hlint"

3961 ];

3962 libraryHaskellDepends = [ base ghc-prim newtype ];

3963 homepage = "http://github.com/ekmett/constraints/";

3964 description = "Constraint manipulation";

3965 license = stdenv.lib.licenses.bsd3;

3966 }) {};

3967 "containers-unicode-symbols" = callPackage

3968 ({ mkDerivation, base, base-unicode-symbols, containers }:

3969 mkDerivation {

3970 pname = "containers-unicode-symbols";

3971 version = "0.3.1.1";

3972 sha256 = "0ccv7rqkykfk5wmr73mc0kwrnwyzakgp5x495dgwn5nila3g4ma6";

3973 configureFlags = [

3974 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3975 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3976 "-fsplitbase" "-f-test-hlint"

3977 ];

3978 libraryHaskellDepends = [ base base-unicode-symbols containers ];

3979 homepage = "http://haskell.org/haskellwiki/Unicode-symbols";

3980 description = "Unicode alternatives for common functions and operators";

3981 license = stdenv.lib.licenses.bsd3;

3982 }) {};

3983 "contravariant" = callPackage

3984 ({ mkDerivation, base, foreign-var, semigroups, transformers

3985 , transformers-compat, void

3986 }:

3987 mkDerivation {

3988 pname = "contravariant";

3989 version = "1.2.2.1";

3990 sha256 = "0w1kgx85wbf96f1hr50b6nh9pqjbqbn4axfd419b38xy09j61j75";

3991 configureFlags = [

3992 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

3993 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

3994 "-fsplitbase" "-f-test-hlint"

3995 ];

3996 libraryHaskellDepends = [

3997 base foreign-var semigroups transformers transformers-compat void

3998 ];

3999 homepage = "http://github.com/ekmett/contravariant/";

4000 description = "Contravariant functors";

4001 license = stdenv.lib.licenses.bsd3;

4002 }) {};

4003 "control-monad-free" = callPackage

4004 ({ mkDerivation, base, deepseq, transformers }:

4005 mkDerivation {

4006 pname = "control-monad-free";

4007 version = "0.5.3";

4008 sha256 = "1igwawcdpg8irayjax1xdrlpa9587k1v4y28ib3xfb7yk0xv7vk1";

4009 configureFlags = [

4010 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4011 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4012 "-fsplitbase" "-f-test-hlint"

4013 ];

4014 libraryHaskellDepends = [ base deepseq transformers ];

4015 homepage = "http://github.com/pepeiborra/control-monad-free";

4016 description = "Free monads and monad transformers";

4017 license = stdenv.lib.licenses.publicDomain;

4018 }) {};

4019 "control-monad-loop" = callPackage

4020 ({ mkDerivation, base, transformers, transformers-base }:

4021 mkDerivation {

4022 pname = "control-monad-loop";

4023 version = "0.1";

4024 sha256 = "003k4pp6wgn30m9ksbh8680f0klzsvd90wsl9jpqs9lpg14hi6zj";

4025 configureFlags = [

4026 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4027 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4028 "-fsplitbase" "-f-test-hlint"

4029 ];

4030 libraryHaskellDepends = [ base transformers transformers-base ];

4031 homepage = "https://github.com/joeyadams/haskell-control-monad-loop";

4032 description = "Simple monad transformer for imperative-style loops";

4033 license = stdenv.lib.licenses.bsd3;

4034 }) {};

4035 "convertible" = callPackage

4036 ({ mkDerivation, base, bytestring, containers, mtl, old-locale

4037 , old-time, text, time

4038 }:

4039 mkDerivation {

4040 pname = "convertible";

4041 version = "1.1.0.0";

4042 sha256 = "0pc3z4jfjna1rz5wlfimw9fyhpasmdnwvava883s401760y99i0k";

4043 revision = "3";

4044 editedCabalFile = "1yh1fik10pkfr1dn4b95i1az676f2fz9lqm1qg16bqzwg4gbqn4r";

4045 configureFlags = [

4046 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4047 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4048 "-fsplitbase" "-f-test-hlint"

4049 ];

4050 isLibrary = true;

4051 isExecutable = true;

4052 libraryHaskellDepends = [

4053 base bytestring containers mtl old-locale old-time text time

4054 ];

4055 homepage = "http://hackage.haskell.org/cgi-bin/hackage-scripts/package/convertible";

4056 description = "Typeclasses and instances for converting between types";

4057 license = stdenv.lib.licenses.bsd3;

4058 }) {};

4059 "cookie" = callPackage

4060 ({ mkDerivation, base, blaze-builder, bytestring, data-default

4061 , deepseq, HUnit, old-locale, QuickCheck, tasty, tasty-hunit

4062 , tasty-quickcheck, text, time

4063 }:

4064 mkDerivation {

4065 pname = "cookie";

4066 version = "0.4.1.4";

4067 sha256 = "0axvljw34cjw47fxwxqql8rvjsyp9gxfbaijmysy5j10kx8s931d";

4068 revision = "2";

4069 editedCabalFile = "0rfph7jfqlvkckf7xz71cf6idziwv5i664gb9cq62l9qx7qwmpc5";

4070 configureFlags = [

4071 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4072 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4073 "-fsplitbase" "-f-test-hlint"

4074 ];

4075 libraryHaskellDepends = [

4076 base blaze-builder bytestring data-default deepseq old-locale text

4077 time

4078 ];

4079 testHaskellDepends = [

4080 base blaze-builder bytestring HUnit QuickCheck tasty tasty-hunit

4081 tasty-quickcheck text time

4082 ];

4083 homepage = "http://github.com/snoyberg/cookie";

4084 description = "HTTP cookie parsing and rendering";

4085 license = stdenv.lib.licenses.bsd3;

4086 }) {};

4087 "courier" = callPackage

4088 ({ mkDerivation, async, base, bytestring, cereal, containers

4089 , directory, hslogger, HUnit, network, stm, test-framework

4090 , test-framework-hunit, text, uuid

4091 }:

4092 mkDerivation {

4093 pname = "courier";

4094 version = "0.1.0.15";

4095 sha256 = "1aj9anrw7jfqx8s2xkdznqs212f54g6i2lcf79bgnkmxsbax252v";

4096 configureFlags = [

4097 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4098 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4099 "-fsplitbase" "-f-test-hlint"

4100 ];

4101 libraryHaskellDepends = [

4102 async base bytestring cereal containers hslogger network stm text

4103 uuid

4104 ];

4105 testHaskellDepends = [

4106 async base cereal containers directory hslogger HUnit network stm

4107 test-framework test-framework-hunit

4108 ];

4109 homepage = "http://github.com/hargettp/courier";

4110 description = "A message-passing library for simplifying network applications";

4111 license = stdenv.lib.licenses.mit;

4112 }) {};

4113 "cpphs" = callPackage

4114 ({ mkDerivation, base, directory, old-locale, old-time, polyparse

4115 }:

4116 mkDerivation {

4117 pname = "cpphs";

4118 version = "1.18.9";

4119 sha256 = "0bf9p5izkag6iqlpf59znsv8107hg1xghgas4crw2gxai1z7bfq6";

4120 configureFlags = [

4121 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4122 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4123 "-fsplitbase" "-f-test-hlint"

4124 ];

4125 isLibrary = true;

4126 isExecutable = true;

4127 libraryHaskellDepends = [

4128 base directory old-locale old-time polyparse

4129 ];

4130 executableHaskellDepends = [

4131 base directory old-locale old-time polyparse

4132 ];

4133 homepage = "http://projects.haskell.org/cpphs/";

4134 description = "A liberalised re-implementation of cpp, the C pre-processor";

4135 license = "LGPL";

4136 }) {};

4137 "cprng-aes" = callPackage

4138 ({ mkDerivation, base, byteable, bytestring, cipher-aes, criterion

4139 , crypto-random, mtl

4140 }:

4141 mkDerivation {

4142 pname = "cprng-aes";

4143 version = "0.6.1";

4144 sha256 = "1wr15kbmk1g3l8a75n0iwbzqg24ixv78slwzwb2q6rlcvq0jlnb4";

4145 configureFlags = [

4146 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4147 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4148 "-fsplitbase" "-f-test-hlint"

4149 ];

4150 enableSeparateDataOutput = true;

4151 libraryHaskellDepends = [

4152 base byteable bytestring cipher-aes crypto-random

4153 ];

4154 benchmarkHaskellDepends = [

4155 base bytestring criterion crypto-random mtl

4156 ];

4157 homepage = "http://github.com/vincenthz/hs-cprng-aes";

4158 description = "Crypto Pseudo Random Number Generator using AES in counter mode";

4159 license = stdenv.lib.licenses.bsd3;

4160 }) {};

4161 "cpu" = callPackage

4162 ({ mkDerivation, base }:

4163 mkDerivation {

4164 pname = "cpu";

4165 version = "0.1.2";

4166 sha256 = "0x19mlanmkg96h6h1i04w2i631z84y4rbk22ki4zhgsajysgw9sn";

4167 configureFlags = [

4168 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4169 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4170 "-fsplitbase" "-f-test-hlint"

4171 ];

4172 isLibrary = true;

4173 isExecutable = true;

4174 enableSeparateDataOutput = true;

4175 libraryHaskellDepends = [ base ];

4176 homepage = "http://github.com/vincenthz/hs-cpu";

4177 description = "Cpu information and properties helpers";

4178 license = stdenv.lib.licenses.bsd3;

4179 }) {};

4180 "criterion" = callPackage

4181 ({ mkDerivation, aeson, ansi-wl-pprint, base, binary, bytestring

4182 , cassava, containers, deepseq, directory, either, filepath, Glob

4183 , hastache, HUnit, mtl, mwc-random, optparse-applicative, parsec

4184 , QuickCheck, statistics, test-framework, test-framework-hunit

4185 , test-framework-quickcheck2, text, time, transformers, vector

4186 , vector-algorithms

4187 }:

4188 mkDerivation {

4189 pname = "criterion";

4190 version = "1.0.2.0";

4191 sha256 = "02mcb49hiv0gijj5343gffdd3r8hjf4d52llv2gradaijz4zdqhx";

4192 revision = "2";

4193 editedCabalFile = "1g4vp91vm06bnyiv65qqzizgnvz8c3980675jr7l7747cwv2k6hb";

4194 configureFlags = [

4195 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4196 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4197 "-fsplitbase" "-f-test-hlint"

4198 ];

4199 isLibrary = true;

4200 isExecutable = true;

4201 enableSeparateDataOutput = true;

4202 libraryHaskellDepends = [

4203 aeson ansi-wl-pprint base binary bytestring cassava containers

4204 deepseq directory either filepath Glob hastache mtl mwc-random

4205 optparse-applicative parsec statistics text time transformers

4206 vector vector-algorithms

4207 ];

4208 executableHaskellDepends = [ base ];

4209 testHaskellDepends = [

4210 base bytestring HUnit QuickCheck statistics test-framework

4211 test-framework-hunit test-framework-quickcheck2 vector

4212 ];

4213 homepage = "http://www.serpentine.com/criterion";

4214 description = "Robust, reliable performance measurement and analysis";

4215 license = stdenv.lib.licenses.bsd3;

4216 }) {};

4217 "crypto-api" = callPackage

4218 ({ mkDerivation, base, bytestring, cereal, entropy, tagged

4219 , transformers

4220 }:

4221 mkDerivation {

4222 pname = "crypto-api";

4223 version = "0.13.2";

4224 sha256 = "1vc27qcgbg7hf50rkqhlrs58zn1888ilh4b6wrrm07bnm48xacak";

4225 configureFlags = [

4226 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4227 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4228 "-fsplitbase" "-f-test-hlint"

4229 ];

4230 libraryHaskellDepends = [

4231 base bytestring cereal entropy tagged transformers

4232 ];

4233 homepage = "https://github.com/TomMD/crypto-api";

4234 description = "A generic interface for cryptographic operations";

4235 license = stdenv.lib.licenses.bsd3;

4236 }) {};

4237 "crypto-cipher-tests" = callPackage

4238 ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types

4239 , HUnit, mtl, QuickCheck, securemem, test-framework

4240 , test-framework-hunit, test-framework-quickcheck2

4241 }:

4242 mkDerivation {

4243 pname = "crypto-cipher-tests";

4244 version = "0.0.11";

4245 sha256 = "19wqignlq90qwpam01hnmmrxaxh5lkax9l1l6rlbi4a07nvp1dnz";

4246 configureFlags = [

4247 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4248 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4249 "-fsplitbase" "-f-test-hlint"

4250 ];

4251 libraryHaskellDepends = [

4252 base byteable bytestring crypto-cipher-types HUnit mtl QuickCheck

4253 securemem test-framework test-framework-hunit

4254 test-framework-quickcheck2

4255 ];

4256 testHaskellDepends = [

4257 base byteable bytestring crypto-cipher-types HUnit mtl QuickCheck

4258 test-framework test-framework-hunit test-framework-quickcheck2

4259 ];

4260 homepage = "http://github.com/vincenthz/hs-crypto-cipher";

4261 description = "Generic cryptography cipher tests";

4262 license = stdenv.lib.licenses.bsd3;

4263 }) {};

4264 "crypto-cipher-types" = callPackage

4265 ({ mkDerivation, base, byteable, bytestring, securemem }:

4266 mkDerivation {

4267 pname = "crypto-cipher-types";

4268 version = "0.0.9";

4269 sha256 = "03qa1i1kj07pfrxsi7fiaqnnd0vi94jd4jfswbmnm4gp1nvzcwr0";

4270 configureFlags = [

4271 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4272 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4273 "-fsplitbase" "-f-test-hlint"

4274 ];

4275 enableSeparateDataOutput = true;

4276 libraryHaskellDepends = [ base byteable bytestring securemem ];

4277 homepage = "http://github.com/vincenthz/hs-crypto-cipher";

4278 description = "Generic cryptography cipher types";

4279 license = stdenv.lib.licenses.bsd3;

4280 }) {};

4281 "crypto-numbers" = callPackage

4282 ({ mkDerivation, base, byteable, bytestring, criterion

4283 , crypto-random, ghc-prim, integer-gmp, mtl, tasty, tasty-hunit

4284 , tasty-quickcheck, vector

4285 }:

4286 mkDerivation {

4287 pname = "crypto-numbers";

4288 version = "0.2.7";

4289 sha256 = "19l9y5jzvqrqfam13xin9m9ca0s5ql86yv0cjn6dzkydx4byn2j2";

4290 revision = "1";

4291 editedCabalFile = "1jjkhid8kwrz5894nad537rqxzzyx6b687bmgyk70nv0ny336j9b";

4292 configureFlags = [

4293 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4294 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4295 "-fsplitbase" "-f-test-hlint"

4296 ];

4297 libraryHaskellDepends = [

4298 base bytestring crypto-random ghc-prim integer-gmp vector

4299 ];

4300 testHaskellDepends = [

4301 base byteable bytestring crypto-random tasty tasty-hunit

4302 tasty-quickcheck vector

4303 ];

4304 benchmarkHaskellDepends = [ base bytestring criterion mtl ];

4305 doCheck = false;

4306 homepage = "https://github.com/vincenthz/hs-crypto-numbers";

4307 description = "Cryptographic numbers: functions and algorithms";

4308 license = stdenv.lib.licenses.bsd3;

4309 }) {};

4310 "crypto-pubkey" = callPackage

4311 ({ mkDerivation, base, byteable, bytestring, criterion

4312 , crypto-numbers, crypto-pubkey-types, crypto-random, cryptohash

4313 , deepseq, mtl, tasty, tasty-hunit, tasty-kat, tasty-quickcheck

4314 }:

4315 mkDerivation {

4316 pname = "crypto-pubkey";

4317 version = "0.2.8";

4318 sha256 = "0vmmx2fqq2xc3xfavy22i2nyynpk88jhmjr62qgxw5w5qgsz5k60";

4319 configureFlags = [

4320 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4321 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4322 "-fsplitbase" "-f-test-hlint"

4323 ];

4324 libraryHaskellDepends = [

4325 base byteable bytestring crypto-numbers crypto-pubkey-types

4326 crypto-random cryptohash

4327 ];

4328 testHaskellDepends = [

4329 base byteable bytestring crypto-numbers crypto-pubkey-types

4330 crypto-random cryptohash tasty tasty-hunit tasty-kat

4331 tasty-quickcheck

4332 ];

4333 benchmarkHaskellDepends = [

4334 base bytestring criterion crypto-pubkey-types crypto-random

4335 cryptohash deepseq mtl

4336 ];

4337 doCheck = false;

4338 homepage = "https://github.com/vincenthz/hs-crypto-pubkey";

4339 description = "Public Key cryptography";

4340 license = stdenv.lib.licenses.bsd3;

4341 }) {};

4342 "crypto-pubkey-types" = callPackage

4343 ({ mkDerivation, asn1-encoding, asn1-types, base }:

4344 mkDerivation {

4345 pname = "crypto-pubkey-types";

4346 version = "0.4.3";

4347 sha256 = "0q0wlzjmpx536h1zcdzrpxjkvqw8abj8z0ci38138kpch4igbnby";

4348 configureFlags = [

4349 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4350 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4351 "-fsplitbase" "-f-test-hlint"

4352 ];

4353 libraryHaskellDepends = [ asn1-encoding asn1-types base ];

4354 homepage = "http://github.com/vincenthz/hs-crypto-pubkey-types";

4355 description = "Generic cryptography Public keys algorithm types";

4356 license = stdenv.lib.licenses.bsd3;

4357 }) {};

4358 "crypto-random" = callPackage

4359 ({ mkDerivation, base, bytestring, securemem, unix, vector }:

4360 mkDerivation {

4361 pname = "crypto-random";

4362 version = "0.0.9";

4363 sha256 = "0139kbbb2h7vshf68y3fvjda29lhj7jjwl4vq78w4y8k8hc7l2hp";

4364 configureFlags = [

4365 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4366 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4367 "-fsplitbase" "-f-test-hlint"

4368 ];

4369 libraryHaskellDepends = [ base bytestring securemem unix vector ];

4370 homepage = "http://github.com/vincenthz/hs-crypto-random";

4371 description = "Simple cryptographic random related types";

4372 license = stdenv.lib.licenses.bsd3;

4373 }) {};

4374 "crypto-random-api" = callPackage

4375 ({ mkDerivation, base, bytestring, entropy }:

4376 mkDerivation {

4377 pname = "crypto-random-api";

4378 version = "0.2.0";

4379 sha256 = "0z49kwgjj7rz235642q64hbkgp0zl6ipn29xd19yb75xc5q7gsan";

4380 configureFlags = [

4381 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4382 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4383 "-fsplitbase" "-f-test-hlint"

4384 ];

4385 libraryHaskellDepends = [ base bytestring entropy ];

4386 homepage = "http://github.com/vincenthz/hs-crypto-random-api";

4387 description = "Simple random generators API for cryptography related code";

4388 license = stdenv.lib.licenses.bsd3;

4389 }) {};

4390 "cryptocipher" = callPackage

4391 ({ mkDerivation, base, cipher-aes, cipher-blowfish, cipher-camellia

4392 , cipher-des, cipher-rc4, crypto-cipher-types

4393 }:

4394 mkDerivation {

4395 pname = "cryptocipher";

4396 version = "0.6.2";

4397 sha256 = "0ip3a2as0df6drl29sryayxx22sx55v6bs60s2fh3i1nxqnydf9l";

4398 configureFlags = [

4399 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4400 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4401 "-fsplitbase" "-f-test-hlint"

4402 ];

4403 libraryHaskellDepends = [

4404 base cipher-aes cipher-blowfish cipher-camellia cipher-des

4405 cipher-rc4 crypto-cipher-types

4406 ];

4407 homepage = "http://github.com/vincenthz/hs-crypto-cipher";

4408 description = "Symmetrical block and stream ciphers";

4409 license = stdenv.lib.licenses.bsd3;

4410 }) {};

4411 "cryptohash" = callPackage

4412 ({ mkDerivation, base, byteable, bytestring, criterion, ghc-prim

4413 , HUnit, QuickCheck, tasty, tasty-hunit, tasty-quickcheck

4414 }:

4415 mkDerivation {

4416 pname = "cryptohash";

4417 version = "0.11.6";

4418 sha256 = "0dyzcaxr8vhzqq9hj4240rxpi87h4ps87yz09klz723shls26f6s";

4419 configureFlags = [

4420 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4421 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4422 "-fsplitbase" "-f-test-hlint"

4423 ];

4424 libraryHaskellDepends = [ base byteable bytestring ghc-prim ];

4425 testHaskellDepends = [

4426 base byteable bytestring HUnit QuickCheck tasty tasty-hunit

4427 tasty-quickcheck

4428 ];

4429 benchmarkHaskellDepends = [ base byteable bytestring criterion ];

4430 homepage = "http://github.com/vincenthz/hs-cryptohash";

4431 description = "collection of crypto hashes, fast, pure and practical";

4432 license = stdenv.lib.licenses.bsd3;

4433 }) {};

4434 "cryptohash-conduit" = callPackage

4435 ({ mkDerivation, base, bytestring, conduit, conduit-extra

4436 , cryptohash, resourcet, transformers

4437 }:

4438 mkDerivation {

4439 pname = "cryptohash-conduit";

4440 version = "0.1.1";

4441 sha256 = "1kmlskgb0jx8hkzdncr24aqir9k1kyfcb2rypvkdld1yin4nslga";

4442 configureFlags = [

4443 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4444 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4445 "-fsplitbase" "-f-test-hlint"

4446 ];

4447 libraryHaskellDepends = [

4448 base bytestring conduit conduit-extra cryptohash resourcet

4449 transformers

4450 ];

4451 homepage = "http://github.com/vincenthz/hs-cryptohash-conduit";

4452 description = "cryptohash conduit";

4453 license = stdenv.lib.licenses.bsd3;

4454 }) {};

4455 "cryptohash-cryptoapi" = callPackage

4456 ({ mkDerivation, base, bytestring, cereal, crypto-api, cryptohash

4457 , tagged

4458 }:

4459 mkDerivation {

4460 pname = "cryptohash-cryptoapi";

4461 version = "0.1.3";

4462 sha256 = "0wj53p32js8lfg0i8akrljpash0jdiyv2vcqpmjbd4dq2fx81w2n";

4463 configureFlags = [

4464 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4465 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4466 "-fsplitbase" "-f-test-hlint"

4467 ];

4468 enableSeparateDataOutput = true;

4469 libraryHaskellDepends = [

4470 base bytestring cereal crypto-api cryptohash tagged

4471 ];

4472 homepage = "http://github.com/vincenthz/hs-cryptohash-cryptoapi";

4473 description = "Crypto-api interfaces for cryptohash";

4474 license = stdenv.lib.licenses.bsd3;

4475 }) {};

4476 "css-text" = callPackage

4477 ({ mkDerivation, attoparsec, base, hspec, QuickCheck, text }:

4478 mkDerivation {

4479 pname = "css-text";

4480 version = "0.1.2.1";

4481 sha256 = "1xi1n2f0g8y43p95lynhcg50wxbq7hqfzbfzm7fy8mn7gvd920nw";

4482 configureFlags = [

4483 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4484 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4485 "-fsplitbase" "-f-test-hlint"

4486 ];

4487 libraryHaskellDepends = [ attoparsec base text ];

4488 testHaskellDepends = [ attoparsec base hspec QuickCheck text ];

4489 homepage = "http://www.yesodweb.com/";

4490 description = "CSS parser and renderer";

4491 license = stdenv.lib.licenses.bsd3;

4492 }) {};

4493 "csv" = callPackage

4494 ({ mkDerivation, base, filepath, parsec }:

4495 mkDerivation {

4496 pname = "csv";

4497 version = "0.1.2";

4498 sha256 = "00767ai09wm7f0yzmpqck3cpgxncpr9djnmmz5l17ajz69139x4c";

4499 configureFlags = [

4500 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4501 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4502 "-fsplitbase" "-f-test-hlint"

4503 ];

4504 libraryHaskellDepends = [ base filepath parsec ];

4505 description = "CSV loader and dumper";

4506 license = stdenv.lib.licenses.mit;

4507 }) {};

4508 "csv-conduit" = callPackage

4509 ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring

4510 , conduit, conduit-extra, containers, data-default, directory

4511 , ghc-prim, HUnit, mmorph, monad-control, mtl, primitive, resourcet

4512 , test-framework, test-framework-hunit, text, transformers

4513 , unordered-containers, vector

4514 }:

4515 mkDerivation {

4516 pname = "csv-conduit";

4517 version = "0.6.6";

4518 sha256 = "12sxxv92qblsa63zdnl80a8yk01b4cvk9k6h58w82bvcy5m0aabk";

4519 configureFlags = [

4520 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4521 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4522 "-fsplitbase" "-f-test-hlint"

4523 ];

4524 isLibrary = true;

4525 isExecutable = true;

4526 libraryHaskellDepends = [

4527 array attoparsec base blaze-builder bytestring conduit

4528 conduit-extra containers data-default ghc-prim mmorph monad-control

4529 mtl primitive resourcet text transformers unordered-containers

4530 vector

4531 ];

4532 executableHaskellDepends = [

4533 base bytestring containers directory mtl primitive text

4534 transformers vector

4535 ];

4536 testHaskellDepends = [

4537 base bytestring containers directory HUnit mtl primitive

4538 test-framework test-framework-hunit text transformers vector

4539 ];

4540 homepage = "http://github.com/ozataman/csv-conduit";

4541 description = "A flexible, fast, conduit-based CSV parser library for Haskell";

4542 license = stdenv.lib.licenses.bsd3;

4543 }) {};

4544 "curl" = callPackage

4545 ({ mkDerivation, base, bytestring, containers, curl }:

4546 mkDerivation {

4547 pname = "curl";

4548 version = "1.3.8";

4549 sha256 = "0vj4hpaa30jz7c702xpsfvqaqdxz28zslsqnsfx6bf6dpwvck1wh";

4550 revision = "1";

4551 editedCabalFile = "02sq2bjw5igc2k9f9ssh58k2ivii2xsvk5r00ky3cxh8j61qy86q";

4552 configureFlags = [

4553 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4554 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4555 "-fsplitbase" "-f-test-hlint"

4556 ];

4557 libraryHaskellDepends = [ base bytestring containers ];

4558 librarySystemDepends = [ curl ];

4559 description = "Haskell binding to libcurl";

4560 license = stdenv.lib.licenses.bsd3;

4561 }) {inherit (pkgs) curl;};

4562 "data-accessor" = callPackage

4563 ({ mkDerivation, array, base, containers, transformers }:

4564 mkDerivation {

4565 pname = "data-accessor";

4566 version = "0.2.2.6";

4567 sha256 = "0668qgllmp2911ppsb0g9z95nq2x0h2cvzyyjlb6iwhnjzyyg7gf";

4568 configureFlags = [

4569 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4570 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4571 "-fsplitbase" "-f-test-hlint"

4572 ];

4573 libraryHaskellDepends = [ array base containers transformers ];

4574 homepage = "http://www.haskell.org/haskellwiki/Record_access";

4575 description = "Utilities for accessing and manipulating fields of records";

4576 license = stdenv.lib.licenses.bsd3;

4577 }) {};

4578 "data-accessor-mtl" = callPackage

4579 ({ mkDerivation, base, data-accessor, mtl }:

4580 mkDerivation {

4581 pname = "data-accessor-mtl";

4582 version = "0.2.0.4";

4583 sha256 = "1i8lk0vy04giixng5addgj740cbvwlc7g62qgrmhfip0w9k93kqh";

4584 configureFlags = [

4585 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4586 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4587 "-fsplitbase" "-f-test-hlint"

4588 ];

4589 libraryHaskellDepends = [ base data-accessor mtl ];

4590 homepage = "http://www.haskell.org/haskellwiki/Record_access";

4591 description = "Use Accessor to access state in mtl State monad class";

4592 license = stdenv.lib.licenses.bsd3;

4593 }) {};

4594 "data-binary-ieee754" = callPackage

4595 ({ mkDerivation, base, binary }:

4596 mkDerivation {

4597 pname = "data-binary-ieee754";

4598 version = "0.4.4";

4599 sha256 = "02nzg1barhqhpf4x26mpzvk7jd29nali033qy01adjplv2z5m5sr";

4600 configureFlags = [

4601 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4602 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4603 "-fsplitbase" "-f-test-hlint"

4604 ];

4605 libraryHaskellDepends = [ base binary ];

4606 homepage = "https://john-millikin.com/software/data-binary-ieee754/";

4607 description = "Parser/Serialiser for IEEE-754 floating-point values";

4608 license = stdenv.lib.licenses.mit;

4609 }) {};

4610 "data-default" = callPackage

4611 ({ mkDerivation, base, data-default-class

4612 , data-default-instances-base, data-default-instances-containers

4613 , data-default-instances-dlist, data-default-instances-old-locale

4614 }:

4615 mkDerivation {

4616 pname = "data-default";

4617 version = "0.5.3";

4618 sha256 = "0d1hm0l9kim3kszshr4msmgzizrzha48gz2kb7b61p7n3gs70m7c";

4619 configureFlags = [

4620 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4621 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4622 "-fsplitbase" "-f-test-hlint"

4623 ];

4624 libraryHaskellDepends = [

4625 base data-default-class data-default-instances-base

4626 data-default-instances-containers data-default-instances-dlist

4627 data-default-instances-old-locale

4628 ];

4629 description = "A class for types with a default value";

4630 license = stdenv.lib.licenses.bsd3;

4631 }) {};

4632 "data-default-class" = callPackage

4633 ({ mkDerivation, base }:

4634 mkDerivation {

4635 pname = "data-default-class";

4636 version = "0.0.1";

4637 sha256 = "0ccgr3jllinchqhw3lsn73ic6axk4196if5274rr1rghls0fxj5d";

4638 configureFlags = [

4639 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4640 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4641 "-fsplitbase" "-f-test-hlint"

4642 ];

4643 libraryHaskellDepends = [ base ];

4644 description = "A class for types with a default value";

4645 license = stdenv.lib.licenses.bsd3;

4646 }) {};

4647 "data-default-instances-base" = callPackage

4648 ({ mkDerivation, base, data-default-class }:

4649 mkDerivation {

4650 pname = "data-default-instances-base";

4651 version = "0.0.1";

4652 sha256 = "1832nq6by91f1iw73ycvkbgn8kpra83pvf2q61hy47xffh0zy4pb";

4653 configureFlags = [

4654 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4655 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4656 "-fsplitbase" "-f-test-hlint"

4657 ];

4658 libraryHaskellDepends = [ base data-default-class ];

4659 description = "Default instances for types in base";

4660 license = stdenv.lib.licenses.bsd3;

4661 }) {};

4662 "data-default-instances-containers" = callPackage

4663 ({ mkDerivation, base, containers, data-default-class }:

4664 mkDerivation {

4665 pname = "data-default-instances-containers";

4666 version = "0.0.1";

4667 sha256 = "06h8xka031w752a7cjlzghvr8adqbl95xj9z5zc1b62w02phfpm5";

4668 configureFlags = [

4669 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4670 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4671 "-fsplitbase" "-f-test-hlint"

4672 ];

4673 libraryHaskellDepends = [ base containers data-default-class ];

4674 description = "Default instances for types in containers";

4675 license = stdenv.lib.licenses.bsd3;

4676 }) {};

4677 "data-default-instances-dlist" = callPackage

4678 ({ mkDerivation, base, data-default-class, dlist }:

4679 mkDerivation {

4680 pname = "data-default-instances-dlist";

4681 version = "0.0.1";

4682 sha256 = "0narkdqiprhgayjiawrr4390h4rq4pl2pb6mvixbv2phrc8kfs3x";

4683 configureFlags = [

4684 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4685 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4686 "-fsplitbase" "-f-test-hlint"

4687 ];

4688 libraryHaskellDepends = [ base data-default-class dlist ];

4689 description = "Default instances for types in dlist";

4690 license = stdenv.lib.licenses.bsd3;

4691 }) {};

4692 "data-default-instances-old-locale" = callPackage

4693 ({ mkDerivation, base, data-default-class, old-locale }:

4694 mkDerivation {

4695 pname = "data-default-instances-old-locale";

4696 version = "0.0.1";

4697 sha256 = "00h81i5phib741yj517p8mbnc48myvfj8axzsw44k34m48lv1lv0";

4698 configureFlags = [

4699 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4700 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4701 "-fsplitbase" "-f-test-hlint"

4702 ];

4703 libraryHaskellDepends = [ base data-default-class old-locale ];

4704 description = "Default instances for types in old-locale";

4705 license = stdenv.lib.licenses.bsd3;

4706 }) {};

4707 "data-inttrie" = callPackage

4708 ({ mkDerivation, base }:

4709 mkDerivation {

4710 pname = "data-inttrie";

4711 version = "0.1.0";

4712 sha256 = "00kzf3cw0y0848cprmx3i7g70rmr92hhfzn60a2x98vb8f7y3814";

4713 configureFlags = [

4714 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4715 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4716 "-fsplitbase" "-f-test-hlint"

4717 ];

4718 libraryHaskellDepends = [ base ];

4719 homepage = "http://github.com/luqui/data-inttrie";

4720 description = "A lazy, infinite trie of integers";

4721 license = stdenv.lib.licenses.bsd3;

4722 }) {};

4723 "data-lens-light" = callPackage

4724 ({ mkDerivation, base, mtl, template-haskell }:

4725 mkDerivation {

4726 pname = "data-lens-light";

4727 version = "0.1.2.1";

4728 sha256 = "038vfzb4vxk1qb0246l2kgv9br37wg59wnlhzyjpn97lypwlf68w";

4729 configureFlags = [

4730 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4731 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4732 "-fsplitbase" "-f-test-hlint"

4733 ];

4734 libraryHaskellDepends = [ base mtl template-haskell ];

4735 homepage = "https://github.com/feuerbach/data-lens-light";

4736 description = "Simple lenses, minimum dependencies";

4737 license = stdenv.lib.licenses.mit;

4738 }) {};

4739 "data-memocombinators" = callPackage

4740 ({ mkDerivation, array, base, data-inttrie }:

4741 mkDerivation {

4742 pname = "data-memocombinators";

4743 version = "0.5.1";

4744 sha256 = "1mvfc1xri3kgkx5q7za01bqg1x3bfvbgcffw5vwl6jmq4hh1sd5l";

4745 configureFlags = [

4746 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4747 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4748 "-fsplitbase" "-f-test-hlint"

4749 ];

4750 libraryHaskellDepends = [ array base data-inttrie ];

4751 homepage = "http://github.com/luqui/data-memocombinators";

4752 description = "Combinators for building memo tables";

4753 license = stdenv.lib.licenses.bsd3;

4754 }) {};

4755 "data-reify" = callPackage

4756 ({ mkDerivation, base, containers }:

4757 mkDerivation {

4758 pname = "data-reify";

4759 version = "0.6";

4760 sha256 = "0mif89mpj5zvw8czc51mfj27jw2ipxd2awnm9q13s46k6s5pv6a7";

4761 revision = "1";

4762 editedCabalFile = "1h9kr0d9xmxf5y5hlygfnv8r7kvwibap6i7bjzr65zl7vczms630";

4763 configureFlags = [

4764 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4765 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4766 "-fsplitbase" "-f-test-hlint"

4767 ];

4768 isLibrary = true;

4769 isExecutable = true;

4770 libraryHaskellDepends = [ base containers ];

4771 executableHaskellDepends = [ base ];

4772 homepage = "http://www.ittc.ku.edu/csdl/fpg/Tools/IOReification";

4773 description = "Reify a recursive data structure into an explicit graph";

4774 license = stdenv.lib.licenses.bsd3;

4775 }) {};

4776 "deepseq-generics" = callPackage

4777 ({ mkDerivation, base, deepseq, ghc-prim, HUnit, test-framework

4778 , test-framework-hunit

4779 }:

4780 mkDerivation {

4781 pname = "deepseq-generics";

4782 version = "0.1.1.2";

4783 sha256 = "01pvigx8n9p8hwbzp2qiq6kzf7cxiam843jz2sjgliacmmp1v7l3";

4784 revision = "1";

4785 editedCabalFile = "1zf97hnh5djrg00ibjgq79hwcapvvivhrqlc9m87cy16x5zqcliz";

4786 configureFlags = [

4787 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4788 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4789 "-fsplitbase" "-f-test-hlint"

4790 ];

4791 libraryHaskellDepends = [ base deepseq ghc-prim ];

4792 testHaskellDepends = [

4793 base deepseq ghc-prim HUnit test-framework test-framework-hunit

4794 ];

4795 homepage = "https://github.com/hvr/deepseq-generics";

4796 description = "GHC.Generics-based Control.DeepSeq.rnf implementation";

4797 license = stdenv.lib.licenses.bsd3;

4798 }) {};

4799 "derive" = callPackage

4800 ({ mkDerivation, base, bytestring, containers, directory, filepath

4801 , haskell-src-exts, pretty, process, syb, template-haskell

4802 , transformers, uniplate

4803 }:

4804 mkDerivation {

4805 pname = "derive";

4806 version = "2.5.22";

4807 sha256 = "0g2grz9y23n8g4wwjinx5cc70aawswl84i3njgj6l1fl29fk1yf2";

4808 configureFlags = [

4809 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4810 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4811 "-fsplitbase" "-f-test-hlint"

4812 ];

4813 isLibrary = true;

4814 isExecutable = true;

4815 libraryHaskellDepends = [

4816 base bytestring containers directory filepath haskell-src-exts

4817 pretty process syb template-haskell transformers uniplate

4818 ];

4819 homepage = "https://github.com/ndmitchell/derive#readme";

4820 description = "A program and library to derive instances for data types";

4821 license = stdenv.lib.licenses.bsd3;

4822 }) {};

4823 "diagrams" = callPackage

4824 ({ mkDerivation, diagrams-contrib, diagrams-core, diagrams-lib

4825 , diagrams-svg

4826 }:

4827 mkDerivation {

4828 pname = "diagrams";

4829 version = "1.2";

4830 sha256 = "17j7hyd86h9msc8ni19agb0yhixga76q9kh4i109iyiyqizdnfhg";

4831 configureFlags = [

4832 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4833 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4834 "-fsplitbase" "-f-test-hlint"

4835 ];

4836 libraryHaskellDepends = [

4837 diagrams-contrib diagrams-core diagrams-lib diagrams-svg

4838 ];

4839 doHaddock = false;

4840 homepage = "http://projects.haskell.org/diagrams";

4841 description = "Embedded domain-specific language for declarative vector graphics";

4842 license = stdenv.lib.licenses.bsd3;

4843 }) {};

4844 "diagrams-builder" = callPackage

4845 ({ mkDerivation, base, cmdargs, diagrams-lib, directory, exceptions

4846 , filepath, hashable, haskell-src-exts, hint, lens, mtl, split

4847 , transformers

4848 }:

4849 mkDerivation {

4850 pname = "diagrams-builder";

4851 version = "0.6.0.3";

4852 sha256 = "1wcdn6hgacn0lmz7ivgz08fg02fscrbf0zz8785yq5mcssyq0r70";

4853 configureFlags = [

4854 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4855 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4856 "-fsplitbase" "-f-test-hlint"

4857 ];

4858 isLibrary = true;

4859 isExecutable = true;

4860 libraryHaskellDepends = [

4861 base cmdargs diagrams-lib directory exceptions filepath hashable

4862 haskell-src-exts hint lens mtl split transformers

4863 ];

4864 homepage = "http://projects.haskell.org/diagrams";

4865 description = "hint-based build service for the diagrams graphics EDSL";

4866 license = stdenv.lib.licenses.bsd3;

4867 }) {};

4868 "diagrams-cairo" = callPackage

4869 ({ mkDerivation, base, bytestring, cairo, colour, containers

4870 , data-default-class, diagrams-core, diagrams-lib, directory

4871 , filepath, hashable, JuicyPixels, lens, mtl, old-time

4872 , optparse-applicative, pango, process, split, statestack, time

4873 , transformers, unix, vector

4874 }:

4875 mkDerivation {

4876 pname = "diagrams-cairo";

4877 version = "1.2.0.6";

4878 sha256 = "058sg89a3jlcr83azjkv7c9g1ylmkpnspyzflwrb3vwzz6glhh0a";

4879 configureFlags = [

4880 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4881 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4882 "-fsplitbase" "-f-test-hlint"

4883 ];

4884 libraryHaskellDepends = [

4885 base bytestring cairo colour containers data-default-class

4886 diagrams-core diagrams-lib directory filepath hashable JuicyPixels

4887 lens mtl old-time optparse-applicative pango process split

4888 statestack time transformers unix vector

4889 ];

4890 homepage = "http://projects.haskell.org/diagrams";

4891 description = "Cairo backend for diagrams drawing EDSL";

4892 license = stdenv.lib.licenses.bsd3;

4893 }) {};

4894 "diagrams-contrib" = callPackage

4895 ({ mkDerivation, arithmoi, base, circle-packing, colour, containers

4896 , data-default, data-default-class, diagrams-core, diagrams-lib

4897 , force-layout, HUnit, lens, MonadRandom, mtl, parsec, QuickCheck

4898 , semigroups, split, test-framework, test-framework-hunit

4899 , test-framework-quickcheck2, text, vector-space

4900 , vector-space-points

4901 }:

4902 mkDerivation {

4903 pname = "diagrams-contrib";

4904 version = "1.1.2.5";

4905 sha256 = "1d7f9jjmfamqg9v6yrr23xw9qq55kk6n8wr51af7rjz09l3fgb3q";

4906 configureFlags = [

4907 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4908 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4909 "-fsplitbase" "-f-test-hlint"

4910 ];

4911 libraryHaskellDepends = [

4912 arithmoi base circle-packing colour containers data-default

4913 data-default-class diagrams-core diagrams-lib force-layout lens

4914 MonadRandom mtl parsec semigroups split text vector-space

4915 vector-space-points

4916 ];

4917 testHaskellDepends = [

4918 base containers diagrams-lib HUnit QuickCheck test-framework

4919 test-framework-hunit test-framework-quickcheck2

4920 ];

4921 homepage = "http://projects.haskell.org/diagrams/";

4922 description = "Collection of user contributions to diagrams EDSL";

4923 license = stdenv.lib.licenses.bsd3;

4924 }) {};

4925 "diagrams-core" = callPackage

4926 ({ mkDerivation, base, containers, dual-tree, lens, MemoTrie

4927 , monoid-extras, newtype, semigroups, vector-space

4928 , vector-space-points

4929 }:

4930 mkDerivation {

4931 pname = "diagrams-core";

4932 version = "1.2.0.5";

4933 sha256 = "11h5k6r69b55lpl56265kqhcd66n0r6232il3cv8q30ad12azbcw";

4934 configureFlags = [

4935 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4936 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4937 "-fsplitbase" "-f-test-hlint"

4938 ];

4939 libraryHaskellDepends = [

4940 base containers dual-tree lens MemoTrie monoid-extras newtype

4941 semigroups vector-space vector-space-points

4942 ];

4943 homepage = "http://projects.haskell.org/diagrams";

4944 description = "Core libraries for diagrams EDSL";

4945 license = stdenv.lib.licenses.bsd3;

4946 }) {};

4947 "diagrams-haddock" = callPackage

4948 ({ mkDerivation, ansi-terminal, base, base64-bytestring, blaze-svg

4949 , bytestring, Cabal, cautious-file, cmdargs, containers, cpphs

4950 , diagrams-builder, diagrams-lib, diagrams-svg, directory, filepath

4951 , haskell-src-exts, lens, mtl, parsec, split, strict, text

4952 , uniplate, vector-space

4953 }:

4954 mkDerivation {

4955 pname = "diagrams-haddock";

4956 version = "0.2.2.13";

4957 sha256 = "0113598w5vqp7ywd1d074sjxyvj7l25jajnx55hvr32f9slz6zwh";

4958 configureFlags = [

4959 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4960 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4961 "-fsplitbase" "-f-test-hlint"

4962 ];

4963 isLibrary = true;

4964 isExecutable = true;

4965 libraryHaskellDepends = [

4966 ansi-terminal base base64-bytestring blaze-svg bytestring

4967 cautious-file containers cpphs diagrams-builder diagrams-lib

4968 diagrams-svg directory filepath haskell-src-exts lens mtl parsec

4969 split strict text uniplate vector-space

4970 ];

4971 executableHaskellDepends = [

4972 base Cabal cmdargs cpphs directory filepath

4973 ];

4974 doCheck = false;

4975 homepage = "http://projects.haskell.org/diagrams/";

4976 description = "Preprocessor for embedding diagrams in Haddock documentation";

4977 license = stdenv.lib.licenses.bsd3;

4978 }) {};

4979 "diagrams-lib" = callPackage

4980 ({ mkDerivation, active, array, base, colour, containers

4981 , data-default-class, diagrams-core, dual-tree, filepath

4982 , fingertree, hashable, intervals, JuicyPixels, lens, MemoTrie

4983 , monoid-extras, optparse-applicative, semigroups, tagged

4984 , vector-space, vector-space-points

4985 }:

4986 mkDerivation {

4987 pname = "diagrams-lib";

4988 version = "1.2.0.8";

4989 sha256 = "1g9z1ww2f2f6gq8q2aa362568632c5dnayhanx4vl2qdc7j1sz8f";

4990 configureFlags = [

4991 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

4992 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

4993 "-fsplitbase" "-f-test-hlint"

4994 ];

4995 libraryHaskellDepends = [

4996 active array base colour containers data-default-class

4997 diagrams-core dual-tree filepath fingertree hashable intervals

4998 JuicyPixels lens MemoTrie monoid-extras optparse-applicative

4999 semigroups tagged vector-space vector-space-points

5000 ];

5001 homepage = "http://projects.haskell.org/diagrams";

5002 description = "Embedded domain-specific language for declarative graphics";

5003 license = stdenv.lib.licenses.bsd3;

5004 }) {};

5005 "diagrams-postscript" = callPackage

5006 ({ mkDerivation, base, containers, data-default-class

5007 , diagrams-core, diagrams-lib, dlist, filepath, hashable, lens

5008 , monoid-extras, mtl, semigroups, split, vector-space

5009 }:

5010 mkDerivation {

5011 pname = "diagrams-postscript";

5012 version = "1.1.0.4";

5013 sha256 = "02a1b68b25id7g70gcq508miibp3wxljxza9zh6g7ad44as8yy5q";

5014 configureFlags = [

5015 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5016 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5017 "-fsplitbase" "-f-test-hlint"

5018 ];

5019 libraryHaskellDepends = [

5020 base containers data-default-class diagrams-core diagrams-lib dlist

5021 filepath hashable lens monoid-extras mtl semigroups split

5022 vector-space

5023 ];

5024 homepage = "http://projects.haskell.org/diagrams/";

5025 description = "Postscript backend for diagrams drawing EDSL";

5026 license = stdenv.lib.licenses.bsd3;

5027 }) {};

5028 "diagrams-svg" = callPackage

5029 ({ mkDerivation, base, base64-bytestring, blaze-markup, blaze-svg

5030 , bytestring, colour, containers, diagrams-core, diagrams-lib

5031 , directory, filepath, hashable, JuicyPixels, lens, monoid-extras

5032 , mtl, old-time, process, split, time, unix, vector-space

5033 }:

5034 mkDerivation {

5035 pname = "diagrams-svg";

5036 version = "1.1.0.4";

5037 sha256 = "11adbfvj5a8yzlbkqs433qgr7884n1vlff9vr6h9w1n0nc1amzpl";

5038 revision = "1";

5039 editedCabalFile = "0ccwh7fcdnvnmjxw015lqa8rp52avynmiqjaw0blvfmpic7mrlrg";

5040 configureFlags = [

5041 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5042 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5043 "-fsplitbase" "-f-test-hlint"

5044 ];

5045 libraryHaskellDepends = [

5046 base base64-bytestring blaze-markup blaze-svg bytestring colour

5047 containers diagrams-core diagrams-lib directory filepath hashable

5048 JuicyPixels lens monoid-extras mtl old-time process split time unix

5049 vector-space

5050 ];

5051 homepage = "http://projects.haskell.org/diagrams/";

5052 description = "SVG backend for diagrams drawing EDSL";

5053 license = stdenv.lib.licenses.bsd3;

5054 }) {};

5055 "digest" = callPackage

5056 ({ mkDerivation, base, bytestring, zlib }:

5057 mkDerivation {

5058 pname = "digest";

5059 version = "0.0.1.2";

5060 sha256 = "04gy2zp8yzvv7j9bdfvmfzcz3sqyqa6rwslqcn4vyair2vmif5v4";

5061 configureFlags = [

5062 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5063 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5064 "-fsplitbase" "-f-test-hlint"

5065 ];

5066 libraryHaskellDepends = [ base bytestring ];

5067 librarySystemDepends = [ zlib ];

5068 description = "Various cryptographic hashes for bytestrings; CRC32 and Adler32 for now";

5069 license = stdenv.lib.licenses.bsd3;

5070 }) {inherit (pkgs) zlib;};

5071 "digestive-functors" = callPackage

5072 ({ mkDerivation, base, bytestring, containers, HUnit, mtl

5073 , old-locale, QuickCheck, test-framework, test-framework-hunit

5074 , test-framework-quickcheck2, text, time

5075 }:

5076 mkDerivation {

5077 pname = "digestive-functors";

5078 version = "0.7.1.5";

5079 sha256 = "1rfdxac3cnwa5r5zxic3xhj4n59f7s6l34xmja4q87ylqxfyqmls";

5080 revision = "1";

5081 editedCabalFile = "02kpdxmsc0cpgpv9l7lqy652khvm1qal6ra0rq24cwha7jfkp6m3";

5082 configureFlags = [

5083 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5084 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5085 "-fsplitbase" "-f-test-hlint"

5086 ];

5087 libraryHaskellDepends = [

5088 base bytestring containers mtl old-locale text time

5089 ];

5090 testHaskellDepends = [

5091 base bytestring containers HUnit mtl old-locale QuickCheck

5092 test-framework test-framework-hunit test-framework-quickcheck2 text

5093 time

5094 ];

5095 homepage = "http://github.com/jaspervdj/digestive-functors";

5096 description = "A practical formlet library";

5097 license = stdenv.lib.licenses.bsd3;

5098 }) {};

5099 "dimensional" = callPackage

5100 ({ mkDerivation, base, numtype, time }:

5101 mkDerivation {

5102 pname = "dimensional";

5103 version = "0.13.0.1";

5104 sha256 = "1cn7gyskp0ax5lm5k05p6qp461hirjyhj0k1qyd64fgdmmp81vi6";

5105 configureFlags = [

5106 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5107 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5108 "-fsplitbase" "-f-test-hlint"

5109 ];

5110 libraryHaskellDepends = [ base numtype time ];

5111 homepage = "http://dimensional.googlecode.com/";

5112 description = "Statically checked physical dimensions";

5113 license = stdenv.lib.licenses.bsd3;

5114 }) {};

5115 "direct-sqlite" = callPackage

5116 ({ mkDerivation, base, base16-bytestring, bytestring, directory

5117 , HUnit, text

5118 }:

5119 mkDerivation {

5120 pname = "direct-sqlite";

5121 version = "2.3.15";

5122 sha256 = "0hlpc3j4crh9hnydcpp6fmiisq9ddn916bslm46x5q1ajvcw7v12";

5123 configureFlags = [

5124 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5125 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5126 "-fsplitbase" "-f-test-hlint"

5127 ];

5128 libraryHaskellDepends = [ base bytestring text ];

5129 testHaskellDepends = [

5130 base base16-bytestring bytestring directory HUnit text

5131 ];

5132 homepage = "https://github.com/IreneKnapp/direct-sqlite";

5133 description = "Low-level binding to SQLite3. Includes UTF8 and BLOB support.";

5134 license = stdenv.lib.licenses.bsd3;

5135 }) {};

5136 "directory-tree" = callPackage

5137 ({ mkDerivation, base, directory, filepath, process }:

5138 mkDerivation {

5139 pname = "directory-tree";

5140 version = "0.12.0";

5141 sha256 = "1idknm7fwci91fkwvzl35g0qd0jk1vb00ds2x82zjf2hdbkcc2gz";

5142 configureFlags = [

5143 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5144 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5145 "-fsplitbase" "-f-test-hlint"

5146 ];

5147 libraryHaskellDepends = [ base directory filepath ];

5148 testHaskellDepends = [ base directory filepath process ];

5149 homepage = "http://brandon.si/code/directory-tree-module-released/";

5150 description = "A simple directory-like tree datatype, with useful IO functions";

5151 license = stdenv.lib.licenses.bsd3;

5152 }) {};

5153 "distributed-process" = callPackage

5154 ({ mkDerivation, base, binary, bytestring, containers

5155 , data-accessor, deepseq, distributed-static, ghc-prim, hashable

5156 , mtl, network-transport, network-transport-tcp, old-locale, random

5157 , rank1dynamic, stm, syb, template-haskell, time, transformers

5158 }:

5159 mkDerivation {

5160 pname = "distributed-process";

5161 version = "0.5.3";

5162 sha256 = "1jp85dd7scizs03cslrbgmaly735l2rv9yl5hq573xj3mjwmv5nz";

5163 configureFlags = [

5164 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5165 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5166 "-fsplitbase" "-f-test-hlint"

5167 ];

5168 libraryHaskellDepends = [

5169 base binary bytestring containers data-accessor deepseq

5170 distributed-static ghc-prim hashable mtl network-transport

5171 old-locale random rank1dynamic stm syb template-haskell time

5172 transformers

5173 ];

5174 benchmarkHaskellDepends = [

5175 base binary bytestring network-transport-tcp

5176 ];

5177 doCheck = false;

5178 homepage = "http://haskell-distributed.github.com/";

5179 description = "Cloud Haskell: Erlang-style concurrency in Haskell";

5180 license = stdenv.lib.licenses.bsd3;

5181 }) {};

5182 "distributed-process-async" = callPackage

5183 ({ mkDerivation, base, binary, containers, data-accessor, deepseq

5184 , distributed-process, distributed-process-extras, fingertree

5185 , hashable, mtl, stm, time, transformers, unordered-containers

5186 }:

5187 mkDerivation {

5188 pname = "distributed-process-async";

5189 version = "0.2.1";

5190 sha256 = "0g28f2f5b28ra1gnm99yalah6rxqps4yvmi403nb0axw295pbmib";

5191 configureFlags = [

5192 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5193 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5194 "-fsplitbase" "-f-test-hlint"

5195 ];

5196 libraryHaskellDepends = [

5197 base binary containers data-accessor deepseq distributed-process

5198 distributed-process-extras fingertree hashable mtl stm time

5199 transformers unordered-containers

5200 ];

5201 doCheck = false;

5202 homepage = "http://github.com/haskell-distributed/distributed-process-async";

5203 description = "Cloud Haskell Async API";

5204 license = stdenv.lib.licenses.bsd3;

5205 }) {};

5206 "distributed-process-client-server" = callPackage

5207 ({ mkDerivation, base, binary, containers, data-accessor, deepseq

5208 , distributed-process, distributed-process-async

5209 , distributed-process-extras, fingertree, hashable, mtl, stm, time

5210 , transformers, unordered-containers

5211 }:

5212 mkDerivation {

5213 pname = "distributed-process-client-server";

5214 version = "0.1.2";

5215 sha256 = "0wr0fxdg9114jd180p4lrjkashqcyxv69harj1ww5jc8dxdb3k2s";

5216 configureFlags = [

5217 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5218 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5219 "-fsplitbase" "-f-test-hlint"

5220 ];

5221 libraryHaskellDepends = [

5222 base binary containers data-accessor deepseq distributed-process

5223 distributed-process-async distributed-process-extras fingertree

5224 hashable mtl stm time transformers unordered-containers

5225 ];

5226 doCheck = false;

5227 homepage = "http://github.com/haskell-distributed/distributed-process-client-server";

5228 description = "The Cloud Haskell Application Platform";

5229 license = stdenv.lib.licenses.bsd3;

5230 }) {};

5231 "distributed-process-execution" = callPackage

5232 ({ mkDerivation, ansi-terminal, base, binary, bytestring

5233 , containers, data-accessor, deepseq, distributed-process

5234 , distributed-process-client-server, distributed-process-extras

5235 , distributed-process-supervisor, distributed-static, fingertree

5236 , ghc-prim, hashable, HUnit, mtl, network, network-transport

5237 , network-transport-tcp, QuickCheck, rematch, stm, test-framework

5238 , test-framework-hunit, test-framework-quickcheck2, time

5239 , transformers, unordered-containers

5240 }:

5241 mkDerivation {

5242 pname = "distributed-process-execution";

5243 version = "0.1.1";

5244 sha256 = "1zm4mcicasf59s3zzca2m7hp4ialzmsmn6arjlz2mnrhcpbkg7ja";

5245 configureFlags = [

5246 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5247 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5248 "-fsplitbase" "-f-test-hlint"

5249 ];

5250 libraryHaskellDepends = [

5251 base binary containers data-accessor deepseq distributed-process

5252 distributed-process-client-server distributed-process-extras

5253 distributed-process-supervisor fingertree hashable mtl stm time

5254 transformers unordered-containers

5255 ];

5256 testHaskellDepends = [

5257 ansi-terminal base binary bytestring containers data-accessor

5258 deepseq distributed-process distributed-process-extras

5259 distributed-static fingertree ghc-prim hashable HUnit mtl network

5260 network-transport network-transport-tcp QuickCheck rematch stm

5261 test-framework test-framework-hunit test-framework-quickcheck2 time

5262 transformers unordered-containers

5263 ];

5264 homepage = "http://github.com/haskell-distributed/distributed-process-execution";

5265 description = "Execution Framework for The Cloud Haskell Application Platform";

5266 license = stdenv.lib.licenses.bsd3;

5267 }) {};

5268 "distributed-process-extras" = callPackage

5269 ({ mkDerivation, base, binary, containers, data-accessor, deepseq

5270 , distributed-process, fingertree, hashable, mtl, stm, time

5271 , transformers, unordered-containers

5272 }:

5273 mkDerivation {

5274 pname = "distributed-process-extras";

5275 version = "0.2.0";

5276 sha256 = "0l8k1h0nx2pign82ydyzsjbkc8qw3vhhbrdggzfwvr3hamnjpqly";

5277 configureFlags = [

5278 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5279 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5280 "-fsplitbase" "-f-test-hlint"

5281 ];

5282 libraryHaskellDepends = [

5283 base binary containers data-accessor deepseq distributed-process

5284 fingertree hashable mtl stm time transformers unordered-containers

5285 ];

5286 doCheck = false;

5287 homepage = "http://github.com/haskell-distributed/distributed-process-extras";

5288 description = "Cloud Haskell Extras";

5289 license = stdenv.lib.licenses.bsd3;

5290 }) {};

5291 "distributed-process-simplelocalnet" = callPackage

5292 ({ mkDerivation, base, binary, bytestring, containers

5293 , data-accessor, distributed-process, network, network-multicast

5294 , network-transport, network-transport-tcp, transformers

5295 }:

5296 mkDerivation {

5297 pname = "distributed-process-simplelocalnet";

5298 version = "0.2.2.0";

5299 sha256 = "024m5jycz257i34m2x97x3qyg76j1128ww61pql3fqy4mhvp3791";

5300 configureFlags = [

5301 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5302 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5303 "-fsplitbase" "-f-test-hlint"

5304 ];

5305 isLibrary = true;

5306 isExecutable = true;

5307 libraryHaskellDepends = [

5308 base binary bytestring containers data-accessor distributed-process

5309 network network-multicast network-transport network-transport-tcp

5310 transformers

5311 ];

5312 homepage = "http://haskell-distributed.github.com";

5313 description = "Simple zero-configuration backend for Cloud Haskell";

5314 license = stdenv.lib.licenses.bsd3;

5315 }) {};

5316 "distributed-process-supervisor" = callPackage

5317 ({ mkDerivation, ansi-terminal, base, binary, bytestring

5318 , containers, data-accessor, deepseq, distributed-process

5319 , distributed-process-client-server, distributed-process-extras

5320 , distributed-static, fingertree, ghc-prim, hashable, HUnit, mtl

5321 , network, network-transport, network-transport-tcp, rematch, stm

5322 , test-framework, test-framework-hunit, time, transformers

5323 , unordered-containers

5324 }:

5325 mkDerivation {

5326 pname = "distributed-process-supervisor";

5327 version = "0.1.2";

5328 sha256 = "1b2rskzjimb2s8xrz4iv4q3c10njjnycxy5bcy159m6hawz1hzj1";

5329 configureFlags = [

5330 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5331 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5332 "-fsplitbase" "-f-test-hlint"

5333 ];

5334 libraryHaskellDepends = [

5335 base binary containers data-accessor deepseq distributed-process

5336 distributed-process-client-server distributed-process-extras

5337 fingertree hashable mtl stm time transformers unordered-containers

5338 ];

5339 testHaskellDepends = [

5340 ansi-terminal base binary bytestring containers data-accessor

5341 deepseq distributed-process distributed-process-client-server

5342 distributed-process-extras distributed-static fingertree ghc-prim

5343 hashable HUnit mtl network network-transport network-transport-tcp

5344 rematch stm test-framework test-framework-hunit time transformers

5345 unordered-containers

5346 ];

5347 doCheck = false;

5348 homepage = "http://github.com/haskell-distributed/distributed-process-supervisor";

5349 description = "Supervisors for The Cloud Haskell Application Platform";

5350 license = stdenv.lib.licenses.bsd3;

5351 }) {};

5352 "distributed-process-task" = callPackage

5353 ({ mkDerivation, ansi-terminal, base, binary, bytestring

5354 , containers, data-accessor, deepseq, distributed-process

5355 , distributed-process-async, distributed-process-client-server

5356 , distributed-process-extras, distributed-static, fingertree

5357 , ghc-prim, hashable, HUnit, mtl, network, network-transport

5358 , network-transport-tcp, QuickCheck, rematch, stm, test-framework

5359 , test-framework-hunit, test-framework-quickcheck2, time

5360 , transformers, unordered-containers

5361 }:

5362 mkDerivation {

5363 pname = "distributed-process-task";

5364 version = "0.1.1";

5365 sha256 = "04w1nhca59i6bzmwfi80mryf5pcsn0zmswq3s3ksqc6wy4mfzy1m";

5366 configureFlags = [

5367 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5368 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5369 "-fsplitbase" "-f-test-hlint"

5370 ];

5371 libraryHaskellDepends = [

5372 base binary containers data-accessor deepseq distributed-process

5373 distributed-process-async distributed-process-client-server

5374 distributed-process-extras fingertree hashable mtl stm time

5375 transformers unordered-containers

5376 ];

5377 testHaskellDepends = [

5378 ansi-terminal base binary bytestring containers data-accessor

5379 deepseq distributed-process distributed-process-async

5380 distributed-process-client-server distributed-process-extras

5381 distributed-static fingertree ghc-prim hashable HUnit mtl network

5382 network-transport network-transport-tcp QuickCheck rematch stm

5383 test-framework test-framework-hunit test-framework-quickcheck2 time

5384 transformers unordered-containers

5385 ];

5386 doCheck = false;

5387 homepage = "http://github.com/haskell-distributed/distributed-process-task";

5388 description = "Task Framework for The Cloud Haskell Application Platform";

5389 license = stdenv.lib.licenses.bsd3;

5390 }) {};

5391 "distributed-static" = callPackage

5392 ({ mkDerivation, base, binary, bytestring, containers, rank1dynamic

5393 }:

5394 mkDerivation {

5395 pname = "distributed-static";

5396 version = "0.3.1.0";

5397 sha256 = "190b6vjcipgrvnfl72c0ssw8crza02gfw9kwyvwg043jcznihj08";

5398 configureFlags = [

5399 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5400 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5401 "-fsplitbase" "-f-test-hlint"

5402 ];

5403 libraryHaskellDepends = [

5404 base binary bytestring containers rank1dynamic

5405 ];

5406 homepage = "http://haskell-distributed.github.com";

5407 description = "Compositional, type-safe, polymorphic static values and closures";

5408 license = stdenv.lib.licenses.bsd3;

5409 }) {};

5410 "distributive" = callPackage

5411 ({ mkDerivation, base, directory, doctest, filepath, ghc-prim

5412 , tagged, transformers, transformers-compat

5413 }:

5414 mkDerivation {

5415 pname = "distributive";

5416 version = "0.4.4";

5417 sha256 = "0s2ln9jv7bh4ri2y31178pvjl8x6nik5d0klx7j2b77yjlsgblc2";

5418 configureFlags = [

5419 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5420 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5421 "-fsplitbase" "-f-test-hlint"

5422 ];

5423 libraryHaskellDepends = [

5424 base ghc-prim tagged transformers transformers-compat

5425 ];

5426 testHaskellDepends = [ base directory doctest filepath ];

5427 homepage = "http://github.com/ekmett/distributive/";

5428 description = "Distributive functors -- Dual to Traversable";

5429 license = stdenv.lib.licenses.bsd3;

5430 }) {};

5431 "djinn-ghc" = callPackage

5432 ({ mkDerivation, async, base, containers, djinn-lib, ghc, mtl

5433 , transformers

5434 }:

5435 mkDerivation {

5436 pname = "djinn-ghc";

5437 version = "0.0.2.3";

5438 sha256 = "190llfn8dvxkdan806nybn3d4psmnr1126zg8lmk8p5wd7nnm5fb";

5439 configureFlags = [

5440 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5441 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5442 "-fsplitbase" "-f-test-hlint"

5443 ];

5444 libraryHaskellDepends = [

5445 async base containers djinn-lib ghc mtl transformers

5446 ];

5447 description = "Generate Haskell code from a type. Bridge from Djinn to GHC API.";

5448 license = stdenv.lib.licenses.bsd3;

5449 }) {};

5450 "djinn-lib" = callPackage

5451 ({ mkDerivation, base, containers, mtl, pretty }:

5452 mkDerivation {

5453 pname = "djinn-lib";

5454 version = "0.0.1.2";

5455 sha256 = "048hs27awl4j9lg04qbnpf8c51mzbgy2afckis19zcswmavi1zn0";

5456 configureFlags = [

5457 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5458 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5459 "-fsplitbase" "-f-test-hlint"

5460 ];

5461 libraryHaskellDepends = [ base containers mtl pretty ];

5462 homepage = "http://www.augustsson.net/Darcs/Djinn/";

5463 description = "Generate Haskell code from a type. Library extracted from djinn package.";

5464 license = stdenv.lib.licenses.bsd3;

5465 }) {};

5466 "dlist" = callPackage

5467 ({ mkDerivation, base, Cabal, deepseq, QuickCheck }:

5468 mkDerivation {

5469 pname = "dlist";

5470 version = "0.7.1.1";

5471 sha256 = "1zayvxvkan2s2ixajdr3f5rn1gzhprzv6cww4cbpwjhzw0l7zc08";

5472 configureFlags = [

5473 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5474 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5475 "-fsplitbase" "-f-test-hlint"

5476 ];

5477 libraryHaskellDepends = [ base deepseq ];

5478 testHaskellDepends = [ base Cabal QuickCheck ];

5479 homepage = "https://github.com/spl/dlist";

5480 description = "Difference lists";

5481 license = stdenv.lib.licenses.bsd3;

5482 }) {};

5483 "dlist-instances" = callPackage

5484 ({ mkDerivation, base, dlist, semigroups }:

5485 mkDerivation {

5486 pname = "dlist-instances";

5487 version = "0.1";

5488 sha256 = "0r1j7djywqd7c224wc9ixkplj3m2mbf9k3ra7n92ja2kfpksm615";

5489 revision = "1";

5490 editedCabalFile = "0b3gxbs4ny2hhwmcqgvayiwflanwwidcmwv15s4mhii43s34pfi1";

5491 configureFlags = [

5492 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5493 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5494 "-fsplitbase" "-f-test-hlint"

5495 ];

5496 libraryHaskellDepends = [ base dlist semigroups ];

5497 homepage = "https://github.com/gregwebs/dlist-instances";

5498 description = "Difference lists instances";

5499 license = stdenv.lib.licenses.bsd3;

5500 }) {};

5501 "doctest" = callPackage

5502 ({ mkDerivation, base, base-compat, deepseq, directory, filepath

5503 , ghc, ghc-paths, hspec, HUnit, process, QuickCheck, setenv

5504 , silently, stringbuilder, syb, transformers

5505 }:

5506 mkDerivation {

5507 pname = "doctest";

5508 version = "0.9.13";

5509 sha256 = "0xl570ay5bw1rpd1aw59c092rnwjbp9qykh2rhpxyvl333p8mg00";

5510 revision = "1";

5511 editedCabalFile = "0zvgpspabmava362w8xxhc4xcm1wcpxwh58gjd1hp2na5vbbcajr";

5512 configureFlags = [

5513 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5514 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5515 "-fsplitbase" "-f-test-hlint"

5516 ];

5517 isLibrary = true;

5518 isExecutable = true;

5519 libraryHaskellDepends = [

5520 base deepseq directory filepath ghc ghc-paths process syb

5521 transformers

5522 ];

5523 executableHaskellDepends = [ base ];

5524 testHaskellDepends = [

5525 base base-compat deepseq directory filepath ghc ghc-paths hspec

5526 HUnit process QuickCheck setenv silently stringbuilder syb

5527 transformers

5528 ];

5529 homepage = "https://github.com/sol/doctest#readme";

5530 description = "Test interactive Haskell examples";

5531 license = stdenv.lib.licenses.mit;

5532 }) {};

5533 "double-conversion" = callPackage

5534 ({ mkDerivation, base, bytestring, ghc-prim, integer-gmp

5535 , test-framework, test-framework-quickcheck2, text

5536 }:

5537 mkDerivation {

5538 pname = "double-conversion";

5539 version = "2.0.1.0";

5540 sha256 = "034ji9jgf3jl0n5pp1nki3lsg173c3b9vniwnwp1q21iasqbawh0";

5541 configureFlags = [

5542 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5543 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5544 "-fsplitbase" "-f-test-hlint"

5545 ];

5546 libraryHaskellDepends = [

5547 base bytestring ghc-prim integer-gmp text

5548 ];

5549 testHaskellDepends = [

5550 base bytestring test-framework test-framework-quickcheck2 text

5551 ];

5552 homepage = "https://github.com/bos/double-conversion";

5553 description = "Fast conversion between double precision floating point and text";

5554 license = stdenv.lib.licenses.bsd3;

5555 }) {};

5556 "dual-tree" = callPackage

5557 ({ mkDerivation, base, monoid-extras, newtype, semigroups }:

5558 mkDerivation {

5559 pname = "dual-tree";

5560 version = "0.2.0.5";

5561 sha256 = "077njr9m6x9n2id0419rn6v4xwb9nvxshrmas9pkknp52va4ljg5";

5562 configureFlags = [

5563 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5564 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5565 "-fsplitbase" "-f-test-hlint"

5566 ];

5567 libraryHaskellDepends = [ base monoid-extras newtype semigroups ];

5568 description = "Rose trees with cached and accumulating monoidal annotations";

5569 license = stdenv.lib.licenses.bsd3;

5570 }) {};

5571 "easy-file" = callPackage

5572 ({ mkDerivation, base, directory, filepath, time, unix }:

5573 mkDerivation {

5574 pname = "easy-file";

5575 version = "0.2.0";

5576 sha256 = "0v8skixq15rvyiyky1dcrfl9jrzkbi75vai8np11xy2kg7a8ym2a";

5577 configureFlags = [

5578 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5579 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5580 "-fsplitbase" "-f-test-hlint"

5581 ];

5582 libraryHaskellDepends = [ base directory filepath time unix ];

5583 homepage = "http://github.com/kazu-yamamoto/easy-file";

5584 description = "Cross-platform File handling";

5585 license = stdenv.lib.licenses.bsd3;

5586 }) {};

5587 "either" = callPackage

5588 ({ mkDerivation, base, bifunctors, exceptions, free, monad-control

5589 , MonadRandom, mtl, profunctors, semigroupoids, semigroups

5590 , transformers, transformers-base

5591 }:

5592 mkDerivation {

5593 pname = "either";

5594 version = "4.3.3.2";

5595 sha256 = "05j4mk1qlp72w70cahfw4nm506sl0wmkgffi2f5xazwjgkggw595";

5596 configureFlags = [

5597 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5598 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5599 "-fsplitbase" "-f-test-hlint"

5600 ];

5601 libraryHaskellDepends = [

5602 base bifunctors exceptions free monad-control MonadRandom mtl

5603 profunctors semigroupoids semigroups transformers transformers-base

5604 ];

5605 homepage = "http://github.com/ekmett/either/";

5606 description = "An either monad transformer";

5607 license = stdenv.lib.licenses.bsd3;

5608 }) {};

5609 "elm-build-lib" = callPackage

5610 ({ mkDerivation, base, bytestring, containers, elm-compiler

5611 , elm-core-sources, file-embed, template-haskell

5612 }:

5613 mkDerivation {

5614 pname = "elm-build-lib";

5615 version = "0.14.0.0";

5616 sha256 = "12hhyjr3bshbz66zxl5jfs4s3qx6laqqwcim3kf8rj2vh12h6wj5";

5617 configureFlags = [

5618 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5619 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5620 "-fsplitbase" "-f-test-hlint"

5621 ];

5622 libraryHaskellDepends = [

5623 base bytestring containers elm-compiler elm-core-sources file-embed

5624 template-haskell

5625 ];

5626 homepage = "http://github.com/JoeyEremondi/elm-build-lib";

5627 description = "Compile Elm code to JS within Haskell";

5628 license = stdenv.lib.licenses.bsd3;

5629 }) {};

5630 "elm-compiler" = callPackage

5631 ({ mkDerivation, aeson, aeson-pretty, base, binary, blaze-html

5632 , blaze-markup, bytestring, cmdargs, containers, directory

5633 , filemanip, filepath, HUnit, indents, language-ecmascript

5634 , language-glsl, mtl, parsec, pretty, process, QuickCheck

5635 , test-framework, test-framework-hunit, test-framework-quickcheck2

5636 , text, transformers, union-find, unordered-containers

5637 }:

5638 mkDerivation {

5639 pname = "elm-compiler";

5640 version = "0.14.1";

5641 sha256 = "0my04mipgia5qw02nzzrzc4kq3vl7bv75rzrsmd2bdb2wll1k94f";

5642 configureFlags = [

5643 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5644 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5645 "-fsplitbase" "-f-test-hlint"

5646 ];

5647 isLibrary = true;

5648 isExecutable = true;

5649 libraryHaskellDepends = [

5650 aeson aeson-pretty base binary blaze-html blaze-markup bytestring

5651 cmdargs containers directory filepath indents language-ecmascript

5652 language-glsl mtl parsec pretty process text transformers

5653 union-find unordered-containers

5654 ];

5655 executableHaskellDepends = [

5656 aeson aeson-pretty base binary bytestring cmdargs containers

5657 directory filepath indents language-glsl mtl parsec pretty process

5658 text transformers union-find

5659 ];

5660 testHaskellDepends = [

5661 aeson aeson-pretty base binary blaze-html blaze-markup bytestring

5662 cmdargs containers directory filemanip filepath HUnit indents

5663 language-ecmascript language-glsl mtl parsec pretty process

5664 QuickCheck test-framework test-framework-hunit

5665 test-framework-quickcheck2 text transformers union-find

5666 unordered-containers

5667 ];

5668 homepage = "http://elm-lang.org";

5669 description = "Values to help with elm-package, elm-make, and elm-lang.org.";

5670 license = stdenv.lib.licenses.bsd3;

5671 }) {};

5672 "elm-core-sources" = callPackage

5673 ({ mkDerivation, base, bytestring, containers, file-embed

5674 , template-haskell

5675 }:

5676 mkDerivation {

5677 pname = "elm-core-sources";

5678 version = "1.0.0";

5679 sha256 = "1yr0csgz0hv25cz3jslap0adwvfcvv35bns32b9g0vyda1fm00x4";

5680 configureFlags = [

5681 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5682 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5683 "-fsplitbase" "-f-test-hlint"

5684 ];

5685 libraryHaskellDepends = [

5686 base bytestring containers file-embed template-haskell

5687 ];

5688 homepage = "http://github.com/JoeyEremondi/elm-build-lib";

5689 description = "Source files for the Elm runtime and standard libraries";

5690 license = stdenv.lib.licenses.bsd3;

5691 }) {};

5692 "elm-package" = callPackage

5693 ({ mkDerivation, aeson, aeson-pretty, ansi-wl-pprint, base, binary

5694 , bytestring, containers, directory, elm-compiler, filepath, HTTP

5695 , http-client, http-client-tls, http-types, mtl, network

5696 , optparse-applicative, pretty, process, text, time

5697 , unordered-containers, vector, zip-archive

5698 }:

5699 mkDerivation {

5700 pname = "elm-package";

5701 version = "0.2.2";

5702 sha256 = "0hkcy1mix2rng2k2zhzgb16nd0asfj9rm9ya2by67vjysiz8cmnr";

5703 configureFlags = [

5704 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5705 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5706 "-fsplitbase" "-f-test-hlint"

5707 ];

5708 isLibrary = true;

5709 isExecutable = true;

5710 libraryHaskellDepends = [

5711 aeson aeson-pretty base binary bytestring containers directory

5712 elm-compiler filepath HTTP http-client http-client-tls http-types

5713 mtl network process text time unordered-containers vector

5714 zip-archive

5715 ];

5716 executableHaskellDepends = [

5717 aeson aeson-pretty ansi-wl-pprint base binary bytestring containers

5718 directory elm-compiler filepath HTTP http-client http-client-tls

5719 http-types mtl network optparse-applicative pretty process text

5720 time unordered-containers vector zip-archive

5721 ];

5722 homepage = "http://github.com/elm-lang/elm-package";

5723 description = "Package manager for Elm libraries";

5724 license = stdenv.lib.licenses.bsd3;

5725 }) {};

5726 "email-validate" = callPackage

5727 ({ mkDerivation, attoparsec, base, bytestring, ghc-prim, HUnit

5728 , QuickCheck, test-framework, test-framework-hunit

5729 , test-framework-quickcheck2

5730 }:

5731 mkDerivation {

5732 pname = "email-validate";

5733 version = "2.0.1";

5734 sha256 = "1qxvcm8xiyz50ganzic8cm8nxswq361i80yi939y3n89dk067lzj";

5735 revision = "1";

5736 editedCabalFile = "1rr452gk6wq6p5kmcihr89g2xbgfz3f9758c2wn64js39lr1wymp";

5737 configureFlags = [

5738 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5739 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5740 "-fsplitbase" "-f-test-hlint"

5741 ];

5742 libraryHaskellDepends = [ attoparsec base bytestring ghc-prim ];

5743 testHaskellDepends = [

5744 base bytestring HUnit QuickCheck test-framework

5745 test-framework-hunit test-framework-quickcheck2

5746 ];

5747 homepage = "http://porg.es/blog/email-address-validation-simpler-faster-more-correct";

5748 description = "Validating an email address string against RFC 5322";

5749 license = stdenv.lib.licenses.bsd3;

5750 }) {};

5751 "enclosed-exceptions" = callPackage

5752 ({ mkDerivation, async, base, deepseq, hspec, lifted-base

5753 , monad-control, QuickCheck, transformers, transformers-base

5754 }:

5755 mkDerivation {

5756 pname = "enclosed-exceptions";

5757 version = "1.0.1.1";

5758 sha256 = "16ax1kqdsk4apg642qxkm2hf9vb5hzmkd14zmkxra8ssp8rn28z5";

5759 configureFlags = [

5760 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5761 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5762 "-fsplitbase" "-f-test-hlint"

5763 ];

5764 libraryHaskellDepends = [

5765 async base deepseq lifted-base monad-control transformers

5766 transformers-base

5767 ];

5768 testHaskellDepends = [

5769 async base deepseq hspec lifted-base monad-control QuickCheck

5770 transformers transformers-base

5771 ];

5772 homepage = "https://github.com/jcristovao/enclosed-exceptions";

5773 description = "Catching all exceptions from within an enclosed computation";

5774 license = stdenv.lib.licenses.mit;

5775 }) {};

5776 "entropy" = callPackage

5777 ({ mkDerivation, base, bytestring, unix }:

5778 mkDerivation {

5779 pname = "entropy";

5780 version = "0.3.6";

5781 sha256 = "1sfv930hvdmf018ngdl15jac2bgj75941w0ndlh78n1jgmf04jhn";

5782 configureFlags = [

5783 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5784 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5785 "-fsplitbase" "-f-test-hlint"

5786 ];

5787 libraryHaskellDepends = [ base bytestring unix ];

5788 homepage = "https://github.com/TomMD/entropy";

5789 description = "A platform independent entropy source";

5790 license = stdenv.lib.licenses.bsd3;

5791 }) {};

5792 "enumerator" = callPackage

5793 ({ mkDerivation, base, bytestring, containers, text, transformers

5794 }:

5795 mkDerivation {

5796 pname = "enumerator";

5797 version = "0.4.20";

5798 sha256 = "02a75dggj295zkhgjry5cb43s6y6ydpjb5w6vgl7kd9b6ma11qik";

5799 configureFlags = [

5800 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5801 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5802 "-fsplitbase" "-f-test-hlint"

5803 ];

5804 libraryHaskellDepends = [

5805 base bytestring containers text transformers

5806 ];

5807 homepage = "https://john-millikin.com/software/enumerator/";

5808 description = "Reliable, high-performance processing with left-fold enumerators";

5809 license = stdenv.lib.licenses.mit;

5810 }) {};

5811 "eq" = callPackage

5812 ({ mkDerivation, base, semigroupoids }:

5813 mkDerivation {

5814 pname = "eq";

5815 version = "4.0.3";

5816 sha256 = "1n2f20dh1rghv8c43dgdlpgamq61dy8dzh86v4p62a125pgawfn3";

5817 configureFlags = [

5818 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5819 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5820 "-fsplitbase" "-f-test-hlint"

5821 ];

5822 libraryHaskellDepends = [ base semigroupoids ];

5823 homepage = "http://github.com/ekmett/eq/";

5824 description = "Leibnizian equality";

5825 license = stdenv.lib.licenses.bsd3;

5826 }) {};

5827 "erf" = callPackage

5828 ({ mkDerivation, base }:

5829 mkDerivation {

5830 pname = "erf";

5831 version = "2.0.0.0";

5832 sha256 = "0dxk2r32ajmmc05vaxcp0yw6vgv4lkbmh8jcshncn98xgsfbgw14";

5833 configureFlags = [

5834 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5835 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5836 "-fsplitbase" "-f-test-hlint"

5837 ];

5838 libraryHaskellDepends = [ base ];

5839 description = "The error function, erf, and related functions";

5840 license = stdenv.lib.licenses.bsd3;

5841 }) {};

5842 "errorcall-eq-instance" = callPackage

5843 ({ mkDerivation, base, hspec, QuickCheck }:

5844 mkDerivation {

5845 pname = "errorcall-eq-instance";

5846 version = "0.1.0";

5847 sha256 = "1sr2wxbdqzpdawcivvd01nwpki0xbcxylz5qv95b96sq6b296gkk";

5848 configureFlags = [

5849 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5850 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5851 "-fsplitbase" "-f-test-hlint"

5852 ];

5853 libraryHaskellDepends = [ base ];

5854 testHaskellDepends = [ base hspec QuickCheck ];

5855 description = "An orphan Eq instance for ErrorCall";

5856 license = stdenv.lib.licenses.mit;

5857 }) {};

5858 "errors" = callPackage

5859 ({ mkDerivation, base, either, safe, transformers }:

5860 mkDerivation {

5861 pname = "errors";

5862 version = "1.4.7";

5863 sha256 = "09g53dylwsw1phxq5zhkbq8pnpwqzipvqclmcrdypzkpwkmfncl7";

5864 configureFlags = [

5865 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5866 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5867 "-fsplitbase" "-f-test-hlint"

5868 ];

5869 libraryHaskellDepends = [ base either safe transformers ];

5870 description = "Simplified error-handling";

5871 license = stdenv.lib.licenses.bsd3;

5872 }) {};

5873 "ersatz" = callPackage

5874 ({ mkDerivation, array, base, blaze-builder, blaze-textual

5875 , bytestring, containers, data-default, lens, mtl, parsec, process

5876 , temporary, transformers, unordered-containers

5877 }:

5878 mkDerivation {

5879 pname = "ersatz";

5880 version = "0.2.6.1";

5881 sha256 = "1hbn49ycc47f5zjf5zdgls23a8da389ma19g43bc379l8hm2xrjj";

5882 configureFlags = [

5883 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5884 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5885 "-fsplitbase" "-f-test-hlint"

5886 ];

5887 isLibrary = true;

5888 isExecutable = true;

5889 enableSeparateDataOutput = true;

5890 libraryHaskellDepends = [

5891 array base blaze-builder blaze-textual bytestring containers

5892 data-default lens mtl process temporary transformers

5893 unordered-containers

5894 ];

5895 executableHaskellDepends = [

5896 array base containers lens mtl parsec

5897 ];

5898 doCheck = false;

5899 homepage = "http://github.com/ekmett/ersatz";

5900 description = "A monad for expressing SAT or QSAT problems using observable sharing";

5901 license = stdenv.lib.licenses.bsd3;

5902 }) {};

5903 "esqueleto" = callPackage

5904 ({ mkDerivation, base, conduit, containers, hspec, HUnit

5905 , monad-control, monad-logger, persistent, persistent-sqlite

5906 , persistent-template, QuickCheck, resourcet, tagged, text

5907 , transformers, unordered-containers

5908 }:

5909 mkDerivation {

5910 pname = "esqueleto";

5911 version = "2.1.2.2";

5912 sha256 = "1sklvl3fl7sq64i5k5jrhc6xvfa4a1a6dfbnzl2alq65x73jzna6";

5913 configureFlags = [

5914 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5915 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5916 "-fsplitbase" "-f-test-hlint"

5917 ];

5918 libraryHaskellDepends = [

5919 base conduit monad-logger persistent resourcet tagged text

5920 transformers unordered-containers

5921 ];

5922 testHaskellDepends = [

5923 base conduit containers hspec HUnit monad-control monad-logger

5924 persistent persistent-sqlite persistent-template QuickCheck

5925 resourcet text transformers

5926 ];

5927 homepage = "https://github.com/prowdsponsor/esqueleto";

5928 description = "Type-safe EDSL for SQL queries on persistent backends";

5929 license = stdenv.lib.licenses.bsd3;

5930 }) {};

5931 "exception-transformers" = callPackage

5932 ({ mkDerivation, base, HUnit, stm, test-framework

5933 , test-framework-hunit, transformers

5934 }:

5935 mkDerivation {

5936 pname = "exception-transformers";

5937 version = "0.3.0.4";

5938 sha256 = "1m4mwgzynymdjvrrrvl90q468pgwik07yy2lsff9spxhcd43w2ra";

5939 configureFlags = [

5940 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5941 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5942 "-fsplitbase" "-f-test-hlint"

5943 ];

5944 libraryHaskellDepends = [ base stm transformers ];

5945 testHaskellDepends = [

5946 base HUnit test-framework test-framework-hunit transformers

5947 ];

5948 homepage = "http://www.cs.drexel.edu/~mainland/";

5949 description = "Type classes and monads for unchecked extensible exceptions";

5950 license = stdenv.lib.licenses.bsd3;

5951 }) {};

5952 "exceptions" = callPackage

5953 ({ mkDerivation, base, mtl, QuickCheck, test-framework

5954 , test-framework-quickcheck2, transformers

5955 }:

5956 mkDerivation {

5957 pname = "exceptions";

5958 version = "0.6.1";

5959 sha256 = "09jv5jskv48fd5la1pdvafwc9j2jxj1ncf6yxzkwcjddynbkyszm";

5960 revision = "1";

5961 editedCabalFile = "1mn959298hryf3kl3lp7jrp23x7vhffrihhgbr23lq1silq40sp8";

5962 configureFlags = [

5963 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5964 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5965 "-fsplitbase" "-f-test-hlint"

5966 ];

5967 libraryHaskellDepends = [ base mtl transformers ];

5968 testHaskellDepends = [

5969 base mtl QuickCheck test-framework test-framework-quickcheck2

5970 transformers

5971 ];

5972 homepage = "http://github.com/ekmett/exceptions/";

5973 description = "Extensible optionally-pure exceptions";

5974 license = stdenv.lib.licenses.bsd3;

5975 }) {};

5976 "executable-path" = callPackage

5977 ({ mkDerivation, base, directory, filepath, unix }:

5978 mkDerivation {

5979 pname = "executable-path";

5980 version = "0.0.3";

5981 sha256 = "1jg58qf19qz93c60ryglcavwdcysz4fd4qn8kpw5im9w9kniawlc";

5982 configureFlags = [

5983 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

5984 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

5985 "-fsplitbase" "-f-test-hlint"

5986 ];

5987 libraryHaskellDepends = [ base directory filepath unix ];

5988 homepage = "http://code.haskell.org/~bkomuves/";

5989 description = "Finding out the full path of the executable";

5990 license = stdenv.lib.licenses.publicDomain;

5991 }) {};

5992 "extensible-exceptions" = callPackage

5993 ({ mkDerivation, base }:

5994 mkDerivation {

5995 pname = "extensible-exceptions";

5996 version = "0.1.1.4";

5997 sha256 = "1273nqws9ij1rp1bsq5jc7k2jxpqa0svawdbim05lf302y0firbc";

5998 configureFlags = [

5999 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6000 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6001 "-fsplitbase" "-f-test-hlint"

6002 ];

6003 libraryHaskellDepends = [ base ];

6004 description = "Extensible exceptions";

6005 license = stdenv.lib.licenses.bsd3;

6006 }) {};

6007 "extra" = callPackage

6008 ({ mkDerivation, base, directory, filepath, process, QuickCheck

6009 , time, unix

6010 }:

6011 mkDerivation {

6012 pname = "extra";

6013 version = "1.0.1";

6014 sha256 = "1nmcgi24b3n0bqiychx96zf07vjy4129f9qpwh57ir90bmsixij6";

6015 revision = "1";

6016 editedCabalFile = "1fgc94cjza5fn61xwjzd1x61dvx71fk16r0d7cfcwsjiv0dvsa59";

6017 configureFlags = [

6018 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6019 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6020 "-fsplitbase" "-f-test-hlint"

6021 ];

6022 libraryHaskellDepends = [

6023 base directory filepath process time unix

6024 ];

6025 testHaskellDepends = [

6026 base directory filepath QuickCheck time unix

6027 ];

6028 homepage = "https://github.com/ndmitchell/extra#readme";

6029 description = "Extra functions I use";

6030 license = stdenv.lib.licenses.bsd3;

6031 }) {};

6032 "failure" = callPackage

6033 ({ mkDerivation, base, transformers }:

6034 mkDerivation {

6035 pname = "failure";

6036 version = "0.2.0.3";

6037 sha256 = "0jimc2x46zq7wnmzfbnqi67jl8yhbvr0fa65ljlc9p3fns9mca3p";

6038 configureFlags = [

6039 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6040 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6041 "-fsplitbase" "-f-test-hlint"

6042 ];

6043 libraryHaskellDepends = [ base transformers ];

6044 homepage = "http://www.haskell.org/haskellwiki/Failure";

6045 description = "A simple type class for success/failure computations. (deprecated)";

6046 license = stdenv.lib.licenses.bsd3;

6047 }) {};

6048 "fast-logger" = callPackage

6049 ({ mkDerivation, array, auto-update, base, blaze-builder

6050 , bytestring, directory, filepath, hspec, text

6051 }:

6052 mkDerivation {

6053 pname = "fast-logger";

6054 version = "2.2.3";

6055 sha256 = "0zap61gz0snbq42h8nyjh637fr2cm1ny9f77sqd6v3yfqjq0ljh3";

6056 revision = "1";

6057 editedCabalFile = "0f9m99f68dk5m6iy7lbzif000l9imijpqygixgdhx0wfpards7xr";

6058 configureFlags = [

6059 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6060 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6061 "-fsplitbase" "-f-test-hlint"

6062 ];

6063 libraryHaskellDepends = [

6064 array auto-update base blaze-builder bytestring directory filepath

6065 text

6066 ];

6067 testHaskellDepends = [ base bytestring directory hspec ];

6068 description = "A fast logging system";

6069 license = stdenv.lib.licenses.bsd3;

6070 }) {};

6071 "fay" = callPackage

6072 ({ mkDerivation, aeson, base, bytestring, containers, data-default

6073 , directory, filepath, ghc-paths, haskell-names, haskell-packages

6074 , haskell-src-exts, language-ecmascript, mtl, optparse-applicative

6075 , process, safe, sourcemap, split, spoon, syb, text, time

6076 , transformers, uniplate, unordered-containers, utf8-string, vector

6077 }:

6078 mkDerivation {

6079 pname = "fay";

6080 version = "0.21.2.1";

6081 sha256 = "06ijfkm1x5a15hac9f4cs4f16rva2hkf07xfh0mm9q3wkamqxlfm";

6082 configureFlags = [

6083 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6084 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6085 "-fsplitbase" "-f-test-hlint"

6086 ];

6087 isLibrary = true;

6088 isExecutable = true;

6089 enableSeparateDataOutput = true;

6090 libraryHaskellDepends = [

6091 aeson base bytestring containers data-default directory filepath

6092 ghc-paths haskell-names haskell-packages haskell-src-exts

6093 language-ecmascript mtl process safe sourcemap split spoon syb text

6094 time transformers uniplate unordered-containers utf8-string vector

6095 ];

6096 executableHaskellDepends = [ base mtl optparse-applicative split ];

6097 homepage = "https://github.com/faylang/fay/wiki";

6098 description = "A compiler for Fay, a Haskell subset that compiles to JavaScript";

6099 license = stdenv.lib.licenses.bsd3;

6100 }) {};

6101 "fay-base" = callPackage

6102 ({ mkDerivation, base, fay }:

6103 mkDerivation {

6104 pname = "fay-base";

6105 version = "0.19.4.2";

6106 sha256 = "1rch4mwkvxccw8jcndhwvf5n0f9bnwpfg6qnbhbwls4y1cvlcihr";

6107 configureFlags = [

6108 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6109 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6110 "-fsplitbase" "-f-test-hlint"

6111 ];

6112 enableSeparateDataOutput = true;

6113 libraryHaskellDepends = [ base fay ];

6114 homepage = "https://github.com/faylang/fay/";

6115 description = "The base package for Fay";

6116 license = stdenv.lib.licenses.bsd3;

6117 }) {};

6118 "fay-builder" = callPackage

6119 ({ mkDerivation, base, Cabal, data-default, directory, fay

6120 , filepath, safe, split, text

6121 }:

6122 mkDerivation {

6123 pname = "fay-builder";

6124 version = "0.2.0.4";

6125 sha256 = "0x1y9d2hgi3ky7f7ydc43dyd54dsmqcgxj6g8n2x3yfrcjkljq05";

6126 configureFlags = [

6127 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6128 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6129 "-fsplitbase" "-f-test-hlint"

6130 ];

6131 libraryHaskellDepends = [

6132 base Cabal data-default directory fay filepath safe split text

6133 ];

6134 description = "Compile Fay code on cabal install, and ad-hoc recompile during development";

6135 license = stdenv.lib.licenses.bsd3;

6136 }) {};

6137 "fay-dom" = callPackage

6138 ({ mkDerivation, fay-base }:

6139 mkDerivation {

6140 pname = "fay-dom";

6141 version = "0.5.0.1";

6142 sha256 = "1zm6w6nccswaksr283alhnsss6xw4k7s61yp8ff4lg5127ff9wp0";

6143 configureFlags = [

6144 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6145 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6146 "-fsplitbase" "-f-test-hlint"

6147 ];

6148 enableSeparateDataOutput = true;

6149 libraryHaskellDepends = [ fay-base ];

6150 homepage = "https://github.com/faylang/fay-dom";

6151 description = "DOM FFI wrapper library for Fay";

6152 license = stdenv.lib.licenses.bsd3;

6153 }) {};

6154 "fay-jquery" = callPackage

6155 ({ mkDerivation, fay-base, fay-text }:

6156 mkDerivation {

6157 pname = "fay-jquery";

6158 version = "0.6.0.3";

6159 sha256 = "1x6i8y6xbz4nyzw59j3cqkhmjvgx9l4vdyh7jr0l1vv396ssnghf";

6160 configureFlags = [

6161 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6162 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6163 "-fsplitbase" "-f-test-hlint"

6164 ];

6165 enableSeparateDataOutput = true;

6166 libraryHaskellDepends = [ fay-base fay-text ];

6167 homepage = "https://github.com/faylang/fay-jquery";

6168 description = "jQuery bindings for Fay";

6169 license = stdenv.lib.licenses.bsd3;

6170 }) {};

6171 "fay-text" = callPackage

6172 ({ mkDerivation, fay, fay-base, text }:

6173 mkDerivation {

6174 pname = "fay-text";

6175 version = "0.3.2.2";

6176 sha256 = "1q1v8jzkccy9arq6jkz4ynpzm1691d1dv9wzyi4i5m6n0gl7aans";

6177 configureFlags = [

6178 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6179 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6180 "-fsplitbase" "-f-test-hlint"

6181 ];

6182 enableSeparateDataOutput = true;

6183 libraryHaskellDepends = [ fay fay-base text ];

6184 homepage = "https://github.com/faylang/fay-text";

6185 description = "Fay Text type represented as JavaScript strings";

6186 license = stdenv.lib.licenses.mit;

6187 }) {};

6188 "fay-uri" = callPackage

6189 ({ mkDerivation, fay-base }:

6190 mkDerivation {

6191 pname = "fay-uri";

6192 version = "0.2.0.0";

6193 sha256 = "1vv4jgkz9cx8inbn6g6sn3a0nf1ak81qlj5li21sk2isj0yws1nr";

6194 configureFlags = [

6195 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6196 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6197 "-fsplitbase" "-f-test-hlint"

6198 ];

6199 enableSeparateDataOutput = true;

6200 libraryHaskellDepends = [ fay-base ];

6201 homepage = "https://github.com/faylang/fay-uri";

6202 description = "Persistent FFI bindings for using jsUri in Fay";

6203 license = stdenv.lib.licenses.bsd3;

6204 }) {};

6205 "fb" = callPackage

6206 ({ mkDerivation, aeson, attoparsec, base, base16-bytestring

6207 , base64-bytestring, bytestring, cereal, conduit, conduit-extra

6208 , crypto-api, cryptohash, cryptohash-cryptoapi, data-default

6209 , http-conduit, http-types, lifted-base, monad-control

6210 , monad-logger, old-locale, resourcet, text, time, transformers

6211 , transformers-base, unordered-containers

6212 }:

6213 mkDerivation {

6214 pname = "fb";

6215 version = "1.0.8";

6216 sha256 = "1cv722kkp6lbxajv3ka4088x2491yy41cfypqqkq753mm59x6s9m";

6217 configureFlags = [

6218 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6219 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6220 "-fsplitbase" "-f-test-hlint"

6221 ];

6222 libraryHaskellDepends = [

6223 aeson attoparsec base base16-bytestring base64-bytestring

6224 bytestring cereal conduit conduit-extra crypto-api cryptohash

6225 cryptohash-cryptoapi data-default http-conduit http-types

6226 lifted-base monad-control monad-logger old-locale resourcet text

6227 time transformers transformers-base unordered-containers

6228 ];

6229 doCheck = false;

6230 homepage = "https://github.com/prowdsponsor/fb";

6231 description = "Bindings to Facebook's API";

6232 license = stdenv.lib.licenses.bsd3;

6233 }) {};

6234 "fb-persistent" = callPackage

6235 ({ mkDerivation, base, cereal, fb, persistent, text, time }:

6236 mkDerivation {

6237 pname = "fb-persistent";

6238 version = "0.3.4";

6239 sha256 = "07hrifzwvv7fzqh70igfbxzn854yvyx7406s8byn0arhmp21ka3b";

6240 configureFlags = [

6241 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6242 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6243 "-fsplitbase" "-f-test-hlint"

6244 ];

6245 libraryHaskellDepends = [ base cereal fb persistent text time ];

6246 homepage = "https://github.com/prowdsponsor/fb-persistent";

6247 description = "Provides Persistent instances to Facebook types";

6248 license = stdenv.lib.licenses.bsd3;

6249 }) {};

6250 "fclabels" = callPackage

6251 ({ mkDerivation, base, HUnit, mtl, template-haskell, transformers

6252 }:

6253 mkDerivation {

6254 pname = "fclabels";

6255 version = "2.0.2.2";

6256 sha256 = "0jvmmmky2h4i6lh0zj67j8rf1r1r1plv1s9y67jbs821266ffra8";

6257 configureFlags = [

6258 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6259 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6260 "-fsplitbase" "-f-test-hlint"

6261 ];

6262 libraryHaskellDepends = [ base mtl template-haskell transformers ];

6263 testHaskellDepends = [

6264 base HUnit mtl template-haskell transformers

6265 ];

6266 homepage = "https://github.com/sebastiaanvisser/fclabels";

6267 description = "First class accessor labels implemented as lenses";

6268 license = stdenv.lib.licenses.bsd3;

6269 }) {};

6270 "fgl" = callPackage

6271 ({ mkDerivation, array, base, containers, mtl }:

6272 mkDerivation {

6273 pname = "fgl";

6274 version = "5.5.1.0";

6275 sha256 = "0rcmz0xlyr1wj490ffja29z1jgl51gz19ka609da6bx39bwx7nga";

6276 configureFlags = [

6277 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6278 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6279 "-fsplitbase" "-f-test-hlint"

6280 ];

6281 libraryHaskellDepends = [ array base containers mtl ];

6282 description = "Martin Erwig's Functional Graph Library";

6283 license = stdenv.lib.licenses.bsd3;

6284 }) {};

6285 "file-embed" = callPackage

6286 ({ mkDerivation, base, bytestring, directory, filepath, HUnit

6287 , template-haskell

6288 }:

6289 mkDerivation {

6290 pname = "file-embed";

6291 version = "0.0.8.2";

6292 sha256 = "1gdxz9244wjhfigpsyaan81gyx6vanb8574xxi7944sj9pcgi74y";

6293 configureFlags = [

6294 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6295 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6296 "-fsplitbase" "-f-test-hlint"

6297 ];

6298 libraryHaskellDepends = [

6299 base bytestring directory filepath template-haskell

6300 ];

6301 testHaskellDepends = [ base filepath HUnit ];

6302 homepage = "https://github.com/snoyberg/file-embed";

6303 description = "Use Template Haskell to embed file contents directly";

6304 license = stdenv.lib.licenses.bsd3;

6305 }) {};

6306 "file-location" = callPackage

6307 ({ mkDerivation, base, containers, lifted-base, process

6308 , template-haskell, transformers

6309 }:

6310 mkDerivation {

6311 pname = "file-location";

6312 version = "0.4.6";

6313 sha256 = "035xszjzhckcazanfvxkwfw2gv2mbw483rinr7ngaqripnl6m0bp";

6314 configureFlags = [

6315 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6316 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6317 "-fsplitbase" "-f-test-hlint"

6318 ];

6319 libraryHaskellDepends = [

6320 base containers lifted-base template-haskell transformers

6321 ];

6322 testHaskellDepends = [

6323 base containers lifted-base process template-haskell transformers

6324 ];

6325 homepage = "https://github.com/gregwebs/FileLocation.hs";

6326 description = "common functions that show file location information";

6327 license = stdenv.lib.licenses.bsd3;

6328 }) {};

6329 "filemanip" = callPackage

6330 ({ mkDerivation, base, bytestring, directory, filepath, mtl

6331 , unix-compat

6332 }:

6333 mkDerivation {

6334 pname = "filemanip";

6335 version = "0.3.6.3";

6336 sha256 = "0ilqr8jv41zxcj5qyicg29m8s30b9v70x6f9h2h2rw5ap8bxldl8";

6337 configureFlags = [

6338 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6339 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6340 "-fsplitbase" "-f-test-hlint"

6341 ];

6342 libraryHaskellDepends = [

6343 base bytestring directory filepath mtl unix-compat

6344 ];

6345 homepage = "https://github.com/bos/filemanip";

6346 description = "Expressive file and directory manipulation for Haskell";

6347 license = stdenv.lib.licenses.bsd3;

6348 }) {};

6349 "fingertree" = callPackage

6350 ({ mkDerivation, base, HUnit, QuickCheck, test-framework

6351 , test-framework-hunit, test-framework-quickcheck2

6352 }:

6353 mkDerivation {

6354 pname = "fingertree";

6355 version = "0.1.0.2";

6356 sha256 = "1krsymv66lnz30hv3j2427vl1wh7vczjb66qviq8mfxgfxf2q8z6";

6357 configureFlags = [

6358 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6359 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6360 "-fsplitbase" "-f-test-hlint"

6361 ];

6362 libraryHaskellDepends = [ base ];

6363 testHaskellDepends = [

6364 base HUnit QuickCheck test-framework test-framework-hunit

6365 test-framework-quickcheck2

6366 ];

6367 description = "Generic finger-tree structure, with example instances";

6368 license = stdenv.lib.licenses.bsd3;

6369 }) {};

6370 "fixed" = callPackage

6371 ({ mkDerivation, base }:

6372 mkDerivation {

6373 pname = "fixed";

6374 version = "0.2.1.1";

6375 sha256 = "1qhmwx8iqshns0crmr9d2f8hm65jxbcp3dvv0c39v34ra7if3a94";

6376 configureFlags = [

6377 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6378 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6379 "-fsplitbase" "-f-test-hlint"

6380 ];

6381 libraryHaskellDepends = [ base ];

6382 homepage = "http://github.com/ekmett/fixed";

6383 description = "Signed 15.16 precision fixed point arithmetic";

6384 license = stdenv.lib.licenses.bsd3;

6385 }) {};

6386 "fixed-list" = callPackage

6387 ({ mkDerivation, base }:

6388 mkDerivation {

6389 pname = "fixed-list";

6390 version = "0.1.5";

6391 sha256 = "07b1kzysf96jckx7yghb2a93l884x8fvxxd0g2ja3hwb5y403911";

6392 configureFlags = [

6393 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6394 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6395 "-fsplitbase" "-f-test-hlint"

6396 ];

6397 libraryHaskellDepends = [ base ];

6398 homepage = "http://github.com/jvranish/FixedList/tree/master";

6399 description = "A fixed length list type";

6400 license = stdenv.lib.licenses.bsd3;

6401 }) {};

6402 "flexible-defaults" = callPackage

6403 ({ mkDerivation, base, containers, template-haskell, th-extras

6404 , transformers

6405 }:

6406 mkDerivation {

6407 pname = "flexible-defaults";

6408 version = "0.0.1.1";

6409 sha256 = "0cbp8hb7y29xz3hl780173cs6ca4df0r98fz7v3drqr46aq55ipl";

6410 configureFlags = [

6411 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6412 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6413 "-fsplitbase" "-f-test-hlint"

6414 ];

6415 libraryHaskellDepends = [

6416 base containers template-haskell th-extras transformers

6417 ];

6418 homepage = "https://github.com/mokus0/flexible-defaults";

6419 description = "Generate default function implementations for complex type classes";

6420 license = stdenv.lib.licenses.publicDomain;

6421 }) {};

6422 "focus" = callPackage

6423 ({ mkDerivation, base }:

6424 mkDerivation {

6425 pname = "focus";

6426 version = "0.1.3";

6427 sha256 = "11l6rlr22m0z41c9fynpisj0cnx70zzcxhsakz9b09ap8wj0raqy";

6428 revision = "1";

6429 editedCabalFile = "0p35inljpw01402xm3pw1is0d2g2l6cmvw9f4xd1asbxgravxvzc";

6430 configureFlags = [

6431 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6432 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6433 "-fsplitbase" "-f-test-hlint"

6434 ];

6435 libraryHaskellDepends = [ base ];

6436 doCheck = false;

6437 homepage = "https://github.com/nikita-volkov/focus";

6438 description = "A general abstraction for manipulating elements of container data structures";

6439 license = stdenv.lib.licenses.mit;

6440 }) {};

6441 "foldl" = callPackage

6442 ({ mkDerivation, base, bytestring, containers, primitive, text

6443 , transformers, vector

6444 }:

6445 mkDerivation {

6446 pname = "foldl";

6447 version = "1.0.8";

6448 sha256 = "1v8g1n17lwjwr2d1r3zam44qlm3jrr5j30d4cs4n4gf5pgxlrzvp";

6449 revision = "1";

6450 editedCabalFile = "1hh1wqs6qq2sw2v8b26qkd7q26b29p7fkz9fj4373rh4895y495n";

6451 configureFlags = [

6452 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6453 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6454 "-fsplitbase" "-f-test-hlint"

6455 ];

6456 libraryHaskellDepends = [

6457 base bytestring containers primitive text transformers vector

6458 ];

6459 description = "Composable, streaming, and efficient left folds";

6460 license = stdenv.lib.licenses.bsd3;

6461 }) {};

6462 "force-layout" = callPackage

6463 ({ mkDerivation, base, containers, data-default-class, lens

6464 , vector-space, vector-space-points

6465 }:

6466 mkDerivation {

6467 pname = "force-layout";

6468 version = "0.3.0.10";

6469 sha256 = "0s3q1az0fvx1kn79nsz3d7d4gampcz4yyp9nmqj9baip1lws6k36";

6470 configureFlags = [

6471 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6472 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6473 "-fsplitbase" "-f-test-hlint"

6474 ];

6475 libraryHaskellDepends = [

6476 base containers data-default-class lens vector-space

6477 vector-space-points

6478 ];

6479 description = "Simple force-directed layout";

6480 license = stdenv.lib.licenses.bsd3;

6481 }) {};

6482 "foreign-store" = callPackage

6483 ({ mkDerivation, base }:

6484 mkDerivation {

6485 pname = "foreign-store";

6486 version = "0.1";

6487 sha256 = "1p7hsr1kg1667wql9c18q7bwpnrldnb8r18ijhji5c7qqr8yml5g";

6488 configureFlags = [

6489 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6490 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6491 "-fsplitbase" "-f-test-hlint"

6492 ];

6493 libraryHaskellDepends = [ base ];

6494 homepage = "https://github.com/chrisdone/foreign-store";

6495 description = "Store a stable pointer in a foreign context to be retrieved later. Persists through GHCi reloads.";

6496 license = stdenv.lib.licenses.bsd3;

6497 }) {};

6498 "foreign-var" = callPackage

6499 ({ mkDerivation, base, stm, transformers }:

6500 mkDerivation {

6501 pname = "foreign-var";

6502 version = "0.0.0.1";

6503 sha256 = "0rv4kszwbxx4gzkqv7kygj31pcjmyacs33bq2imjl24bjgy8si49";

6504 revision = "1";

6505 editedCabalFile = "1fygv7zyibp3xkp663fhnfjg8sd7rfqcz7dvjm9bwpyc7alq2j8c";

6506 libraryHaskellDepends = [ base stm transformers ];

6507 homepage = "http://github.com/ekmett/foreign-var/";

6508 description = "Encapsulating mutatable state in external libraries";

6509 license = stdenv.lib.licenses.bsd3;

6510 }) {};

6511 "formatting" = callPackage

6512 ({ mkDerivation, base, old-locale, scientific, text, text-format

6513 , time

6514 }:

6515 mkDerivation {

6516 pname = "formatting";

6517 version = "6.0.0";

6518 sha256 = "01zighgfc8nywigzsah07fr7pkcz0mfrb495gikaapi01i13nkmc";

6519 revision = "1";

6520 editedCabalFile = "0955kh0p60pqx93ks9m5pp6zjgifxprhxsqhqw0a6qk97m676p2m";

6521 configureFlags = [

6522 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6523 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6524 "-fsplitbase" "-f-test-hlint"

6525 ];

6526 libraryHaskellDepends = [

6527 base old-locale scientific text text-format time

6528 ];

6529 description = "Combinator-based type-safe formatting (like printf() or FORMAT)";

6530 license = stdenv.lib.licenses.bsd3;

6531 }) {};

6532 "fpco-api" = callPackage

6533 ({ mkDerivation, aeson, attoparsec, base, base64-bytestring

6534 , blaze-html, bytestring, cereal, containers, data-default, deepseq

6535 , deepseq-generics, directory, failure, fay, filepath, ghc-prim

6536 , hashable, http-conduit, http-types, ini, lifted-async

6537 , lifted-base, monad-control, monad-extras, monad-logger, mtl

6538 , network, optparse-applicative, persistent, persistent-template

6539 , pretty-show, process, random, resourcet, safe, semigroups

6540 , shakespeare, shakespeare-i18n, stm, syb, template-haskell, text

6541 , time, transformers, transformers-base, unordered-containers

6542 , vector, yesod-core

6543 }:

6544 mkDerivation {

6545 pname = "fpco-api";

6546 version = "1.2.0.5";

6547 sha256 = "1r80a6vimpy4nviskl62c4ivp2l8wrg3vhzgdg53nnfa5j6lmha2";

6548 configureFlags = [

6549 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6550 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6551 "-fsplitbase" "-f-test-hlint"

6552 ];

6553 isLibrary = true;

6554 isExecutable = true;

6555 libraryHaskellDepends = [

6556 aeson attoparsec base base64-bytestring blaze-html bytestring

6557 cereal containers data-default deepseq deepseq-generics directory

6558 failure fay filepath ghc-prim hashable http-conduit http-types

6559 lifted-async lifted-base monad-control monad-extras monad-logger

6560 mtl network persistent persistent-template pretty-show random

6561 resourcet safe semigroups shakespeare shakespeare-i18n stm syb

6562 template-haskell text time transformers transformers-base

6563 unordered-containers vector yesod-core

6564 ];

6565 executableHaskellDepends = [

6566 aeson base bytestring data-default directory filepath ini network

6567 optparse-applicative process safe text unordered-containers

6568 ];

6569 homepage = "https://www.fpcomplete.com/page/api";

6570 description = "Simple interface to the FP Complete IDE API";

6571 license = stdenv.lib.licenses.bsd3;

6572 }) {};

6573 "free" = callPackage

6574 ({ mkDerivation, base, bifunctors, comonad, distributive, mtl

6575 , prelude-extras, profunctors, semigroupoids, semigroups

6576 , template-haskell, transformers

6577 }:

6578 mkDerivation {

6579 pname = "free";

6580 version = "4.10.0.1";

6581 sha256 = "0vs080bbcbncjqa7z0l6zd10kpmilj8khxiqdn4bq24mifyryhvq";

6582 configureFlags = [

6583 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6584 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6585 "-fsplitbase" "-f-test-hlint"

6586 ];

6587 libraryHaskellDepends = [

6588 base bifunctors comonad distributive mtl prelude-extras profunctors

6589 semigroupoids semigroups template-haskell transformers

6590 ];

6591 homepage = "http://github.com/ekmett/free/";

6592 description = "Monads for free";

6593 license = stdenv.lib.licenses.bsd3;

6594 }) {};

6595 "freenect" = callPackage

6596 ({ mkDerivation, base, freenect, freenect_sync, vector }:

6597 mkDerivation {

6598 pname = "freenect";

6599 version = "1.2";

6600 sha256 = "11ggp90npdyfdmf8zhjk442zl0j0lni6hizhgc0409za9i6s1l5g";

6601 configureFlags = [

6602 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6603 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6604 "-fsplitbase" "-f-test-hlint"

6605 "--extra-include-dirs=${pkgs.freenect}/include/libfreenect"

6606 "--extra-lib-dirs=${pkgs.freenect}/lib"

6607 ];

6608 libraryHaskellDepends = [ base vector ];

6609 librarySystemDepends = [ freenect freenect_sync ];

6610 homepage = "https://github.com/chrisdone/freenect";

6611 description = "Interface to the Kinect device";

6612 license = stdenv.lib.licenses.bsd3;

6613 }) {inherit (pkgs) freenect; freenect_sync = null;};

6614 "frisby" = callPackage

6615 ({ mkDerivation, array, base, containers, mtl }:

6616 mkDerivation {

6617 pname = "frisby";

6618 version = "0.2";

6619 sha256 = "0isj9p7j33va1a4q78vnq32j9jdbjww596rxja235z4whicraf53";

6620 revision = "1";

6621 editedCabalFile = "1ip1bykcrnqzfjbsi4gfj59lc24k3kvyn949ryczpqshlpgnbnqj";

6622 configureFlags = [

6623 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6624 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6625 "-fsplitbase" "-f-test-hlint"

6626 ];

6627 libraryHaskellDepends = [ array base containers mtl ];

6628 homepage = "http://repetae.net/computer/frisby/";

6629 description = "Linear time composable parser for PEG grammars";

6630 license = stdenv.lib.licenses.bsd3;

6631 }) {};

6632 "fsnotify" = callPackage

6633 ({ mkDerivation, async, base, containers, directory, hinotify

6634 , system-fileio, system-filepath, tasty, tasty-hunit, temporary-rc

6635 , text, time

6636 }:

6637 mkDerivation {

6638 pname = "fsnotify";

6639 version = "0.1.0.3";

6640 sha256 = "0m6jyg45azk377jklgwyqrx95q174cxd5znpyh9azznkh09wq58z";

6641 configureFlags = [

6642 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6643 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6644 "-fsplitbase" "-f-test-hlint"

6645 ];

6646 libraryHaskellDepends = [

6647 async base containers hinotify system-fileio system-filepath text

6648 time

6649 ];

6650 testHaskellDepends = [

6651 async base directory system-fileio system-filepath tasty

6652 tasty-hunit temporary-rc

6653 ];

6654 doCheck = false;

6655 description = "Cross platform library for file change notification";

6656 license = stdenv.lib.licenses.bsd3;

6657 }) {};

6658 "fuzzcheck" = callPackage

6659 ({ mkDerivation, base, hspec, hspec-expectations, HUnit

6660 , lifted-base, monad-control, QuickCheck, random, transformers

6661 }:

6662 mkDerivation {

6663 pname = "fuzzcheck";

6664 version = "0.1.1";

6665 sha256 = "0qfr4f0b50l368b45yzwhqd4g2y1kvfrfj4hr84cdxcwdrwn9mpc";

6666 configureFlags = [

6667 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6668 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6669 "-fsplitbase" "-f-test-hlint"

6670 ];

6671 libraryHaskellDepends = [

6672 base lifted-base monad-control QuickCheck random transformers

6673 ];

6674 testHaskellDepends = [

6675 base hspec hspec-expectations HUnit QuickCheck

6676 ];

6677 homepage = "https://github.com/fpco/fuzzcheck";

6678 description = "A simple checker for stress testing monadic code";

6679 license = stdenv.lib.licenses.bsd3;

6680 }) {};

6681 "gd" = callPackage

6682 ({ mkDerivation, base, bytestring, expat, fontconfig, freetype, gd

6683 , libjpeg, libpng, zlib

6684 }:

6685 mkDerivation {

6686 pname = "gd";

6687 version = "3000.7.3";

6688 sha256 = "1dkzv6zs00qi0jmblkw05ywizc8y3baz7pnz0lcqn1cs1mhcpbhl";

6689 configureFlags = [

6690 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6691 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6692 "-fsplitbase" "-f-test-hlint"

6693 ];

6694 libraryHaskellDepends = [ base bytestring ];

6695 librarySystemDepends = [

6696 expat fontconfig freetype gd libjpeg libpng zlib

6697 ];

6698 description = "A Haskell binding to a subset of the GD graphics library";

6699 license = stdenv.lib.licenses.bsd3;

6700 }) {inherit (pkgs) expat; inherit (pkgs) fontconfig;

6701 inherit (pkgs) freetype; inherit (pkgs) gd; inherit (pkgs) libjpeg;

6702 inherit (pkgs) libpng; inherit (pkgs) zlib;};

6703 "generic-aeson" = callPackage

6704 ({ mkDerivation, aeson, attoparsec, base, generic-deriving, mtl

6705 , tagged, text, unordered-containers, vector

6706 }:

6707 mkDerivation {

6708 pname = "generic-aeson";

6709 version = "0.2.0.2";

6710 sha256 = "1x58c7xgdc1asg4n61fpikn7jvspyqawykq4q49xhsp5dp11lzzh";

6711 revision = "2";

6712 editedCabalFile = "1vxmhq6wmxwb9m1br2raq2vzsvyp5s9l2jq87ahgm1fjqnayysyi";

6713 configureFlags = [

6714 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6715 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6716 "-fsplitbase" "-f-test-hlint"

6717 ];

6718 libraryHaskellDepends = [

6719 aeson attoparsec base generic-deriving mtl tagged text

6720 unordered-containers vector

6721 ];

6722 description = "Derivation of Aeson instances using GHC generics";

6723 license = stdenv.lib.licenses.bsd3;

6724 }) {};

6725 "generic-deriving" = callPackage

6726 ({ mkDerivation, base, ghc-prim, template-haskell }:

6727 mkDerivation {

6728 pname = "generic-deriving";

6729 version = "1.6.3";

6730 sha256 = "04cjyl5aphf36qbbn75midrqj151fc77z2znpal8dk52gaab2f67";

6731 configureFlags = [

6732 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6733 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6734 "-fsplitbase" "-f-test-hlint"

6735 ];

6736 libraryHaskellDepends = [ base ghc-prim template-haskell ];

6737 description = "Generic programming library for generalised deriving";

6738 license = stdenv.lib.licenses.bsd3;

6739 }) {};

6740 "generics-sop" = callPackage

6741 ({ mkDerivation, base, ghc-prim, template-haskell }:

6742 mkDerivation {

6743 pname = "generics-sop";

6744 version = "0.1.1.2";

6745 sha256 = "1r9icxwyh4pg952yaywk4nfj4j21klzf361z9z24avd6vw89p6v7";

6746 configureFlags = [

6747 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6748 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6749 "-fsplitbase" "-f-test-hlint"

6750 ];

6751 libraryHaskellDepends = [ base ghc-prim template-haskell ];

6752 description = "Generic Programming using True Sums of Products";

6753 license = stdenv.lib.licenses.bsd3;

6754 }) {};

6755 "ghc-heap-view" = callPackage

6756 ({ mkDerivation, base, binary, bytestring, containers, deepseq, ghc

6757 , template-haskell, transformers

6758 }:

6759 mkDerivation {

6760 pname = "ghc-heap-view";

6761 version = "0.5.3";

6762 sha256 = "1jcqi4gahxmhd61hl75wgb9dp99kxld68860jnd9x4hnp5cd33q0";

6763 configureFlags = [

6764 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6765 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6766 "-fsplitbase" "-f-test-hlint"

6767 ];

6768 enableSeparateDataOutput = true;

6769 libraryHaskellDepends = [

6770 base binary bytestring containers ghc template-haskell transformers

6771 ];

6772 testHaskellDepends = [ base deepseq ];

6773 description = "Extract the heap representation of Haskell values and thunks";

6774 license = stdenv.lib.licenses.bsd3;

6775 }) {};

6776 "ghc-mod" = callPackage

6777 ({ mkDerivation, async, base, Cabal, containers, data-default

6778 , deepseq, directory, djinn-ghc, doctest, filepath, ghc, ghc-paths

6779 , ghc-syb-utils, haskell-src-exts, hlint, hspec, io-choice

6780 , monad-control, monad-journal, mtl, old-time, pretty, process

6781 , split, syb, temporary, text, time, transformers

6782 , transformers-base

6783 }:

6784 mkDerivation {

6785 pname = "ghc-mod";

6786 version = "5.2.1.2";

6787 sha256 = "11wnrdb6blw169w6kd49ax9h1r9qkka5329lmdhimvki8amv8riv";

6788 revision = "2";

6789 editedCabalFile = "13fbfwjkc498s0mv6fza7b4ywdy81saqdqfmz5q1lp671hwh5m15";

6790 configureFlags = [

6791 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6792 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6793 "-fsplitbase" "-f-test-hlint"

6794 ];

6795 isLibrary = true;

6796 isExecutable = true;

6797 enableSeparateDataOutput = true;

6798 libraryHaskellDepends = [

6799 base Cabal containers deepseq directory djinn-ghc filepath ghc

6800 ghc-paths ghc-syb-utils haskell-src-exts hlint io-choice

6801 monad-control monad-journal mtl old-time pretty process split syb

6802 temporary text time transformers transformers-base

6803 ];

6804 executableHaskellDepends = [

6805 async base containers data-default directory filepath ghc mtl

6806 old-time pretty process split time

6807 ];

6808 testHaskellDepends = [

6809 base Cabal containers deepseq directory djinn-ghc doctest filepath

6810 ghc ghc-paths ghc-syb-utils haskell-src-exts hlint hspec io-choice

6811 monad-control monad-journal mtl old-time pretty process split syb

6812 temporary text time transformers transformers-base

6813 ];

6814 doCheck = false;

6815 homepage = "http://www.mew.org/~kazu/proj/ghc-mod/";

6816 description = "Happy Haskell Programming";

6817 license = stdenv.lib.licenses.bsd3;

6818 }) {};

6819 "ghc-mtl" = callPackage

6820 ({ mkDerivation, base, exceptions, extensible-exceptions, ghc, mtl

6821 }:

6822 mkDerivation {

6823 pname = "ghc-mtl";

6824 version = "1.2.1.0";

6825 sha256 = "0h6r6gip9nsjlsq88wj105hhqliy7ac2dmmndsfzbjz07b03cklk";

6826 configureFlags = [

6827 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6828 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6829 "-fsplitbase" "-f-test-hlint"

6830 ];

6831 libraryHaskellDepends = [

6832 base exceptions extensible-exceptions ghc mtl

6833 ];

6834 homepage = "http://hub.darcs.net/jcpetruzza/ghc-mtl";

6835 description = "An mtl compatible version of the Ghc-Api monads and monad-transformers";

6836 license = stdenv.lib.licenses.bsd3;

6837 }) {};

6838 "ghc-paths" = callPackage

6839 ({ mkDerivation, base, Cabal, directory }:

6840 mkDerivation {

6841 pname = "ghc-paths";

6842 version = "0.1.0.9";

6843 sha256 = "0ibrr1dxa35xx20cpp8jzgfak1rdmy344dfwq4vlq013c6w8z9mg";

6844 revision = "2";

6845 editedCabalFile = "1gs6biqbcabgmrwhc1bq1bdaxdwwh26v4mpvj5c7cfyigc64gwyk";

6846 configureFlags = [

6847 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6848 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6849 "-fsplitbase" "-f-test-hlint"

6850 ];

6851 setupHaskellDepends = [ base Cabal directory ];

6852 libraryHaskellDepends = [ base ];

6853 description = "Knowledge of GHC's installation directories";

6854 license = stdenv.lib.licenses.bsd3;

6855 }) {};

6856 "ghc-syb-utils" = callPackage

6857 ({ mkDerivation, base, ghc, syb }:

6858 mkDerivation {

6859 pname = "ghc-syb-utils";

6860 version = "0.2.3";

6861 sha256 = "0rxwdivpcppwzbqglbrz8rm9f4g1gmba9ij7p7aj3di9x37kzxky";

6862 configureFlags = [

6863 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6864 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6865 "-fsplitbase" "-f-test-hlint"

6866 ];

6867 libraryHaskellDepends = [ base ghc syb ];

6868 homepage = "http://github.com/nominolo/ghc-syb";

6869 description = "Scrap Your Boilerplate utilities for the GHC API";

6870 license = stdenv.lib.licenses.bsd3;

6871 }) {};

6872 "ghcid" = callPackage

6873 ({ mkDerivation, base, cmdargs, containers, directory, extra

6874 , filepath, process, tasty, tasty-hunit, terminal-size, time

6875 }:

6876 mkDerivation {

6877 pname = "ghcid";

6878 version = "0.3.4";

6879 sha256 = "1xapx3rlx9fsvs5idqyarassqbg8ifsar923pi9vsn29ipjp2kjq";

6880 revision = "1";

6881 editedCabalFile = "1hc5df2cqmj1mqw2bqdqwl19j57xf5zqg6x479m5m3b7aj5viv9p";

6882 configureFlags = [

6883 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6884 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6885 "-fsplitbase" "-f-test-hlint"

6886 ];

6887 isLibrary = true;

6888 isExecutable = true;

6889 libraryHaskellDepends = [

6890 base cmdargs containers directory extra filepath process

6891 terminal-size time

6892 ];

6893 executableHaskellDepends = [

6894 base cmdargs containers directory extra filepath process

6895 terminal-size time

6896 ];

6897 testHaskellDepends = [

6898 base cmdargs containers directory extra filepath process tasty

6899 tasty-hunit terminal-size time

6900 ];

6901 doCheck = false;

6902 homepage = "https://github.com/ndmitchell/ghcid#readme";

6903 description = "GHCi based bare bones IDE";

6904 license = stdenv.lib.licenses.bsd3;

6905 }) {};

6906 "gio" = callPackage

6907 ({ mkDerivation, array, base, bytestring, containers, glib

6908 , gtk2hs-buildtools, mtl, system-glib

6909 }:

6910 mkDerivation {

6911 pname = "gio";

6912 version = "0.13.0.4";

6913 sha256 = "1g2nwllgrckgg8kcgmripx8wqc664601kv4r7h4qq3v6hghvhdja";

6914 configureFlags = [

6915 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6916 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6917 "-fsplitbase" "-f-test-hlint"

6918 ];

6919 enableSeparateDataOutput = true;

6920 libraryHaskellDepends = [

6921 array base bytestring containers glib mtl

6922 ];

6923 libraryPkgconfigDepends = [ system-glib ];

6924 libraryToolDepends = [ gtk2hs-buildtools ];

6925 doHaddock = false;

6926 homepage = "http://projects.haskell.org/gtk2hs/";

6927 description = "Binding to the GIO";

6928 license = stdenv.lib.licenses.lgpl21;

6929 }) {system-glib = pkgs.glib;};

6930 "git-embed" = callPackage

6931 ({ mkDerivation, base, directory, filepath, process

6932 , template-haskell

6933 }:

6934 mkDerivation {

6935 pname = "git-embed";

6936 version = "0.1.0";

6937 sha256 = "0yrx06ay25zsk90djr4mrqnn80xp3w6cmkciqavrmijf25fc5jvn";

6938 configureFlags = [

6939 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6940 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6941 "-fsplitbase" "-f-test-hlint"

6942 ];

6943 libraryHaskellDepends = [

6944 base directory filepath process template-haskell

6945 ];

6946 homepage = "https://github.com/borsboom/git-embed";

6947 description = "Use TH to embed Git repo information";

6948 license = stdenv.lib.licenses.bsd2;

6949 }) {};

6950 "gl" = callPackage

6951 ({ mkDerivation, base, containers, directory, filepath, fixed, half

6952 , hxt, mesa, split, transformers

6953 }:

6954 mkDerivation {

6955 pname = "gl";

6956 version = "0.6.3";

6957 sha256 = "0ys5808rzr04fcw7hlliqpx2sncyqpr4x89p4sa2vf5ywsgzmz04";

6958 configureFlags = [

6959 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6960 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6961 "-fsplitbase" "-f-test-hlint"

6962 ];

6963 libraryHaskellDepends = [

6964 base containers directory filepath fixed half hxt split

6965 transformers

6966 ];

6967 librarySystemDepends = [ mesa ];

6968 doHaddock = false;

6969 description = "Complete OpenGL raw bindings";

6970 license = stdenv.lib.licenses.bsd3;

6971 }) {inherit (pkgs) mesa;};

6972 "glib" = callPackage

6973 ({ mkDerivation, base, bytestring, containers, glib

6974 , gtk2hs-buildtools, text, utf8-string

6975 }:

6976 mkDerivation {

6977 pname = "glib";

6978 version = "0.13.1.0";

6979 sha256 = "11scv2imljnr6ng7692jdagr7fc924hgfwfbnw4a5sra3w7ja7fz";

6980 configureFlags = [

6981 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

6982 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

6983 "-fsplitbase" "-f-test-hlint"

6984 ];

6985 libraryHaskellDepends = [

6986 base bytestring containers text utf8-string

6987 ];

6988 libraryPkgconfigDepends = [ glib ];

6989 libraryToolDepends = [ gtk2hs-buildtools ];

6990 homepage = "http://projects.haskell.org/gtk2hs/";

6991 description = "Binding to the GLIB library for Gtk2Hs";

6992 license = stdenv.lib.licenses.lgpl21;

6993 }) {inherit (pkgs) glib;};

6994 "graph-core" = callPackage

6995 ({ mkDerivation, base, containers, deepseq, hashable, HTF, mtl

6996 , QuickCheck, safe, unordered-containers, vector

6997 }:

6998 mkDerivation {

6999 pname = "graph-core";

7000 version = "0.2.1.0";

7001 sha256 = "0xx99p2i1ng79rph0hkb2dp5r9y77s0y4v8njsywxyq4kbl3ly7f";

7002 revision = "1";

7003 editedCabalFile = "0a86rpz2vkg1hr6av4xywch0ccn437ljjw2jrcw1712ma6yv536d";

7004 configureFlags = [

7005 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7006 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7007 "-fsplitbase" "-f-test-hlint"

7008 ];

7009 libraryHaskellDepends = [

7010 base containers deepseq hashable mtl QuickCheck safe

7011 unordered-containers vector

7012 ];

7013 testHaskellDepends = [

7014 base containers deepseq hashable HTF mtl QuickCheck safe

7015 unordered-containers vector

7016 ];

7017 homepage = "https://github.com/factisresearch/graph-core";

7018 description = "Fast, memory efficient and persistent graph implementation";

7019 license = stdenv.lib.licenses.mit;

7020 }) {};

7021 "graphs" = callPackage

7022 ({ mkDerivation, array, base, containers, transformers, void }:

7023 mkDerivation {

7024 pname = "graphs";

7025 version = "0.5.0.1";

7026 sha256 = "1qr5ihf66byq6wq3f6al1i2jrxfi107b5agwck265425mq0jaf9f";

7027 configureFlags = [

7028 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7029 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7030 "-fsplitbase" "-f-test-hlint"

7031 ];

7032 libraryHaskellDepends = [

7033 array base containers transformers void

7034 ];

7035 homepage = "http://github.com/ekmett/graphs";

7036 description = "A simple monadic graph library";

7037 license = stdenv.lib.licenses.bsd3;

7038 }) {};

7039 "gravatar" = callPackage

7040 ({ mkDerivation, base, bytestring, data-default, HTTP, pureMD5

7041 , text

7042 }:

7043 mkDerivation {

7044 pname = "gravatar";

7045 version = "0.6";

7046 sha256 = "035qhrk0s4bpv9xvji4j7w2r98gppn2armz4wjdjy8f50anjpfw3";

7047 configureFlags = [

7048 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7049 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7050 "-fsplitbase" "-f-test-hlint"

7051 ];

7052 libraryHaskellDepends = [

7053 base bytestring data-default HTTP pureMD5 text

7054 ];

7055 homepage = "http://github.com/pbrisbin/gravatar";

7056 description = "Look up gravatar image urls by email address";

7057 license = stdenv.lib.licenses.bsd3;

7058 }) {};

7059 "groundhog" = callPackage

7060 ({ mkDerivation, aeson, attoparsec, base, base64-bytestring

7061 , blaze-builder, bytestring, containers, monad-control

7062 , monad-logger, mtl, scientific, text, time, transformers

7063 , transformers-base

7064 }:

7065 mkDerivation {

7066 pname = "groundhog";

7067 version = "0.7.0.3";

7068 sha256 = "0n5c501wfyqcl1iy4017yyxp95kz7mb4lgc0mjjk9si36ixkww9r";

7069 revision = "2";

7070 editedCabalFile = "1zzk6q800yl20hdg1wy0224lclj45n88k6aqskc6mbzady3zg8ml";

7071 configureFlags = [

7072 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7073 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7074 "-fsplitbase" "-f-test-hlint"

7075 ];

7076 libraryHaskellDepends = [

7077 aeson attoparsec base base64-bytestring blaze-builder bytestring

7078 containers monad-control monad-logger mtl scientific text time

7079 transformers transformers-base

7080 ];

7081 homepage = "http://github.com/lykahb/groundhog";

7082 description = "Type-safe datatype-database mapping library";

7083 license = stdenv.lib.licenses.bsd3;

7084 }) {};

7085 "groundhog-mysql" = callPackage

7086 ({ mkDerivation, base, bytestring, containers, groundhog

7087 , monad-control, monad-logger, mysql, mysql-simple, resource-pool

7088 , text, time, transformers

7089 }:

7090 mkDerivation {

7091 pname = "groundhog-mysql";

7092 version = "0.7.0.1";

7093 sha256 = "01pnninva0va0pl9k7mjk2l7fm42978j9x82sj8z7cscshvl327f";

7094 configureFlags = [

7095 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7096 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7097 "-fsplitbase" "-f-test-hlint"

7098 ];

7099 libraryHaskellDepends = [

7100 base bytestring containers groundhog monad-control monad-logger

7101 mysql mysql-simple resource-pool text time transformers

7102 ];

7103 description = "MySQL backend for the groundhog library";

7104 license = stdenv.lib.licenses.bsd3;

7105 }) {};

7106 "groundhog-postgresql" = callPackage

7107 ({ mkDerivation, attoparsec, base, blaze-builder, bytestring

7108 , containers, groundhog, monad-control, monad-logger

7109 , postgresql-libpq, postgresql-simple, resource-pool, text, time

7110 , transformers

7111 }:

7112 mkDerivation {

7113 pname = "groundhog-postgresql";

7114 version = "0.7.0.2";

7115 sha256 = "18wdj51v6qqyqx10lvknr3irhs5qddvh301bx7l9cdcpkk1la81i";

7116 revision = "1";

7117 editedCabalFile = "1jlr0vf0rvg3kb39qh0swx2p37r1xqkzqr30j2fxjw6q4ycz8k01";

7118 configureFlags = [

7119 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7120 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7121 "-fsplitbase" "-f-test-hlint"

7122 ];

7123 libraryHaskellDepends = [

7124 attoparsec base blaze-builder bytestring containers groundhog

7125 monad-control monad-logger postgresql-libpq postgresql-simple

7126 resource-pool text time transformers

7127 ];

7128 description = "PostgreSQL backend for the groundhog library";

7129 license = stdenv.lib.licenses.bsd3;

7130 }) {};

7131 "groundhog-sqlite" = callPackage

7132 ({ mkDerivation, base, bytestring, containers, direct-sqlite

7133 , groundhog, monad-control, monad-logger, resource-pool, text

7134 , transformers, unordered-containers

7135 }:

7136 mkDerivation {

7137 pname = "groundhog-sqlite";

7138 version = "0.7.0.1";

7139 sha256 = "0lsm9yfapdpy4nf5bxrbjkvw9nwc82qfmyw1h9l3mc4b8nfp12dy";

7140 configureFlags = [

7141 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7142 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7143 "-fsplitbase" "-f-test-hlint"

7144 ];

7145 libraryHaskellDepends = [

7146 base bytestring containers direct-sqlite groundhog monad-control

7147 monad-logger resource-pool text transformers unordered-containers

7148 ];

7149 description = "Sqlite3 backend for the groundhog library";

7150 license = stdenv.lib.licenses.bsd3;

7151 }) {};

7152 "groundhog-th" = callPackage

7153 ({ mkDerivation, aeson, base, bytestring, containers, groundhog

7154 , template-haskell, text, time, unordered-containers, yaml

7155 }:

7156 mkDerivation {

7157 pname = "groundhog-th";

7158 version = "0.7.0";

7159 sha256 = "14g4665wrr3226m2v63p4j8g9bcyi5la7nk2vh509xyz3z17aq67";

7160 revision = "1";

7161 editedCabalFile = "1zsiahvfgqxq9kgig46l9hyarg8kwzp1j2hr4671bxs1c1ah1na1";

7162 configureFlags = [

7163 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7164 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7165 "-fsplitbase" "-f-test-hlint"

7166 ];

7167 libraryHaskellDepends = [

7168 aeson base bytestring containers groundhog template-haskell text

7169 time unordered-containers yaml

7170 ];

7171 description = "Type-safe datatype-database mapping library";

7172 license = stdenv.lib.licenses.bsd3;

7173 }) {};

7174 "groupoids" = callPackage

7175 ({ mkDerivation, base, semigroupoids }:

7176 mkDerivation {

7177 pname = "groupoids";

7178 version = "4.0";

7179 sha256 = "08la44c19pz2clws5mb939zc1d17cb6qy9qlh2n1634pl0zrawb6";

7180 configureFlags = [

7181 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7182 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7183 "-fsplitbase" "-f-test-hlint"

7184 ];

7185 libraryHaskellDepends = [ base semigroupoids ];

7186 doHaddock = false;

7187 homepage = "http://github.com/ekmett/groupoids/";

7188 description = "This package has been absorbed into semigroupoids 4.0";

7189 license = stdenv.lib.licenses.bsd3;

7190 }) {};

7191 "groups" = callPackage

7192 ({ mkDerivation, base }:

7193 mkDerivation {

7194 pname = "groups";

7195 version = "0.4.0.0";

7196 sha256 = "1kp8h3617cimya8nnadljyy4vk66dzl5nzfm900k2gh3ci8kja6k";

7197 configureFlags = [

7198 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7199 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7200 "-fsplitbase" "-f-test-hlint"

7201 ];

7202 libraryHaskellDepends = [ base ];

7203 description = "Haskell 98 groups";

7204 license = stdenv.lib.licenses.bsd3;

7205 }) {};

7206 "gtk" = callPackage

7207 ({ mkDerivation, array, base, bytestring, cairo, containers, gio

7208 , glib, gtk2, gtk2hs-buildtools, mtl, pango, text

7209 }:

7210 mkDerivation {

7211 pname = "gtk";

7212 version = "0.13.4";

7213 sha256 = "1xfcwj37jy3w9gkap1p7mw8ix9xsvpc1268nrpilp2wkch2gs7qp";

7214 configureFlags = [

7215 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7216 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7217 "-fsplitbase" "-f-test-hlint"

7218 ];

7219 enableSeparateDataOutput = true;

7220 libraryHaskellDepends = [

7221 array base bytestring cairo containers gio glib mtl pango text

7222 ];

7223 libraryPkgconfigDepends = [ gtk2 ];

7224 libraryToolDepends = [ gtk2hs-buildtools ];

7225 homepage = "http://projects.haskell.org/gtk2hs/";

7226 description = "Binding to the Gtk+ graphical user interface library";

7227 license = stdenv.lib.licenses.lgpl21;

7228 }) {gtk2 = pkgs.gnome2.gtk;};

7229 "gtk2hs-buildtools" = callPackage

7230 ({ mkDerivation, alex, array, base, containers, directory, filepath

7231 , happy, hashtables, pretty, process, random

7232 }:

7233 mkDerivation {

7234 pname = "gtk2hs-buildtools";

7235 version = "0.13.0.3";

7236 sha256 = "1ijcmcjp8mralpzl1gvh24bzq8njlzkvck1r07b010rrklv04arp";

7237 configureFlags = [

7238 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7239 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7240 "-fsplitbase" "-f-test-hlint"

7241 ];

7242 isLibrary = false;

7243 isExecutable = true;

7244 enableSeparateDataOutput = true;

7245 executableHaskellDepends = [

7246 array base containers directory filepath hashtables pretty process

7247 random

7248 ];

7249 executableToolDepends = [ alex happy ];

7250 doHaddock = false;

7251 homepage = "http://projects.haskell.org/gtk2hs/";

7252 description = "Tools to build the Gtk2Hs suite of User Interface libraries";

7253 license = stdenv.lib.licenses.gpl2;

7254 }) {};

7255 "hOpenPGP" = callPackage

7256 ({ mkDerivation, ansi-wl-pprint, attoparsec, base

7257 , base64-bytestring, bytestring, bzlib, cereal, cereal-conduit

7258 , conduit, conduit-extra, containers, crypto-cipher-types

7259 , crypto-pubkey, crypto-random, cryptocipher, cryptohash

7260 , data-default, errors, hashable, incremental-parser, ixset, lens

7261 , monad-loops, mtl, nettle, openpgp-asciiarmor, QuickCheck

7262 , quickcheck-instances, resourcet, securemem, semigroups, split

7263 , tasty, tasty-hunit, tasty-quickcheck, text, time, transformers

7264 , unordered-containers, zlib

7265 }:

7266 mkDerivation {

7267 pname = "hOpenPGP";

7268 version = "1.11";

7269 sha256 = "1alcaqx2i4a4cbmh0brb9axfsm4nb8fs4mqglh609iy3bdl791b7";

7270 configureFlags = [

7271 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7272 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7273 "-fsplitbase" "-f-test-hlint"

7274 ];

7275 libraryHaskellDepends = [

7276 ansi-wl-pprint attoparsec base base64-bytestring bytestring bzlib

7277 cereal cereal-conduit conduit conduit-extra containers

7278 crypto-cipher-types crypto-pubkey crypto-random cryptocipher

7279 cryptohash data-default errors hashable incremental-parser ixset

7280 lens monad-loops mtl nettle openpgp-asciiarmor resourcet securemem

7281 semigroups split text time transformers unordered-containers zlib

7282 ];

7283 testHaskellDepends = [

7284 ansi-wl-pprint attoparsec base bytestring bzlib cereal

7285 cereal-conduit conduit conduit-extra containers crypto-cipher-types

7286 crypto-pubkey crypto-random cryptocipher cryptohash data-default

7287 errors hashable incremental-parser ixset lens monad-loops mtl

7288 nettle QuickCheck quickcheck-instances resourcet securemem

7289 semigroups split tasty tasty-hunit tasty-quickcheck text time

7290 transformers unordered-containers zlib

7291 ];

7292 homepage = "http://floss.scru.org/hOpenPGP/";

7293 description = "native Haskell implementation of OpenPGP (RFC4880)";

7294 license = stdenv.lib.licenses.mit;

7295 }) {};

7296 "hPDB" = callPackage

7297 ({ mkDerivation, AC-Vector, base, bytestring, containers, deepseq

7298 , directory, ghc-prim, iterable, mmap, mtl, Octree, parallel

7299 , QuickCheck, tagged, template-haskell, text, vector, zlib

7300 }:

7301 mkDerivation {

7302 pname = "hPDB";

7303 version = "1.2.0.2";

7304 sha256 = "0mymyvd9p63sf3801bn2pyihj47fymp8wwfbllhbvw2l92hy79vk";

7305 configureFlags = [

7306 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7307 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7308 "-fsplitbase" "-f-test-hlint"

7309 ];

7310 libraryHaskellDepends = [

7311 AC-Vector base bytestring containers deepseq directory ghc-prim

7312 iterable mmap mtl Octree parallel QuickCheck tagged

7313 template-haskell text vector zlib

7314 ];

7315 homepage = "https://github.com/BioHaskell/hPDB";

7316 description = "Protein Databank file format library";

7317 license = stdenv.lib.licenses.bsd3;

7318 }) {};

7319 "hPDB-examples" = callPackage

7320 ({ mkDerivation, AC-Vector, base, bytestring, containers, deepseq

7321 , directory, ghc-prim, GLUT, hPDB, IfElse, iterable, mtl, Octree

7322 , OpenGL, process, QuickCheck, template-haskell, text, text-format

7323 , time, vector

7324 }:

7325 mkDerivation {

7326 pname = "hPDB-examples";

7327 version = "1.2.0.1";

7328 sha256 = "0ppwbm0ag9dd5rzpvzk89c4ykwkgvwz9fg6d3lr9vwfid15a116s";

7329 configureFlags = [

7330 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7331 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7332 "-fsplitbase" "-f-test-hlint"

7333 ];

7334 isLibrary = false;

7335 isExecutable = true;

7336 executableHaskellDepends = [

7337 AC-Vector base bytestring containers deepseq directory ghc-prim

7338 GLUT hPDB iterable mtl Octree OpenGL QuickCheck template-haskell

7339 text text-format vector

7340 ];

7341 testHaskellDepends = [

7342 AC-Vector base bytestring containers deepseq directory ghc-prim

7343 hPDB IfElse iterable mtl process template-haskell text time vector

7344 ];

7345 doHaddock = false;

7346 homepage = "https://github.com/BioHaskell/hPDB-examples";

7347 description = "Examples for hPDB library";

7348 license = stdenv.lib.licenses.bsd3;

7349 }) {};

7350 "haddock-api" = callPackage

7351 ({ mkDerivation, array, base, bytestring, Cabal, containers

7352 , deepseq, directory, filepath, ghc, ghc-paths, haddock-library

7353 , xhtml

7354 }:

7355 mkDerivation {

7356 pname = "haddock-api";

7357 version = "2.15.0.2";

7358 sha256 = "1gdmwid3qg86ql0828bp8g121psvmz11s0xivrzhiv8knxbqj8l7";

7359 configureFlags = [

7360 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7361 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7362 "-fsplitbase" "-f-test-hlint"

7363 ];

7364 enableSeparateDataOutput = true;

7365 libraryHaskellDepends = [

7366 array base bytestring Cabal containers deepseq directory filepath

7367 ghc ghc-paths haddock-library xhtml

7368 ];

7369 homepage = "http://www.haskell.org/haddock/";

7370 description = "A documentation-generation tool for Haskell libraries";

7371 license = stdenv.lib.licenses.bsd3;

7372 }) {};

7373 "haddock-library" = callPackage

7374 ({ mkDerivation, base, base-compat, bytestring, deepseq, hspec

7375 , QuickCheck

7376 }:

7377 mkDerivation {

7378 pname = "haddock-library";

7379 version = "1.1.1";

7380 sha256 = "0sjnmbmq1pss9ikcqnhvpf57rv78lzi1r99ywpmmvj1gyva2s31m";

7381 configureFlags = [

7382 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7383 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7384 "-fsplitbase" "-f-test-hlint"

7385 ];

7386 libraryHaskellDepends = [ base bytestring deepseq ];

7387 testHaskellDepends = [

7388 base base-compat bytestring deepseq hspec QuickCheck

7389 ];

7390 homepage = "http://www.haskell.org/haddock/";

7391 description = "Library exposing some functionality of Haddock";

7392 license = stdenv.lib.licenses.bsd3;

7393 }) {};

7394 "half" = callPackage

7395 ({ mkDerivation, base }:

7396 mkDerivation {

7397 pname = "half";

7398 version = "0.2.0.1";

7399 sha256 = "0lwh5bv8pnp9fzq64z1fg1i4fv8h2lcchs1298agq881hcay19qw";

7400 revision = "1";

7401 editedCabalFile = "1knc268v79zb3fs2x09gjs7fh6i24iaplpdblg4lr72xgawc1bfg";

7402 configureFlags = [

7403 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7404 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7405 "-fsplitbase" "-f-test-hlint"

7406 ];

7407 libraryHaskellDepends = [ base ];

7408 homepage = "http://github.com/ekmett/half";

7409 description = "Half-precision floating-point";

7410 license = stdenv.lib.licenses.bsd3;

7411 }) {};

7412 "happstack-server" = callPackage

7413 ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring

7414 , containers, directory, extensible-exceptions, filepath, hslogger

7415 , html, HUnit, monad-control, mtl, network, network-uri, old-locale

7416 , parsec, process, sendfile, syb, system-filepath, template-haskell

7417 , text, threads, time, time-compat, transformers, transformers-base

7418 , unix, utf8-string, xhtml, zlib

7419 }:

7420 mkDerivation {

7421 pname = "happstack-server";

7422 version = "7.3.9";

7423 sha256 = "10js2kmxw5lyy1h5xyz7qx852d29cl48qxyvadc4bdad6w06gdlz";

7424 revision = "1";

7425 editedCabalFile = "0d3pxb58abql2k80zkp0gfnsqc9dhrzv64lydnad6q9w3y1208ag";

7426 configureFlags = [

7427 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7428 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7429 "-fsplitbase" "-f-test-hlint"

7430 ];

7431 libraryHaskellDepends = [

7432 base base64-bytestring blaze-html bytestring containers directory

7433 extensible-exceptions filepath hslogger html monad-control mtl

7434 network network-uri old-locale parsec process sendfile syb

7435 system-filepath template-haskell text threads time time-compat

7436 transformers transformers-base unix utf8-string xhtml zlib

7437 ];

7438 testHaskellDepends = [

7439 base bytestring containers HUnit parsec zlib

7440 ];

7441 homepage = "http://happstack.com";

7442 description = "Web related tools and services";

7443 license = stdenv.lib.licenses.bsd3;

7444 }) {};

7445 "happy" = callPackage

7446 ({ mkDerivation, array, base, Cabal, containers, directory

7447 , filepath, mtl, process

7448 }:

7449 mkDerivation {

7450 pname = "happy";

7451 version = "1.19.5";

7452 sha256 = "1nj353q4z1g186fpjzf0dnsg71qhxqpamx8jy89rjjvv3p0kmw32";

7453 revision = "2";

7454 editedCabalFile = "1dvhv94lzmya938i5crshg9qbx7dxvkyxkhfbqimxkydxn7l2w7w";

7455 configureFlags = [

7456 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7457 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7458 "-fsplitbase" "-f-test-hlint"

7459 ];

7460 isLibrary = false;

7461 isExecutable = true;

7462 setupHaskellDepends = [ base Cabal directory filepath ];

7463 executableHaskellDepends = [ array base containers mtl ];

7464 testHaskellDepends = [ base process ];

7465 doHaddock = false;

7466 homepage = "http://www.haskell.org/happy/";

7467 description = "Happy is a parser generator for Haskell";

7468 license = stdenv.lib.licenses.bsd3;

7469 }) {};

7470 "hashable" = callPackage

7471 ({ mkDerivation, base, bytestring, criterion, ghc-prim, HUnit

7472 , integer-gmp, QuickCheck, random, siphash, test-framework

7473 , test-framework-hunit, test-framework-quickcheck2, text, unix

7474 }:

7475 mkDerivation {

7476 pname = "hashable";

7477 version = "1.2.3.2";

7478 sha256 = "0h9295pv2sgbaqlwpwbx2bap6nngm0jcdhkqham1wpjwyxqgqrlc";

7479 configureFlags = [

7480 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7481 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7482 "-fsplitbase" "-f-test-hlint"

7483 ];

7484 libraryHaskellDepends = [

7485 base bytestring ghc-prim integer-gmp text

7486 ];

7487 testHaskellDepends = [

7488 base bytestring ghc-prim HUnit QuickCheck random test-framework

7489 test-framework-hunit test-framework-quickcheck2 text unix

7490 ];

7491 benchmarkHaskellDepends = [

7492 base bytestring criterion ghc-prim integer-gmp siphash text

7493 ];

7494 homepage = "http://github.com/tibbe/hashable";

7495 description = "A class for types that can be converted to a hash value";

7496 license = stdenv.lib.licenses.bsd3;

7497 }) {};

7498 "hashable-extras" = callPackage

7499 ({ mkDerivation, base, bifunctors, bytestring, directory, doctest

7500 , filepath, generic-deriving, hashable, transformers

7501 }:

7502 mkDerivation {

7503 pname = "hashable-extras";

7504 version = "0.2.0.1";

7505 sha256 = "09y2m0wpim7sl7n9qnkr0miwfsbvb1q8lm6shpcq0jxzxknbag7s";

7506 revision = "2";

7507 editedCabalFile = "1k4f8acpd2w0mywffwpn6jipfvj3wy68jqf2ndfkcxi688lwawsg";

7508 configureFlags = [

7509 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7510 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7511 "-fsplitbase" "-f-test-hlint"

7512 ];

7513 libraryHaskellDepends = [

7514 base bifunctors bytestring generic-deriving hashable transformers

7515 ];

7516 testHaskellDepends = [ base directory doctest filepath ];

7517 homepage = "http://github.com/analytics/hashable-extras/";

7518 description = "Higher-rank Hashable";

7519 license = stdenv.lib.licenses.bsd3;

7520 }) {};

7521 "hashmap" = callPackage

7522 ({ mkDerivation, base, containers, deepseq, hashable }:

7523 mkDerivation {

7524 pname = "hashmap";

7525 version = "1.3.0.1";

7526 sha256 = "16scl1rbq0f18mggrj4lbhgkz7kzshsw9a523rjd8cjkdjz1ijwr";

7527 configureFlags = [

7528 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7529 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7530 "-fsplitbase" "-f-test-hlint"

7531 ];

7532 libraryHaskellDepends = [ base containers deepseq hashable ];

7533 homepage = "http://git.auryn.cz/haskell/hashmap/";

7534 description = "Persistent containers Map and Set based on hashing";

7535 license = stdenv.lib.licenses.bsd3;

7536 }) {};

7537 "hashtables" = callPackage

7538 ({ mkDerivation, base, ghc-prim, hashable, primitive, vector }:

7539 mkDerivation {

7540 pname = "hashtables";

7541 version = "1.2.0.2";

7542 sha256 = "0dqq5ssgkqzplqf5dmc4l8cj28j5py7i6n6a069qn4cibvxfjaq1";

7543 configureFlags = [

7544 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7545 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7546 "-fsplitbase" "-f-test-hlint"

7547 ];

7548 libraryHaskellDepends = [

7549 base ghc-prim hashable primitive vector

7550 ];

7551 homepage = "http://github.com/gregorycollins/hashtables";

7552 description = "Mutable hash tables in the ST monad";

7553 license = stdenv.lib.licenses.bsd3;

7554 }) {};

7555 "haskell-lexer" = callPackage

7556 ({ mkDerivation, base }:

7557 mkDerivation {

7558 pname = "haskell-lexer";

7559 version = "1.0";

7560 sha256 = "11jv30msg4rym73lk6j21ky2510c3av8qxk5p4z63j4m283w9l46";

7561 configureFlags = [

7562 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7563 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7564 "-fsplitbase" "-f-test-hlint"

7565 ];

7566 libraryHaskellDepends = [ base ];

7567 description = "A fully compliant Haskell 98 lexer";

7568 license = stdenv.lib.licenses.bsd3;

7569 }) {};

7570 "haskell-names" = callPackage

7571 ({ mkDerivation, aeson, base, bytestring, Cabal, containers

7572 , data-lens-light, filemanip, filepath, haskell-packages

7573 , haskell-src-exts, hse-cpp, mtl, pretty-show, tagged, tasty

7574 , tasty-golden, transformers, traverse-with-class, type-eq

7575 , uniplate, utf8-string

7576 }:

7577 mkDerivation {

7578 pname = "haskell-names";

7579 version = "0.4.1";

7580 sha256 = "1zkfq54s7n17g77sqzfhhc4bmqwdwbynz0gzwyaf3m4nmz6lkfl8";

7581 revision = "1";

7582 editedCabalFile = "0hgpfdgd00s1mb7f3yqlk6h8arvxyb312wzxvz4gx44nmlvlnryl";

7583 configureFlags = [

7584 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7585 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7586 "-fsplitbase" "-f-test-hlint"

7587 ];

7588 enableSeparateDataOutput = true;

7589 libraryHaskellDepends = [

7590 aeson base bytestring Cabal containers data-lens-light filepath

7591 haskell-packages haskell-src-exts hse-cpp mtl tagged transformers

7592 traverse-with-class type-eq uniplate

7593 ];

7594 testHaskellDepends = [

7595 aeson base bytestring Cabal containers filemanip filepath

7596 haskell-packages haskell-src-exts hse-cpp mtl pretty-show tagged

7597 tasty tasty-golden traverse-with-class uniplate utf8-string

7598 ];

7599 homepage = "http://documentup.com/haskell-suite/haskell-names";

7600 description = "Name resolution library for Haskell";

7601 license = stdenv.lib.licenses.bsd3;

7602 }) {};

7603 "haskell-packages" = callPackage

7604 ({ mkDerivation, aeson, base, bytestring, Cabal, containers

7605 , deepseq, directory, filepath, haskell-src-exts, hse-cpp, mtl

7606 , optparse-applicative, tagged, transformers, transformers-compat

7607 }:

7608 mkDerivation {

7609 pname = "haskell-packages";

7610 version = "0.2.4.4";

7611 sha256 = "1n4il9vkszr48n0zg3kccyqa744p0cc6idamdk6xb6hj0flpqzzc";

7612 revision = "1";

7613 editedCabalFile = "16f34nxp74wx8lmpjcqzk16xjajw7m92xhavmim4rk02s46mx2qd";

7614 configureFlags = [

7615 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7616 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7617 "-fsplitbase" "-f-test-hlint"

7618 ];

7619 libraryHaskellDepends = [

7620 aeson base bytestring Cabal containers deepseq directory filepath

7621 haskell-src-exts hse-cpp mtl optparse-applicative tagged

7622 transformers transformers-compat

7623 ];

7624 homepage = "http://documentup.com/haskell-suite/haskell-packages";

7625 description = "Haskell suite library for package management and integration with Cabal";

7626 license = stdenv.lib.licenses.mit;

7627 }) {};

7628 "haskell-src" = callPackage

7629 ({ mkDerivation, array, base, happy, pretty, syb }:

7630 mkDerivation {

7631 pname = "haskell-src";

7632 version = "1.0.2.0";

7633 sha256 = "19lilhpwnjb7cks9fq1ipnc8f7dwxy0ri3dgjkdxs3i355byw99a";

7634 configureFlags = [

7635 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7636 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7637 "-fsplitbase" "-f-test-hlint"

7638 ];

7639 libraryHaskellDepends = [ array base pretty syb ];

7640 libraryToolDepends = [ happy ];

7641 description = "Support for manipulating Haskell source code";

7642 license = stdenv.lib.licenses.bsd3;

7643 }) {};

7644 "haskell-src-exts" = callPackage

7645 ({ mkDerivation, array, base, containers, cpphs, directory

7646 , filepath, ghc-prim, happy, mtl, pretty, smallcheck, syb, tasty

7647 , tasty-golden, tasty-smallcheck

7648 }:

7649 mkDerivation {

7650 pname = "haskell-src-exts";

7651 version = "1.16.0.1";

7652 sha256 = "1h8gjw5g92rvvzadqzpscg73x7ajvs1wlphrh27afim3scdd8frz";

7653 configureFlags = [

7654 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7655 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7656 "-fsplitbase" "-f-test-hlint"

7657 ];

7658 libraryHaskellDepends = [ array base cpphs ghc-prim pretty ];

7659 libraryToolDepends = [ happy ];

7660 testHaskellDepends = [

7661 base containers directory filepath mtl smallcheck syb tasty

7662 tasty-golden tasty-smallcheck

7663 ];

7664 homepage = "https://github.com/haskell-suite/haskell-src-exts";

7665 description = "Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer";

7666 license = stdenv.lib.licenses.bsd3;

7667 }) {};

7668 "haskell-src-meta" = callPackage

7669 ({ mkDerivation, base, haskell-src-exts, pretty, syb

7670 , template-haskell, th-orphans

7671 }:

7672 mkDerivation {

7673 pname = "haskell-src-meta";

7674 version = "0.6.0.8";

7675 sha256 = "1fv228n9zbqa52aif7pkylrqgz2n63xhxly9f828i18xf02rmxnk";

7676 revision = "1";

7677 editedCabalFile = "12lz67xk1mc3zkqnx8r54q9m1pmi1ikmgf9v3cisy22sw5vrcq4q";

7678 configureFlags = [

7679 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7680 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7681 "-fsplitbase" "-f-test-hlint"

7682 ];

7683 libraryHaskellDepends = [

7684 base haskell-src-exts pretty syb template-haskell th-orphans

7685 ];

7686 description = "Parse source to template-haskell abstract syntax";

7687 license = stdenv.lib.licenses.bsd3;

7688 }) {};

7689 "hasql" = callPackage

7690 ({ mkDerivation, attoparsec, base, base-prelude, either

7691 , hasql-backend, list-t, mmorph, monad-control, mtl, resource-pool

7692 , template-haskell, text, transformers, transformers-base, vector

7693 }:

7694 mkDerivation {

7695 pname = "hasql";

7696 version = "0.7.2";

7697 sha256 = "1gxigzmsrn3kpp6nf4my3yz2215sgmr9021qnpvsq6mqnl6vqddg";

7698 configureFlags = [

7699 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7700 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7701 "-fsplitbase" "-f-test-hlint"

7702 ];

7703 libraryHaskellDepends = [

7704 attoparsec base base-prelude either hasql-backend list-t mmorph

7705 monad-control mtl resource-pool template-haskell text transformers

7706 transformers-base vector

7707 ];

7708 doCheck = false;

7709 homepage = "https://github.com/nikita-volkov/hasql";

7710 description = "A minimalistic general high level API for relational databases";

7711 license = stdenv.lib.licenses.mit;

7712 }) {};

7713 "hasql-backend" = callPackage

7714 ({ mkDerivation, base, base-prelude, bytestring, either, free

7715 , list-t, text, transformers, vector

7716 }:

7717 mkDerivation {

7718 pname = "hasql-backend";

7719 version = "0.4.0";

7720 sha256 = "15jzz01lmh4s6y70b01yc7ffzbicm7nxna30krra8vlp0w32lnys";

7721 configureFlags = [

7722 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7723 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7724 "-fsplitbase" "-f-test-hlint"

7725 ];

7726 libraryHaskellDepends = [

7727 base base-prelude bytestring either free list-t text transformers

7728 vector

7729 ];

7730 doCheck = false;

7731 homepage = "https://github.com/nikita-volkov/hasql-backend";

7732 description = "API for backends of \"hasql\"";

7733 license = stdenv.lib.licenses.mit;

7734 }) {};

7735 "hasql-postgres" = callPackage

7736 ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring

7737 , either, free, hashable, hashtables, hasql-backend, list-t

7738 , loch-th, mmorph, placeholders, postgresql-binary

7739 , postgresql-libpq, scientific, template-haskell, text, time

7740 , transformers, uuid, vector

7741 }:

7742 mkDerivation {

7743 pname = "hasql-postgres";

7744 version = "0.10.2";

7745 sha256 = "0nw1xq9wfdhcm40qfx8d883nvgk7bfhwbwwb1r9jx7zlspx15vq5";

7746 configureFlags = [

7747 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7748 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7749 "-fsplitbase" "-f-test-hlint"

7750 ];

7751 libraryHaskellDepends = [

7752 aeson attoparsec base base-prelude bytestring either free hashable

7753 hashtables hasql-backend list-t loch-th mmorph placeholders

7754 postgresql-binary postgresql-libpq scientific template-haskell text

7755 time transformers uuid vector

7756 ];

7757 doCheck = false;

7758 homepage = "https://github.com/nikita-volkov/hasql-postgres";

7759 description = "A \"PostgreSQL\" backend for the \"hasql\" library";

7760 license = stdenv.lib.licenses.mit;

7761 }) {};

7762 "hastache" = callPackage

7763 ({ mkDerivation, base, blaze-builder, bytestring, containers

7764 , directory, filepath, HUnit, ieee754, mtl, process, syb, text

7765 , transformers

7766 }:

7767 mkDerivation {

7768 pname = "hastache";

7769 version = "0.6.1";

7770 sha256 = "0r5l8k157pgvz1ck4lfid5x05f2s0nlmwf33f4fj09b1kmk8k3wc";

7771 revision = "5";

7772 editedCabalFile = "0fwd1jd6sqkscmy2yq1w3dcl4va4w9n8mhs6ldrilh1cj6b54r3f";

7773 configureFlags = [

7774 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7775 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7776 "-fsplitbase" "-f-test-hlint"

7777 ];

7778 isLibrary = true;

7779 isExecutable = true;

7780 libraryHaskellDepends = [

7781 base blaze-builder bytestring containers directory filepath ieee754

7782 mtl syb text transformers

7783 ];

7784 executableHaskellDepends = [

7785 base blaze-builder bytestring containers directory filepath ieee754

7786 mtl process syb text transformers

7787 ];

7788 testHaskellDepends = [

7789 base bytestring directory HUnit mtl syb text

7790 ];

7791 homepage = "http://github.com/lymar/hastache";

7792 description = "Haskell implementation of Mustache templates";

7793 license = stdenv.lib.licenses.bsd3;

7794 }) {};

7795 "haxr" = callPackage

7796 ({ mkDerivation, array, base, base64-bytestring, blaze-builder

7797 , bytestring, HaXml, HTTP, mtl, network, network-uri, old-locale

7798 , old-time, template-haskell, time, utf8-string

7799 }:

7800 mkDerivation {

7801 pname = "haxr";

7802 version = "3000.10.3.1";

7803 sha256 = "0alvrsk85f1l79hfa9shagjckp4sx835l9734ab2izfv50mxx7gm";

7804 revision = "1";

7805 editedCabalFile = "060r24v3x8idc07ji22z7aq53h2mw3k2vv8kyn7k4q5f4b8q26li";

7806 configureFlags = [

7807 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7808 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7809 "-fsplitbase" "-f-test-hlint"

7810 ];

7811 libraryHaskellDepends = [

7812 array base base64-bytestring blaze-builder bytestring HaXml HTTP

7813 mtl network network-uri old-locale old-time template-haskell time

7814 utf8-string

7815 ];

7816 homepage = "http://www.haskell.org/haskellwiki/HaXR";

7817 description = "XML-RPC client and server library";

7818 license = stdenv.lib.licenses.bsd3;

7819 }) {};

7820 "hdaemonize" = callPackage

7821 ({ mkDerivation, base, extensible-exceptions, filepath, hsyslog

7822 , mtl, unix

7823 }:

7824 mkDerivation {

7825 pname = "hdaemonize";

7826 version = "0.5.0.0";

7827 sha256 = "15dyaa9rbmsjp3sg9yxg1i90kfy9rvlzmwg5kl8kwal69ajzjjgv";

7828 configureFlags = [

7829 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7830 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7831 "-fsplitbase" "-f-test-hlint"

7832 ];

7833 libraryHaskellDepends = [

7834 base extensible-exceptions filepath hsyslog mtl unix

7835 ];

7836 homepage = "http://github.com/madhadron/hdaemonize";

7837 description = "Library to handle the details of writing daemons for UNIX";

7838 license = stdenv.lib.licenses.bsd3;

7839 }) {};

7840 "hdevtools" = callPackage

7841 ({ mkDerivation, base, Cabal, cmdargs, directory, filepath, ghc

7842 , ghc-paths, network, syb, time, unix

7843 }:

7844 mkDerivation {

7845 pname = "hdevtools";

7846 version = "0.1.0.6";

7847 sha256 = "1plpkdhjv2493zy7fdn3a6cwdava0yrqqkzyn3wddi9f70xd62ak";

7848 configureFlags = [

7849 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7850 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7851 "-fsplitbase" "-f-test-hlint"

7852 ];

7853 isLibrary = false;

7854 isExecutable = true;

7855 executableHaskellDepends = [

7856 base Cabal cmdargs directory filepath ghc ghc-paths network syb

7857 time unix

7858 ];

7859 doHaddock = false;

7860 homepage = "https://github.com/bitc/hdevtools/";

7861 description = "Persistent GHC powered background server for FAST haskell development tools";

7862 license = stdenv.lib.licenses.mit;

7863 }) {};

7864 "heap" = callPackage

7865 ({ mkDerivation, base, QuickCheck }:

7866 mkDerivation {

7867 pname = "heap";

7868 version = "1.0.2";

7869 sha256 = "1xwgdx4m558m2xqmqnskkbja9s1lqm131xphjgk0yclsk0sv8was";

7870 revision = "1";

7871 editedCabalFile = "0chkmbp92y2izcdllwh1xph1q0vpa40qm4ww068j9w0r4n0fqdx8";

7872 isLibrary = true;

7873 isExecutable = true;

7874 libraryHaskellDepends = [ base ];

7875 executableHaskellDepends = [ base QuickCheck ];

7876 description = "Heaps in Haskell";

7877 license = stdenv.lib.licenses.bsd3;

7878 }) {};

7879 "heaps" = callPackage

7880 ({ mkDerivation, base, directory, doctest, filepath }:

7881 mkDerivation {

7882 pname = "heaps";

7883 version = "0.3.2";

7884 sha256 = "1xkb2lk97ymgjxk89159h226qs89z5wank4jx35awwzv4f67ay46";

7885 configureFlags = [

7886 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7887 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7888 "-fsplitbase" "-f-test-hlint"

7889 ];

7890 libraryHaskellDepends = [ base ];

7891 testHaskellDepends = [ base directory doctest filepath ];

7892 homepage = "http://github.com/ekmett/heaps/";

7893 description = "Asymptotically optimal Brodal/Okasaki heaps";

7894 license = stdenv.lib.licenses.bsd3;

7895 }) {};

7896 "hebrew-time" = callPackage

7897 ({ mkDerivation, base, HUnit, QuickCheck, test-framework

7898 , test-framework-hunit, test-framework-quickcheck2, time

7899 }:

7900 mkDerivation {

7901 pname = "hebrew-time";

7902 version = "0.1.1";

7903 sha256 = "0ckridxf4rvhhp0k1mckbbbpzfs32l4mwg7n9mrmsggldpl7x6f7";

7904 configureFlags = [

7905 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7906 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7907 "-fsplitbase" "-f-test-hlint"

7908 ];

7909 libraryHaskellDepends = [ base time ];

7910 testHaskellDepends = [

7911 base HUnit QuickCheck test-framework test-framework-hunit

7912 test-framework-quickcheck2 time

7913 ];

7914 homepage = "https://github.com/snoyberg/hebrew-time";

7915 description = "Hebrew dates and prayer times";

7916 license = stdenv.lib.licenses.mit;

7917 }) {};

7918 "heist" = callPackage

7919 ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html

7920 , bytestring, containers, directory, directory-tree, dlist, errors

7921 , filepath, hashable, map-syntax, MonadCatchIO-transformers, mtl

7922 , process, random, text, time, transformers, unordered-containers

7923 , vector, xmlhtml

7924 }:

7925 mkDerivation {

7926 pname = "heist";

7927 version = "0.14.1";

7928 sha256 = "11g6nrg9xn9ypwrz7mj3hqjhg45ia1miihh1ydls7vfdm2fqlagy";

7929 revision = "4";

7930 editedCabalFile = "0xl84i16lir9r6422dl94hc26yh3c7khy03rc6s1431n9d7mn7fn";

7931 configureFlags = [

7932 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7933 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7934 "-fsplitbase" "-f-test-hlint"

7935 ];

7936 libraryHaskellDepends = [

7937 aeson attoparsec base blaze-builder blaze-html bytestring

7938 containers directory directory-tree dlist errors filepath hashable

7939 map-syntax MonadCatchIO-transformers mtl process random text time

7940 transformers unordered-containers vector xmlhtml

7941 ];

7942 homepage = "http://snapframework.com/";

7943 description = "An Haskell template system supporting both HTML5 and XML";

7944 license = stdenv.lib.licenses.bsd3;

7945 }) {};

7946 "here" = callPackage

7947 ({ mkDerivation, base, haskell-src-meta, mtl, parsec

7948 , template-haskell

7949 }:

7950 mkDerivation {

7951 pname = "here";

7952 version = "1.2.7";

7953 sha256 = "1fqjqzfg3fif67ic75pavsnfjb9lxk5cf82chxs2hrkx41gm4gr6";

7954 configureFlags = [

7955 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7956 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7957 "-fsplitbase" "-f-test-hlint"

7958 ];

7959 libraryHaskellDepends = [

7960 base haskell-src-meta mtl parsec template-haskell

7961 ];

7962 homepage = "https://github.com/tmhedberg/here";

7963 description = "Here docs & interpolated strings via quasiquotation";

7964 license = stdenv.lib.licenses.bsd3;

7965 }) {};

7966 "heredoc" = callPackage

7967 ({ mkDerivation, base, template-haskell }:

7968 mkDerivation {

7969 pname = "heredoc";

7970 version = "0.2.0.0";

7971 sha256 = "0h0g2f7yscwl1ba1yn3jnz2drvd6ns9m910hwlmq3kdq3k39y3f9";

7972 configureFlags = [

7973 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7974 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7975 "-fsplitbase" "-f-test-hlint"

7976 ];

7977 libraryHaskellDepends = [ base template-haskell ];

7978 homepage = "http://hackage.haskell.org/package/heredoc";

7979 description = "multi-line string / here document using QuasiQuotes";

7980 license = stdenv.lib.licenses.publicDomain;

7981 }) {};

7982 "hflags" = callPackage

7983 ({ mkDerivation, base, containers, template-haskell, text }:

7984 mkDerivation {

7985 pname = "hflags";

7986 version = "0.4";

7987 sha256 = "17zzx273kmnwwazmmns78cllz3l7wad1gi7hizgcxi68j04blhd4";

7988 revision = "1";

7989 editedCabalFile = "0n3cyff2gwvbz9xd9iyz75jwdd4asd6n52s7w8sf9hcl78vkdycj";

7990 configureFlags = [

7991 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

7992 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

7993 "-fsplitbase" "-f-test-hlint"

7994 ];

7995 libraryHaskellDepends = [ base containers template-haskell text ];

7996 homepage = "http://github.com/errge/hflags";

7997 description = "Command line flag parser, very similar to Google's gflags";

7998 license = "unknown";

7999 }) {};

8000 "highlighting-kate" = callPackage

8001 ({ mkDerivation, base, blaze-html, containers, Diff, directory

8002 , filepath, mtl, parsec, process, regex-pcre-builtin, utf8-string

8003 }:

8004 mkDerivation {

8005 pname = "highlighting-kate";

8006 version = "0.5.12";

8007 sha256 = "0igcph3icmskf2g861fmxwgjdgrm52r5zazviiv82wck8nvmkh0i";

8008 revision = "1";

8009 editedCabalFile = "0dd326v816zhb7cmrpm7ag5jdlz5g611lsh3d6m64lslvwk1s8dx";

8010 configureFlags = [

8011 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8012 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8013 "-fsplitbase" "-f-test-hlint"

8014 ];

8015 isLibrary = true;

8016 isExecutable = true;

8017 libraryHaskellDepends = [

8018 base blaze-html containers mtl parsec regex-pcre-builtin

8019 utf8-string

8020 ];

8021 executableHaskellDepends = [ base blaze-html containers filepath ];

8022 testHaskellDepends = [

8023 base blaze-html containers Diff directory filepath process

8024 ];

8025 homepage = "http://github.com/jgm/highlighting-kate";

8026 description = "Syntax highlighting";

8027 license = "GPL";

8028 }) {};

8029 "hinotify" = callPackage

8030 ({ mkDerivation, base, containers, directory, unix }:

8031 mkDerivation {

8032 pname = "hinotify";

8033 version = "0.3.7";

8034 sha256 = "0i7mxg9ilzcgijda6j3ya5xnpbxa3wm9xswdfif95jim9w82sw0b";

8035 configureFlags = [

8036 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8037 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8038 "-fsplitbase" "-f-test-hlint"

8039 ];

8040 libraryHaskellDepends = [ base containers directory unix ];

8041 homepage = "https://github.com/kolmodin/hinotify.git";

8042 description = "Haskell binding to inotify";

8043 license = stdenv.lib.licenses.bsd3;

8044 }) {};

8045 "hint" = callPackage

8046 ({ mkDerivation, base, directory, exceptions, extensible-exceptions

8047 , filepath, ghc, ghc-mtl, ghc-paths, HUnit, mtl, random, unix

8048 }:

8049 mkDerivation {

8050 pname = "hint";

8051 version = "0.4.2.2";

8052 sha256 = "1gv4nmwqp8xxvz90g9k48bixpc3cabx8591vj1zv6aah8fbng06w";

8053 revision = "1";

8054 editedCabalFile = "1s1pvw3n5dgx6z5w9lwq7jr9r1c4wk0c4yn4j7b968c5q0j28dvi";

8055 configureFlags = [

8056 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8057 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8058 "-fsplitbase" "-f-test-hlint"

8059 ];

8060 libraryHaskellDepends = [

8061 base directory exceptions extensible-exceptions filepath ghc

8062 ghc-mtl ghc-paths mtl random unix

8063 ];

8064 testHaskellDepends = [

8065 base directory exceptions extensible-exceptions filepath HUnit mtl

8066 ];

8067 homepage = "http://hub.darcs.net/jcpetruzza/hint";

8068 description = "Runtime Haskell interpreter (GHC API wrapper)";

8069 license = stdenv.lib.licenses.bsd3;

8070 }) {};

8071 "histogram-fill" = callPackage

8072 ({ mkDerivation, base, criterion, deepseq, ghc-prim

8073 , monad-primitive, mwc-random, primitive, vector

8074 }:

8075 mkDerivation {

8076 pname = "histogram-fill";

8077 version = "0.8.4.1";

8078 sha256 = "0zamqza4ky90l27sjgv55rp7s1g4hs0k0qn2qza7lfwk991ijn9q";

8079 configureFlags = [

8080 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8081 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8082 "-fsplitbase" "-f-test-hlint"

8083 ];

8084 libraryHaskellDepends = [

8085 base deepseq ghc-prim monad-primitive primitive vector

8086 ];

8087 benchmarkHaskellDepends = [ base criterion mwc-random vector ];

8088 homepage = "https://github.com/Shimuuar/histogram-fill/";

8089 description = "Library for histograms creation";

8090 license = stdenv.lib.licenses.bsd3;

8091 }) {};

8092 "hit" = callPackage

8093 ({ mkDerivation, attoparsec, base, byteable, bytedump, bytestring

8094 , containers, cryptohash, hourglass, mtl, parsec, patience, random

8095 , system-fileio, system-filepath, tasty, tasty-quickcheck

8096 , unix-compat, utf8-string, vector, zlib, zlib-bindings

8097 }:

8098 mkDerivation {

8099 pname = "hit";

8100 version = "0.6.3";

8101 sha256 = "0wg44vgd5jzi0r0vg8k5zrvlr7rcrb4nrp862c6y991941qv71nv";

8102 configureFlags = [

8103 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8104 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8105 "-fsplitbase" "-f-test-hlint"

8106 ];

8107 isLibrary = true;

8108 isExecutable = true;

8109 enableSeparateDataOutput = true;

8110 libraryHaskellDepends = [

8111 attoparsec base byteable bytestring containers cryptohash hourglass

8112 mtl parsec patience random system-fileio system-filepath

8113 unix-compat utf8-string vector zlib zlib-bindings

8114 ];

8115 testHaskellDepends = [

8116 base bytedump bytestring hourglass tasty tasty-quickcheck

8117 ];

8118 homepage = "http://github.com/vincenthz/hit";

8119 description = "Git operations in haskell";

8120 license = stdenv.lib.licenses.bsd3;

8121 }) {};

8122 "hjsmin" = callPackage

8123 ({ mkDerivation, base, blaze-builder, bytestring, Cabal, containers

8124 , HUnit, language-javascript, optparse-applicative, QuickCheck

8125 , test-framework, test-framework-hunit, text

8126 }:

8127 mkDerivation {

8128 pname = "hjsmin";

8129 version = "0.1.4.7";

8130 sha256 = "1gw9is6piqrqxnrwp8v3vij90icmym58rxqnnklrcjfi3ai7y58f";

8131 revision = "1";

8132 editedCabalFile = "0895ki6x963h6x1vq4r91rgfig952rryy0qz88vkhgd19wgza94b";

8133 configureFlags = [

8134 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8135 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8136 "-fsplitbase" "-f-test-hlint"

8137 ];

8138 isLibrary = true;

8139 isExecutable = true;

8140 libraryHaskellDepends = [

8141 base blaze-builder bytestring containers language-javascript text

8142 ];

8143 executableHaskellDepends = [

8144 base blaze-builder bytestring containers language-javascript

8145 optparse-applicative text

8146 ];

8147 testHaskellDepends = [

8148 base blaze-builder bytestring Cabal containers HUnit

8149 language-javascript QuickCheck test-framework test-framework-hunit

8150 text

8151 ];

8152 homepage = "http://github.com/alanz/hjsmin";

8153 description = "Haskell implementation of a javascript minifier";

8154 license = stdenv.lib.licenses.bsd3;

8155 }) {};

8156 "hledger" = callPackage

8157 ({ mkDerivation, base, cmdargs, containers, csv, directory

8158 , filepath, haskeline, hledger-lib, html, HUnit, mtl, old-locale

8159 , old-time, parsec, pretty-show, process, regex-tdfa, regexpr, safe

8160 , shakespeare, shakespeare-text, split, tabular, test-framework

8161 , test-framework-hunit, text, time, transformers, utf8-string

8162 , wizards

8163 }:

8164 mkDerivation {

8165 pname = "hledger";

8166 version = "0.24.1";

8167 sha256 = "0k09bdr3y975581mpqpmg4jynghl8v4j2386nzqprh0k6a602nv8";

8168 configureFlags = [

8169 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8170 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8171 "-fsplitbase" "-f-test-hlint"

8172 ];

8173 isLibrary = true;

8174 isExecutable = true;

8175 libraryHaskellDepends = [

8176 base cmdargs containers csv directory filepath haskeline

8177 hledger-lib HUnit mtl old-locale old-time parsec pretty-show

8178 process regex-tdfa regexpr safe shakespeare shakespeare-text split

8179 tabular text time utf8-string wizards

8180 ];

8181 executableHaskellDepends = [

8182 base cmdargs containers csv directory filepath haskeline

8183 hledger-lib HUnit mtl old-locale old-time parsec pretty-show

8184 process regex-tdfa regexpr safe shakespeare shakespeare-text split

8185 tabular text time utf8-string wizards

8186 ];

8187 testHaskellDepends = [

8188 base cmdargs containers csv directory filepath haskeline

8189 hledger-lib HUnit mtl old-locale old-time parsec pretty-show

8190 process regex-tdfa regexpr safe shakespeare shakespeare-text split

8191 tabular test-framework test-framework-hunit text time transformers

8192 wizards

8193 ];

8194 benchmarkHaskellDepends = [

8195 base directory filepath hledger-lib html old-locale process tabular

8196 time

8197 ];

8198 homepage = "http://hledger.org";

8199 description = "The main command-line interface for the hledger accounting tool";

8200 license = "GPL";

8201 }) {};

8202 "hledger-lib" = callPackage

8203 ({ mkDerivation, array, base, blaze-markup, bytestring, cmdargs

8204 , containers, csv, Decimal, directory, filepath, HUnit, mtl

8205 , old-locale, old-time, parsec, pretty-show, regex-tdfa, regexpr

8206 , safe, split, test-framework, test-framework-hunit, time

8207 , transformers, utf8-string

8208 }:

8209 mkDerivation {

8210 pname = "hledger-lib";

8211 version = "0.24.1";

8212 sha256 = "1clzy72f34b497hsjkfjpgkhmn0dl19an9j4r11mn2q8z06106nc";

8213 configureFlags = [

8214 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8215 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8216 "-fsplitbase" "-f-test-hlint"

8217 ];

8218 libraryHaskellDepends = [

8219 array base blaze-markup bytestring cmdargs containers csv Decimal

8220 directory filepath HUnit mtl old-locale old-time parsec pretty-show

8221 regex-tdfa regexpr safe split time transformers utf8-string

8222 ];

8223 testHaskellDepends = [

8224 array base blaze-markup cmdargs containers csv Decimal directory

8225 filepath HUnit mtl old-locale old-time parsec pretty-show

8226 regex-tdfa regexpr safe split test-framework test-framework-hunit

8227 time transformers

8228 ];

8229 homepage = "http://hledger.org";

8230 description = "Core data types, parsers and utilities for the hledger accounting tool";

8231 license = "GPL";

8232 }) {};

8233 "hlibgit2" = callPackage

8234 ({ mkDerivation, base, bindings-DSL, git, openssl, process, zlib }:

8235 mkDerivation {

8236 pname = "hlibgit2";

8237 version = "0.18.0.14";

8238 sha256 = "0fxglcgi0iwj9xqgx1f3dixia9pqfzz0yq9iq7flaggpr9pvn3n0";

8239 configureFlags = [

8240 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8241 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8242 "-fsplitbase" "-f-test-hlint"

8243 ];

8244 libraryHaskellDepends = [ base bindings-DSL zlib ];

8245 librarySystemDepends = [ openssl ];

8246 testHaskellDepends = [ base process ];

8247 testToolDepends = [ git ];

8248 description = "Low-level bindings to libgit2";

8249 license = stdenv.lib.licenses.mit;

8250 }) {inherit (pkgs) git; inherit (pkgs) openssl;};

8251 "hlint" = callPackage

8252 ({ mkDerivation, ansi-terminal, base, cmdargs, containers, cpphs

8253 , directory, extra, filepath, haskell-src-exts, hscolour, process

8254 , transformers, uniplate

8255 }:

8256 mkDerivation {

8257 pname = "hlint";

8258 version = "1.9.16";

8259 sha256 = "11ykjslyr8sgpa1jpnv3vdzz0nxyrxw3mzcsdbidgzw7aphpzcb3";

8260 revision = "1";

8261 editedCabalFile = "12ib3139al1sjn0yq3yp9p8lsqhxq1zb6i26vym33x3qxybl6gsf";

8262 configureFlags = [

8263 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8264 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8265 "-fsplitbase" "-f-test-hlint"

8266 ];

8267 isLibrary = true;

8268 isExecutable = true;

8269 enableSeparateDataOutput = true;

8270 libraryHaskellDepends = [

8271 ansi-terminal base cmdargs containers cpphs directory extra

8272 filepath haskell-src-exts hscolour process transformers uniplate

8273 ];

8274 executableHaskellDepends = [ base ];

8275 homepage = "http://community.haskell.org/~ndm/hlint/";

8276 description = "Source code suggestions";

8277 license = stdenv.lib.licenses.bsd3;

8278 }) {};

8279 "hmatrix" = callPackage

8280 ({ mkDerivation, array, base, binary, blas, bytestring, deepseq

8281 , liblapack, random, split, storable-complex, vector

8282 }:

8283 mkDerivation {

8284 pname = "hmatrix";

8285 version = "0.16.1.5";

8286 sha256 = "1da1iy2rzz51l69nixacsl7gqhkzld1w8z5h0klkha3mcnf1kkkq";

8287 revision = "1";

8288 editedCabalFile = "0im6bsyssw4fmb177j2jpprhn1g2hmanlrb7df5vkzp5mgpplgzf";

8289 configureFlags = [

8290 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8291 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8292 "-fsplitbase" "-f-test-hlint"

8293 ];

8294 libraryHaskellDepends = [

8295 array base binary bytestring deepseq random split storable-complex

8296 vector

8297 ];

8298 librarySystemDepends = [ blas liblapack ];

8299 preConfigure = "sed -i hmatrix.cabal -e '/\\/usr\\//D'";

8300 homepage = "https://github.com/albertoruiz/hmatrix";

8301 description = "Numeric Linear Algebra";

8302 license = stdenv.lib.licenses.bsd3;

8303 }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};

8304 "hmatrix-gsl" = callPackage

8305 ({ mkDerivation, array, base, gsl, hmatrix, process, random, vector

8306 }:

8307 mkDerivation {

8308 pname = "hmatrix-gsl";

8309 version = "0.16.0.3";

8310 sha256 = "07hg9rfrr1029n9q8xyicyh4rr9x4c02cqn1xxnks9p9qyccf4kg";

8311 configureFlags = [

8312 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8313 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8314 "-fsplitbase" "-f-test-hlint"

8315 ];

8316 libraryHaskellDepends = [

8317 array base hmatrix process random vector

8318 ];

8319 libraryPkgconfigDepends = [ gsl ];

8320 homepage = "https://github.com/albertoruiz/hmatrix";

8321 description = "Numerical computation";

8322 license = "GPL";

8323 }) {inherit (pkgs) gsl;};

8324 "hoauth2" = callPackage

8325 ({ mkDerivation, aeson, base, bytestring, bytestring-show

8326 , http-conduit, http-types, monad-control, mtl, random, text

8327 , transformers

8328 }:

8329 mkDerivation {

8330 pname = "hoauth2";

8331 version = "0.4.3";

8332 sha256 = "1qmhk9h3rwp29dsjqbgsma4zgzdd6cw1jcryzd17rk32biiiylvg";

8333 configureFlags = [

8334 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8335 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8336 "-fsplitbase" "-f-test-hlint"

8337 ];

8338 isLibrary = true;

8339 isExecutable = true;

8340 libraryHaskellDepends = [

8341 aeson base bytestring bytestring-show http-conduit http-types

8342 monad-control mtl random text transformers

8343 ];

8344 executableHaskellDepends = [

8345 aeson base bytestring http-conduit http-types text

8346 ];

8347 homepage = "https://github.com/freizl/hoauth2";

8348 description = "hoauth2";

8349 license = stdenv.lib.licenses.bsd3;

8350 }) {};

8351 "holy-project" = callPackage

8352 ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal

8353 , directory, filepath, hastache, http-conduit, HUnit, lens

8354 , lens-aeson, process, QuickCheck, random, smallcheck, split, syb

8355 , tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck, text

8356 , time, unix

8357 }:

8358 mkDerivation {

8359 pname = "holy-project";

8360 version = "0.1.1.1";

8361 sha256 = "0vb4mlz6gb01aadm2b8kgvgnrwwvl6q4ndx6xldi0xi3rm22xkwj";

8362 configureFlags = [

8363 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8364 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8365 "-fsplitbase" "-f-test-hlint"

8366 ];

8367 isLibrary = true;

8368 isExecutable = true;

8369 enableSeparateDataOutput = true;

8370 libraryHaskellDepends = [

8371 aeson ansi-terminal base bytestring directory filepath hastache

8372 http-conduit lens lens-aeson process random split syb text time

8373 unix

8374 ];

8375 executableHaskellDepends = [

8376 aeson ansi-terminal base bytestring Cabal directory filepath

8377 hastache http-conduit HUnit lens lens-aeson process QuickCheck

8378 random smallcheck split syb tasty tasty-hunit tasty-quickcheck

8379 tasty-smallcheck text time unix

8380 ];

8381 testHaskellDepends = [

8382 base bytestring Cabal HUnit QuickCheck smallcheck tasty tasty-hunit

8383 tasty-quickcheck tasty-smallcheck

8384 ];

8385 homepage = "http://github.com/yogsototh/holy-project";

8386 description = "Start your Haskell project with cabal, git and tests";

8387 license = stdenv.lib.licenses.mit;

8388 }) {};

8389 "hoogle" = callPackage

8390 ({ mkDerivation, aeson, array, base, binary, blaze-builder

8391 , bytestring, Cabal, case-insensitive, cmdargs, conduit, containers

8392 , deepseq, directory, filepath, haskell-src-exts, http-types

8393 , old-locale, parsec, process, QuickCheck, random, resourcet, safe

8394 , shake, tagsoup, temporary, text, time, transformers, uniplate

8395 , unix, vector, vector-algorithms, wai, warp

8396 }:

8397 mkDerivation {

8398 pname = "hoogle";

8399 version = "4.2.39";

8400 sha256 = "0n3sh13lhg9aip1390by0wfdfsrnqz61zgs6ji143ak7fdff1559";

8401 configureFlags = [

8402 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8403 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8404 "-fsplitbase" "-f-test-hlint"

8405 ];

8406 isLibrary = true;

8407 isExecutable = true;

8408 enableSeparateDataOutput = true;

8409 libraryHaskellDepends = [

8410 array base binary blaze-builder bytestring case-insensitive conduit

8411 containers deepseq directory filepath haskell-src-exts http-types

8412 parsec process QuickCheck random resourcet safe text transformers

8413 uniplate unix vector vector-algorithms wai

8414 ];

8415 executableHaskellDepends = [

8416 aeson array base binary blaze-builder bytestring Cabal

8417 case-insensitive cmdargs conduit containers deepseq directory

8418 filepath haskell-src-exts http-types old-locale parsec process

8419 QuickCheck random resourcet safe shake tagsoup text time

8420 transformers uniplate unix vector vector-algorithms wai warp

8421 ];

8422 testHaskellDepends = [ base directory filepath process temporary ];

8423 testTarget = "--test-option=--no-net";

8424 homepage = "http://www.haskell.org/hoogle/";

8425 description = "Haskell API Search";

8426 license = stdenv.lib.licenses.bsd3;

8427 }) {};

8428 "hostname" = callPackage

8429 ({ mkDerivation, base }:

8430 mkDerivation {

8431 pname = "hostname";

8432 version = "1.0";

8433 sha256 = "0p6gm4328946qxc295zb6vhwhf07l1fma82vd0siylnsnsqxlhwv";

8434 configureFlags = [

8435 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8436 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8437 "-fsplitbase" "-f-test-hlint"

8438 ];

8439 libraryHaskellDepends = [ base ];

8440 description = "A very simple package providing a cross-platform means of determining the hostname";

8441 license = stdenv.lib.licenses.bsd3;

8442 }) {};

8443 "hostname-validate" = callPackage

8444 ({ mkDerivation, attoparsec, base, bytestring }:

8445 mkDerivation {

8446 pname = "hostname-validate";

8447 version = "1.0.0";

8448 sha256 = "0my8g4kqf9mz7ii79ff53rwkx3yv9kkn4jbm60q4b7g1rzhb3bvz";

8449 configureFlags = [

8450 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8451 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8452 "-fsplitbase" "-f-test-hlint"

8453 ];

8454 libraryHaskellDepends = [ attoparsec base bytestring ];

8455 description = "Validate hostnames e.g. localhost or foo.co.uk.";

8456 license = stdenv.lib.licenses.bsd3;

8457 }) {};

8458 "hourglass" = callPackage

8459 ({ mkDerivation, base, bytestring, criterion, deepseq, mtl

8460 , old-locale, tasty, tasty-hunit, tasty-quickcheck, time

8461 }:

8462 mkDerivation {

8463 pname = "hourglass";

8464 version = "0.2.8";

8465 sha256 = "1n5kffmf9qnr2zy6igck7rlrw0gx5lqc92n1lajpa8vq96qzx7lj";

8466 revision = "1";

8467 editedCabalFile = "1dcl32rg27yd94m751cawq1cfgdllb1f3gdxa3nxd7xgcfdvl8yz";

8468 configureFlags = [

8469 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8470 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8471 "-fsplitbase" "-f-test-hlint"

8472 ];

8473 libraryHaskellDepends = [ base deepseq ];

8474 testHaskellDepends = [

8475 base deepseq mtl old-locale tasty tasty-hunit tasty-quickcheck time

8476 ];

8477 benchmarkHaskellDepends = [

8478 base bytestring criterion deepseq mtl old-locale time

8479 ];

8480 homepage = "https://github.com/vincenthz/hs-hourglass";

8481 description = "simple performant time related library";

8482 license = stdenv.lib.licenses.bsd3;

8483 }) {};

8484 "hs-bibutils" = callPackage

8485 ({ mkDerivation, base, syb }:

8486 mkDerivation {

8487 pname = "hs-bibutils";

8488 version = "5.5";

8489 sha256 = "0pf5lh179rw9jkmw16ss3kiwydlj6zgfk868mjl5s57kx55z7ycm";

8490 configureFlags = [

8491 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8492 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8493 "-fsplitbase" "-f-test-hlint"

8494 ];

8495 libraryHaskellDepends = [ base syb ];

8496 homepage = "http://istitutocolli.org/repos/hs-bibutils/";

8497 description = "Haskell bindings to bibutils, the bibliography conversion utilities";

8498 license = "GPL";

8499 }) {};

8500 "hscolour" = callPackage

8501 ({ mkDerivation, base, containers }:

8502 mkDerivation {

8503 pname = "hscolour";

8504 version = "1.20.3";

8505 sha256 = "15ix93sw4p7g5ln2halcgqppdc0i0vmkzcjzxvqzkk9yp9pq3nrs";

8506 configureFlags = [

8507 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8508 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8509 "-fsplitbase" "-f-test-hlint"

8510 ];

8511 isLibrary = true;

8512 isExecutable = true;

8513 enableSeparateDataOutput = true;

8514 libraryHaskellDepends = [ base containers ];

8515 executableHaskellDepends = [ base containers ];

8516 homepage = "http://code.haskell.org/~malcolm/hscolour/";

8517 description = "Colourise Haskell code";

8518 license = "GPL";

8519 }) {};

8520 "hse-cpp" = callPackage

8521 ({ mkDerivation, base, cpphs, haskell-src-exts }:

8522 mkDerivation {

8523 pname = "hse-cpp";

8524 version = "0.1";

8525 sha256 = "0f1bgi1hnpnry1pm7jhi626afdvymzy7k0a70n07n41js46pjxd0";

8526 revision = "1";

8527 editedCabalFile = "0jrav7kl7a3a421xhaqh03jvj7qsgscpi93fpxss0q4pgq98gmcy";

8528 configureFlags = [

8529 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8530 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8531 "-fsplitbase" "-f-test-hlint"

8532 ];

8533 libraryHaskellDepends = [ base cpphs haskell-src-exts ];

8534 description = "Preprocess+parse haskell code";

8535 license = stdenv.lib.licenses.mit;

8536 }) {};

8537 "hslogger" = callPackage

8538 ({ mkDerivation, base, containers, directory, mtl, network

8539 , old-locale, process, time, unix

8540 }:

8541 mkDerivation {

8542 pname = "hslogger";

8543 version = "1.2.8";

8544 sha256 = "0i7cji7d23kv8m0vr32ws8zm4ah5vxzb1ykv833m7i6m2g1p4dfy";

8545 configureFlags = [

8546 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8547 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8548 "-fsplitbase" "-f-test-hlint"

8549 ];

8550 isLibrary = true;

8551 isExecutable = true;

8552 libraryHaskellDepends = [

8553 base containers directory mtl network old-locale process time unix

8554 ];

8555 homepage = "http://software.complete.org/hslogger";

8556 description = "Versatile logging framework";

8557 license = stdenv.lib.licenses.bsd3;

8558 }) {};

8559 "hslua" = callPackage

8560 ({ mkDerivation, base, mtl }:

8561 mkDerivation {

8562 pname = "hslua";

8563 version = "0.3.13";

8564 sha256 = "02j3hrzq3dgcv4bvf4xz14qxvzlb0vlxrf7lk9wqwdy43b978mz9";

8565 configureFlags = [

8566 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8567 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8568 "-fsplitbase" "-f-test-hlint"

8569 ];

8570 libraryHaskellDepends = [ base mtl ];

8571 testHaskellDepends = [ base ];

8572 description = "A Lua language interpreter embedding in Haskell";

8573 license = stdenv.lib.licenses.mit;

8574 }) {};

8575 "hspec" = callPackage

8576 ({ mkDerivation, base, directory, hspec-core, hspec-discover

8577 , hspec-expectations, hspec-meta, HUnit, QuickCheck, stringbuilder

8578 , transformers

8579 }:

8580 mkDerivation {

8581 pname = "hspec";

8582 version = "2.1.5";

8583 sha256 = "0lj8inhp0lxh23ayc3wcj5c7rslwr4q6s6wqswhda0v3cz3lfmsc";

8584 revision = "1";

8585 editedCabalFile = "1zwphda7jiny3g5ka6fr4m9477439kinrlqw4s4fjkbl8qlgyyy0";

8586 configureFlags = [

8587 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8588 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8589 "-fsplitbase" "-f-test-hlint"

8590 ];

8591 libraryHaskellDepends = [

8592 base hspec-core hspec-discover hspec-expectations HUnit QuickCheck

8593 transformers

8594 ];

8595 testHaskellDepends = [

8596 base directory hspec-core hspec-meta stringbuilder

8597 ];

8598 homepage = "http://hspec.github.io/";

8599 description = "A Testing Framework for Haskell";

8600 license = stdenv.lib.licenses.mit;

8601 }) {};

8602 "hspec-core" = callPackage

8603 ({ mkDerivation, ansi-terminal, async, base, deepseq

8604 , hspec-expectations, hspec-meta, HUnit, process, QuickCheck

8605 , quickcheck-io, random, setenv, silently, tf-random, time

8606 , transformers

8607 }:

8608 mkDerivation {

8609 pname = "hspec-core";

8610 version = "2.1.5";

8611 sha256 = "1za9ybkcqrzgrmqvzijvw471yk5kjhp0pr0n47n4f4cy0ha7l0fb";

8612 revision = "4";

8613 editedCabalFile = "1isp7dinp57v3wgcipg45vzwnp6qf83jqxdcnh9s8w0rs30sxkwc";

8614 configureFlags = [

8615 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8616 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8617 "-fsplitbase" "-f-test-hlint"

8618 ];

8619 libraryHaskellDepends = [

8620 ansi-terminal async base deepseq hspec-expectations HUnit

8621 QuickCheck quickcheck-io random setenv tf-random time transformers

8622 ];

8623 testHaskellDepends = [

8624 ansi-terminal async base deepseq hspec-expectations hspec-meta

8625 HUnit process QuickCheck quickcheck-io random setenv silently

8626 tf-random time transformers

8627 ];

8628 homepage = "http://hspec.github.io/";

8629 description = "A Testing Framework for Haskell";

8630 license = stdenv.lib.licenses.mit;

8631 }) {};

8632 "hspec-discover" = callPackage

8633 ({ mkDerivation, base, directory, filepath, hspec-meta }:

8634 mkDerivation {

8635 pname = "hspec-discover";

8636 version = "2.1.5";

8637 sha256 = "03bs5gxzhn605f8k7wdm629kzsmxy5mjb1v834q69f3w1iczx304";

8638 configureFlags = [

8639 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8640 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8641 "-fsplitbase" "-f-test-hlint"

8642 ];

8643 isLibrary = true;

8644 isExecutable = true;

8645 executableHaskellDepends = [ base directory filepath ];

8646 testHaskellDepends = [ base directory filepath hspec-meta ];

8647 doHaddock = false;

8648 homepage = "http://hspec.github.io/";

8649 description = "Automatically discover and run Hspec tests";

8650 license = stdenv.lib.licenses.mit;

8651 }) {};

8652 "hspec-expectations" = callPackage

8653 ({ mkDerivation, base, hspec, HUnit, markdown-unlit, silently }:

8654 mkDerivation {

8655 pname = "hspec-expectations";

8656 version = "0.6.1.1";

8657 sha256 = "0f36b2cp2ipbqz9g6lp43nvx8dykkw196wg97kgb07mmnq6gakix";

8658 configureFlags = [

8659 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8660 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8661 "-fsplitbase" "-f-test-hlint"

8662 ];

8663 libraryHaskellDepends = [ base HUnit ];

8664 testHaskellDepends = [ base hspec HUnit markdown-unlit silently ];

8665 homepage = "https://github.com/sol/hspec-expectations#readme";

8666 description = "Catchy combinators for HUnit";

8667 license = stdenv.lib.licenses.mit;

8668 }) {};

8669 "hspec-meta" = callPackage

8670 ({ mkDerivation, ansi-terminal, async, base, deepseq, directory

8671 , filepath, hspec-expectations, HUnit, QuickCheck, quickcheck-io

8672 , random, setenv, time, transformers

8673 }:

8674 mkDerivation {

8675 pname = "hspec-meta";

8676 version = "2.0.0";

8677 sha256 = "0x1k2d4nycglzn9l4i32xrampr9fgzjpp4j1jyy7pj89cfl8jc8f";

8678 configureFlags = [

8679 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8680 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8681 "-fsplitbase" "-f-test-hlint"

8682 ];

8683 isLibrary = true;

8684 isExecutable = true;

8685 libraryHaskellDepends = [

8686 ansi-terminal async base deepseq hspec-expectations HUnit

8687 QuickCheck quickcheck-io random setenv time transformers

8688 ];

8689 executableHaskellDepends = [ base directory filepath ];

8690 homepage = "http://hspec.github.io/";

8691 description = "A version of Hspec which is used to test Hspec itself";

8692 license = stdenv.lib.licenses.mit;

8693 }) {};

8694 "hspec-wai" = callPackage

8695 ({ mkDerivation, base, bytestring, case-insensitive, hspec

8696 , hspec-core, hspec-expectations, http-types, QuickCheck, text

8697 , transformers, wai, wai-extra

8698 }:

8699 mkDerivation {

8700 pname = "hspec-wai";

8701 version = "0.6.3";

8702 sha256 = "0vydfzpfwrld6wi47bk1d27hm5mz8hll3fc0ckzy7dyyzrgfnp4i";

8703 configureFlags = [

8704 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8705 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8706 "-fsplitbase" "-f-test-hlint"

8707 ];

8708 libraryHaskellDepends = [

8709 base bytestring case-insensitive hspec-core hspec-expectations

8710 http-types text transformers wai wai-extra

8711 ];

8712 testHaskellDepends = [

8713 base bytestring case-insensitive hspec hspec-core

8714 hspec-expectations http-types QuickCheck text transformers wai

8715 wai-extra

8716 ];

8717 description = "Experimental Hspec support for testing WAI applications";

8718 license = stdenv.lib.licenses.mit;

8719 }) {};

8720 "hspec-wai-json" = callPackage

8721 ({ mkDerivation, aeson, aeson-qq, base, bytestring, hspec

8722 , hspec-wai, template-haskell

8723 }:

8724 mkDerivation {

8725 pname = "hspec-wai-json";

8726 version = "0.6.0";

8727 sha256 = "0r9p8v3cynyx5gnan86cc0l5hrmnm3mx7w2kkc1npv6zq0cj1bgq";

8728 configureFlags = [

8729 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8730 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8731 "-fsplitbase" "-f-test-hlint"

8732 ];

8733 libraryHaskellDepends = [

8734 aeson aeson-qq base bytestring hspec-wai template-haskell

8735 ];

8736 testHaskellDepends = [ base hspec hspec-wai ];

8737 description = "Testing JSON APIs with hspec-wai";

8738 license = stdenv.lib.licenses.mit;

8739 }) {};

8740 "hspec2" = callPackage

8741 ({ mkDerivation, base, hspec, hspec-discover }:

8742 mkDerivation {

8743 pname = "hspec2";

8744 version = "0.6.1";

8745 sha256 = "0zlvm7r46q8yhgx2kx9mfrf6x2f5amdbi3a59fh69dsqs4lbgmf4";

8746 revision = "1";

8747 editedCabalFile = "0zqh0f7d89aw3ib7mx2wlkpc166f3zipgka4m54y2shcz3rbl7nl";

8748 configureFlags = [

8749 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8750 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8751 "-fsplitbase" "-f-test-hlint"

8752 ];

8753 libraryHaskellDepends = [ base hspec hspec-discover ];

8754 homepage = "http://hspec.github.io/";

8755 description = "Alpha version of Hspec 2.0";

8756 license = stdenv.lib.licenses.mit;

8757 }) {};

8758 "hsyslog" = callPackage

8759 ({ mkDerivation, base, doctest }:

8760 mkDerivation {

8761 pname = "hsyslog";

8762 version = "2.0";

8763 sha256 = "02v698grn43bvikqhqiz9ys8x2amngdmhvl3i0ar9203p2x8q3pq";

8764 configureFlags = [

8765 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8766 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8767 "-fsplitbase" "-f-test-hlint"

8768 ];

8769 libraryHaskellDepends = [ base ];

8770 testHaskellDepends = [ base doctest ];

8771 homepage = "http://github.com/peti/hsyslog";

8772 description = "FFI interface to syslog(3) from POSIX.1-2001";

8773 license = stdenv.lib.licenses.bsd3;

8774 }) {};

8775 "html" = callPackage

8776 ({ mkDerivation, base }:

8777 mkDerivation {

8778 pname = "html";

8779 version = "1.0.1.2";

8780 sha256 = "0q9hmfii62kc82ijlg238fxrzxhsivn42x5wd6ffcr9xldg4jd8c";

8781 configureFlags = [

8782 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8783 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8784 "-fsplitbase" "-f-test-hlint"

8785 ];

8786 libraryHaskellDepends = [ base ];

8787 description = "HTML combinator library";

8788 license = stdenv.lib.licenses.bsd3;

8789 }) {};

8790 "html-conduit" = callPackage

8791 ({ mkDerivation, base, bytestring, conduit, conduit-extra

8792 , containers, hspec, HUnit, resourcet, system-filepath

8793 , tagstream-conduit, text, transformers, xml-conduit, xml-types

8794 }:

8795 mkDerivation {

8796 pname = "html-conduit";

8797 version = "1.1.1.1";

8798 sha256 = "1bsr0fsy7k606m477c4rxdh7j71nyrp86f1lg9wlwnbm31vrhw00";

8799 configureFlags = [

8800 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8801 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8802 "-fsplitbase" "-f-test-hlint"

8803 ];

8804 libraryHaskellDepends = [

8805 base bytestring conduit conduit-extra containers resourcet

8806 system-filepath tagstream-conduit text transformers xml-conduit

8807 xml-types

8808 ];

8809 testHaskellDepends = [

8810 base bytestring containers hspec HUnit xml-conduit

8811 ];

8812 homepage = "https://github.com/snoyberg/xml";

8813 description = "Parse HTML documents using xml-conduit datatypes";

8814 license = stdenv.lib.licenses.mit;

8815 }) {};

8816 "http-client" = callPackage

8817 ({ mkDerivation, array, async, base, base64-bytestring

8818 , blaze-builder, bytestring, case-insensitive, clock, containers

8819 , cookie, data-default-class, deepseq, directory, exceptions

8820 , filepath, ghc-prim, hspec, http-types, mime-types, monad-control

8821 , network, network-uri, publicsuffixlist, random, streaming-commons

8822 , text, time, transformers, zlib

8823 }:

8824 mkDerivation {

8825 pname = "http-client";

8826 version = "0.4.9";

8827 sha256 = "1dr8xd1y615hrc9557804zc9k1zi39rfb0hrmpr8ay28f71mb4an";

8828 configureFlags = [

8829 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8830 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8831 "-fsplitbase" "-f-test-hlint"

8832 ];

8833 libraryHaskellDepends = [

8834 array base base64-bytestring blaze-builder bytestring

8835 case-insensitive clock containers cookie data-default-class deepseq

8836 exceptions filepath ghc-prim http-types mime-types network

8837 network-uri publicsuffixlist random streaming-commons text time

8838 transformers

8839 ];

8840 testHaskellDepends = [

8841 async base base64-bytestring blaze-builder bytestring

8842 case-insensitive containers deepseq directory hspec http-types

8843 monad-control network streaming-commons text time transformers zlib

8844 ];

8845 homepage = "https://github.com/snoyberg/http-client";

8846 description = "An HTTP client engine, intended as a base layer for more user-friendly packages";

8847 license = stdenv.lib.licenses.mit;

8848 }) {};

8849 "http-client-tls" = callPackage

8850 ({ mkDerivation, base, bytestring, connection, data-default-class

8851 , hspec, http-client, http-types, network, tls

8852 }:

8853 mkDerivation {

8854 pname = "http-client-tls";

8855 version = "0.2.2";

8856 sha256 = "0a01r05h5fxswyn6k6cgqgak4scqjan72hyy5wbdqzzhl4rmh7j5";

8857 revision = "1";

8858 editedCabalFile = "01ycp67hb0vlk4l43fv53vspw4izp9mjzapagfzamrahlcdps85b";

8859 configureFlags = [

8860 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8861 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8862 "-fsplitbase" "-f-test-hlint"

8863 ];

8864 libraryHaskellDepends = [

8865 base bytestring connection data-default-class http-client network

8866 tls

8867 ];

8868 testHaskellDepends = [ base hspec http-client http-types ];

8869 homepage = "https://github.com/snoyberg/http-client";

8870 description = "http-client backend using the connection package and tls library";

8871 license = stdenv.lib.licenses.mit;

8872 }) {};

8873 "http-conduit" = callPackage

8874 ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive

8875 , conduit, conduit-extra, connection, cookie, data-default-class

8876 , hspec, http-client, http-client-tls, http-types, HUnit

8877 , lifted-base, monad-control, mtl, network, resourcet

8878 , streaming-commons, text, time, transformers, utf8-string, wai

8879 , wai-conduit, warp, warp-tls

8880 }:

8881 mkDerivation {

8882 pname = "http-conduit";

8883 version = "2.1.5";

8884 sha256 = "0vk2an6h3h7a5klk9xrf3apfm6xdmqm418yrr7pb56b7w5sfq003";

8885 revision = "1";

8886 editedCabalFile = "0rgdrjwkkh778d788xhrnnibygprgy718365214n38yl6jxmqlqg";

8887 configureFlags = [

8888 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8889 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8890 "-fsplitbase" "-f-test-hlint"

8891 ];

8892 libraryHaskellDepends = [

8893 base bytestring conduit http-client http-client-tls http-types

8894 lifted-base monad-control mtl resourcet transformers

8895 ];

8896 testHaskellDepends = [

8897 base blaze-builder bytestring case-insensitive conduit

8898 conduit-extra connection cookie data-default-class hspec

8899 http-client http-types HUnit lifted-base network streaming-commons

8900 text time transformers utf8-string wai wai-conduit warp warp-tls

8901 ];

8902 homepage = "http://www.yesodweb.com/book/http-conduit";

8903 description = "HTTP client package with conduit interface and HTTPS support";

8904 license = stdenv.lib.licenses.bsd3;

8905 }) {};

8906 "http-date" = callPackage

8907 ({ mkDerivation, array, attoparsec, base, bytestring, doctest

8908 , hspec, old-locale, time

8909 }:

8910 mkDerivation {

8911 pname = "http-date";

8912 version = "0.0.6";

8913 sha256 = "0f1s4bfazckl016pi2nzrmmiv0f6pnr9mgvsdj33ysvknp0md3c9";

8914 configureFlags = [

8915 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8916 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8917 "-fsplitbase" "-f-test-hlint"

8918 ];

8919 libraryHaskellDepends = [ array attoparsec base bytestring ];

8920 testHaskellDepends = [

8921 base bytestring doctest hspec old-locale time

8922 ];

8923 description = "HTTP Date parser/formatter";

8924 license = stdenv.lib.licenses.bsd3;

8925 }) {};

8926 "http-reverse-proxy" = callPackage

8927 ({ mkDerivation, async, base, blaze-builder, bytestring

8928 , case-insensitive, conduit, conduit-extra, containers

8929 , data-default-class, hspec, http-client, http-conduit, http-types

8930 , lifted-base, monad-control, network, resourcet, streaming-commons

8931 , text, transformers, wai, wai-logger, warp, word8

8932 }:

8933 mkDerivation {

8934 pname = "http-reverse-proxy";

8935 version = "0.4.1.2";

8936 sha256 = "1gggn5l08g7mxbka0h7h8w687y3awbm19395fi6wvis76isyz8wy";

8937 revision = "1";

8938 editedCabalFile = "0fwwb3wnmxrfvn8pvi3hpz8hrpjd8s5rajhh4j4x9355ac7cz61i";

8939 configureFlags = [

8940 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8941 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8942 "-fsplitbase" "-f-test-hlint"

8943 ];

8944 libraryHaskellDepends = [

8945 async base blaze-builder bytestring case-insensitive conduit

8946 conduit-extra containers data-default-class http-client http-types

8947 lifted-base monad-control network resourcet streaming-commons text

8948 transformers wai wai-logger word8

8949 ];

8950 testHaskellDepends = [

8951 base blaze-builder bytestring conduit conduit-extra hspec

8952 http-conduit http-types lifted-base network resourcet

8953 streaming-commons transformers wai warp

8954 ];

8955 homepage = "https://github.com/fpco/http-reverse-proxy";

8956 description = "Reverse proxy HTTP requests, either over raw sockets or with WAI";

8957 license = stdenv.lib.licenses.bsd3;

8958 }) {};

8959 "http-types" = callPackage

8960 ({ mkDerivation, array, base, blaze-builder, bytestring

8961 , case-insensitive, doctest, hspec, QuickCheck

8962 , quickcheck-instances, text

8963 }:

8964 mkDerivation {

8965 pname = "http-types";

8966 version = "0.8.6";

8967 sha256 = "1q1ni88rs8d79xnk1x2jaf3848ygxlfhpvv4gw46k08lw29ihfxh";

8968 configureFlags = [

8969 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8970 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8971 "-fsplitbase" "-f-test-hlint"

8972 ];

8973 libraryHaskellDepends = [

8974 array base blaze-builder bytestring case-insensitive text

8975 ];

8976 testHaskellDepends = [

8977 base blaze-builder bytestring doctest hspec QuickCheck

8978 quickcheck-instances text

8979 ];

8980 homepage = "https://github.com/aristidb/http-types";

8981 description = "Generic HTTP types for Haskell (for both client and server code)";

8982 license = stdenv.lib.licenses.bsd3;

8983 }) {};

8984 "hweblib" = callPackage

8985 ({ mkDerivation, attoparsec, base, bytestring, containers

8986 , criterion, HUnit, mtl, text, transformers

8987 }:

8988 mkDerivation {

8989 pname = "hweblib";

8990 version = "0.6.3";

8991 sha256 = "03dmx5irlsyb3b9zg2r6nz947sslizkn0nlk65ldb5n4m8my33hy";

8992 configureFlags = [

8993 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

8994 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

8995 "-fsplitbase" "-f-test-hlint"

8996 ];

8997 libraryHaskellDepends = [

8998 attoparsec base bytestring containers mtl text transformers

8999 ];

9000 testHaskellDepends = [

9001 attoparsec base bytestring containers HUnit mtl transformers

9002 ];

9003 benchmarkHaskellDepends = [

9004 attoparsec base bytestring containers criterion HUnit mtl

9005 transformers

9006 ];

9007 homepage = "http://github.com/aycanirican/hweblib";

9008 description = "Haskell Web Library";

9009 license = stdenv.lib.licenses.bsd3;

9010 }) {};

9011 "hxt" = callPackage

9012 ({ mkDerivation, base, binary, bytestring, containers, deepseq

9013 , directory, filepath, HUnit, hxt-charproperties

9014 , hxt-regex-xmlschema, hxt-unicode, mtl, network-uri, parsec

9015 }:

9016 mkDerivation {

9017 pname = "hxt";

9018 version = "9.3.1.15";

9019 sha256 = "0q35jqi3g5qfwzp2p2hm22lkmbmk08bx2qvpgq4731zm48y7ngkj";

9020 configureFlags = [

9021 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9022 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9023 "-fsplitbase" "-f-test-hlint"

9024 ];

9025 libraryHaskellDepends = [

9026 base binary bytestring containers deepseq directory filepath HUnit

9027 hxt-charproperties hxt-regex-xmlschema hxt-unicode mtl network-uri

9028 parsec

9029 ];

9030 homepage = "https://github.com/UweSchmidt/hxt";

9031 description = "A collection of tools for processing XML with Haskell";

9032 license = stdenv.lib.licenses.mit;

9033 }) {};

9034 "hxt-charproperties" = callPackage

9035 ({ mkDerivation, base }:

9036 mkDerivation {

9037 pname = "hxt-charproperties";

9038 version = "9.2.0.1";

9039 sha256 = "1mml8wglvagqq891rchgli6r8rnkwrqhgsxfl6kb5403pzb18rp4";

9040 configureFlags = [

9041 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9042 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9043 "-fsplitbase" "-f-test-hlint"

9044 ];

9045 libraryHaskellDepends = [ base ];

9046 homepage = "https://github.com/UweSchmidt/hxt";

9047 description = "Character properties and classes for XML and Unicode";

9048 license = stdenv.lib.licenses.mit;

9049 }) {};

9050 "hxt-http" = callPackage

9051 ({ mkDerivation, base, bytestring, HTTP, hxt, network, network-uri

9052 , parsec

9053 }:

9054 mkDerivation {

9055 pname = "hxt-http";

9056 version = "9.1.5.2";

9057 sha256 = "02yxvzczv89j518b94wh8m4dsmnymzxgv9158m7w6lqxk41rv8bg";

9058 configureFlags = [

9059 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9060 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9061 "-fsplitbase" "-f-test-hlint"

9062 ];

9063 libraryHaskellDepends = [

9064 base bytestring HTTP hxt network network-uri parsec

9065 ];

9066 homepage = "https://github.com/UweSchmidt/hxt";

9067 description = "Interface to native Haskell HTTP package HTTP";

9068 license = stdenv.lib.licenses.mit;

9069 }) {};

9070 "hxt-pickle-utils" = callPackage

9071 ({ mkDerivation, base, hxt, mtl }:

9072 mkDerivation {

9073 pname = "hxt-pickle-utils";

9074 version = "0.1.0.2";

9075 sha256 = "06v4935lljcyyx4a5v0z4id3fz4v28aghsrzr94k6diibpnwcdz2";

9076 revision = "1";

9077 editedCabalFile = "1yyjb49q82wqhhbg1922az76rr41ipji8a7bw1zfxhsp5i03n5w9";

9078 configureFlags = [

9079 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9080 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9081 "-fsplitbase" "-f-test-hlint"

9082 ];

9083 libraryHaskellDepends = [ base hxt mtl ];

9084 homepage = "https://github.com/silkapp/hxt-pickle-utils";

9085 description = "Utility functions for using HXT picklers";

9086 license = stdenv.lib.licenses.bsd3;

9087 }) {};

9088 "hxt-regex-xmlschema" = callPackage

9089 ({ mkDerivation, base, bytestring, criterion, deepseq, HUnit

9090 , hxt-charproperties, parsec, text

9091 }:

9092 mkDerivation {

9093 pname = "hxt-regex-xmlschema";

9094 version = "9.2.0.2";

9095 sha256 = "1hkcd5p7rhv8z2vlcpd1gcdiyni28m8k8yd5fnxw8a9bvrnnfi27";

9096 revision = "1";

9097 editedCabalFile = "1skvrrl0pld3zwjxsb64g9sdrqy1z4whjm45prsqj1mcw909rcl5";

9098 configureFlags = [

9099 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9100 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9101 "-fsplitbase" "-f-test-hlint"

9102 ];

9103 libraryHaskellDepends = [

9104 base bytestring hxt-charproperties parsec text

9105 ];

9106 testHaskellDepends = [ base bytestring HUnit parsec text ];

9107 benchmarkHaskellDepends = [

9108 base bytestring criterion deepseq parsec text

9109 ];

9110 homepage = "http://www.haskell.org/haskellwiki/Regular_expressions_for_XML_Schema";

9111 description = "A regular expression library for W3C XML Schema regular expressions";

9112 license = stdenv.lib.licenses.mit;

9113 }) {};

9114 "hxt-relaxng" = callPackage

9115 ({ mkDerivation, base, containers, hxt, hxt-charproperties

9116 , hxt-regex-xmlschema, network-uri, parsec

9117 }:

9118 mkDerivation {

9119 pname = "hxt-relaxng";

9120 version = "9.1.5.5";

9121 sha256 = "07s47z5xhd0pdzz8mr9vg78qxay450sm8ljycpprq7y7mgh2vzhf";

9122 configureFlags = [

9123 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9124 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9125 "-fsplitbase" "-f-test-hlint"

9126 ];

9127 libraryHaskellDepends = [

9128 base containers hxt hxt-charproperties hxt-regex-xmlschema

9129 network-uri parsec

9130 ];

9131 homepage = "https://github.com/UweSchmidt/hxt";

9132 description = "The HXT RelaxNG validator";

9133 license = stdenv.lib.licenses.mit;

9134 }) {};

9135 "hxt-unicode" = callPackage

9136 ({ mkDerivation, base, hxt-charproperties }:

9137 mkDerivation {

9138 pname = "hxt-unicode";

9139 version = "9.0.2.4";

9140 sha256 = "0rj48cy8z4fl3zpg5bpa458kqr83adav6jnqv4i71dclpprj6n3v";

9141 configureFlags = [

9142 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9143 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9144 "-fsplitbase" "-f-test-hlint"

9145 ];

9146 libraryHaskellDepends = [ base hxt-charproperties ];

9147 homepage = "https://github.com/UweSchmidt/hxt";

9148 description = "Unicode en-/decoding functions for utf8, iso-latin-* and other encodings";

9149 license = stdenv.lib.licenses.mit;

9150 }) {};

9151 "hybrid-vectors" = callPackage

9152 ({ mkDerivation, base, deepseq, primitive, vector }:

9153 mkDerivation {

9154 pname = "hybrid-vectors";

9155 version = "0.1.2.1";

9156 sha256 = "0xh6yvv7jyahzrqihc13g1nlv81v0mzxvaxib5fcyr1njwbcwv59";

9157 revision = "2";

9158 editedCabalFile = "0ix4ql150fxmaywl59slk3jqy4gq6h1d4bkbajg5maixby3hh3dx";

9159 configureFlags = [

9160 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9161 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9162 "-fsplitbase" "-f-test-hlint"

9163 ];

9164 libraryHaskellDepends = [ base deepseq primitive vector ];

9165 homepage = "http://github.com/ekmett/hybrid-vectors";

9166 description = "Hybrid vectors e.g. Mixed Boxed/Unboxed vectors";

9167 license = stdenv.lib.licenses.bsd3;

9168 }) {};

9169 "hyphenation" = callPackage

9170 ({ mkDerivation, base, containers, directory, doctest, filepath

9171 , unordered-containers

9172 }:

9173 mkDerivation {

9174 pname = "hyphenation";

9175 version = "0.4.2.1";

9176 sha256 = "069mbxdjlj36lyxr8bqkh1d05bhly64wk5lk71mz73lzcyaivcxi";

9177 configureFlags = [

9178 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9179 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9180 "-fsplitbase" "-f-test-hlint"

9181 ];

9182 enableSeparateDataOutput = true;

9183 libraryHaskellDepends = [ base containers unordered-containers ];

9184 testHaskellDepends = [

9185 base containers directory doctest filepath unordered-containers

9186 ];

9187 homepage = "http://github.com/ekmett/hyphenation";

9188 description = "Configurable Knuth-Liang hyphenation";

9189 license = stdenv.lib.licenses.bsd3;

9190 }) {};

9191 "idna" = callPackage

9192 ({ mkDerivation, base, punycode, stringprep, text }:

9193 mkDerivation {

9194 pname = "idna";

9195 version = "0.3.0";

9196 sha256 = "04w2mp9wa4mzdz4njx47j081jia8y000b46cw8vmx44fx8gv1zwp";

9197 configureFlags = [

9198 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9199 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9200 "-fsplitbase" "-f-test-hlint"

9201 ];

9202 libraryHaskellDepends = [ base punycode stringprep text ];

9203 description = "Implements IDNA (RFC 3490)";

9204 license = stdenv.lib.licenses.bsd3;

9205 }) {};

9206 "ieee754" = callPackage

9207 ({ mkDerivation, base }:

9208 mkDerivation {

9209 pname = "ieee754";

9210 version = "0.7.6";

9211 sha256 = "03s56h82n7hcwcn2dhd646prcf9wxj5jq49xqsnl7cnvi9768h2q";

9212 configureFlags = [

9213 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9214 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9215 "-fsplitbase" "-f-test-hlint"

9216 ];

9217 libraryHaskellDepends = [ base ];

9218 homepage = "http://github.com/patperry/hs-ieee754";

9219 description = "Utilities for dealing with IEEE floating point numbers";

9220 license = stdenv.lib.licenses.bsd3;

9221 }) {};

9222 "imagesize-conduit" = callPackage

9223 ({ mkDerivation, base, bytestring, conduit, conduit-extra, hspec

9224 , resourcet

9225 }:

9226 mkDerivation {

9227 pname = "imagesize-conduit";

9228 version = "1.0.0.4";

9229 sha256 = "0hhmjbdqdljfy3khzpg2xq6kgxa9x89jvpci7lf413pc1lpg4cw7";

9230 revision = "1";

9231 editedCabalFile = "0gaas69df3m6q6yanzhzyv4smqkar4svs6yzy7vcvq9aayk6x6ls";

9232 configureFlags = [

9233 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9234 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9235 "-fsplitbase" "-f-test-hlint"

9236 ];

9237 libraryHaskellDepends = [ base bytestring conduit conduit-extra ];

9238 testHaskellDepends = [

9239 base bytestring conduit conduit-extra hspec resourcet

9240 ];

9241 homepage = "http://github.com/silkapp/imagesize-conduit";

9242 description = "Determine the size of some common image formats";

9243 license = stdenv.lib.licenses.bsd3;

9244 }) {};

9245 "immortal" = callPackage

9246 ({ mkDerivation, base, lifted-base, monad-control, stm, tasty

9247 , tasty-hunit, transformers, transformers-base

9248 }:

9249 mkDerivation {

9250 pname = "immortal";

9251 version = "0.2";

9252 sha256 = "1si9zh309xh29qrxkhb0shwisjrsja2d9lpj17dwlzn0gv0i1672";

9253 configureFlags = [

9254 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9255 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9256 "-fsplitbase" "-f-test-hlint"

9257 ];

9258 libraryHaskellDepends = [

9259 base lifted-base monad-control transformers-base

9260 ];

9261 testHaskellDepends = [

9262 base lifted-base stm tasty tasty-hunit transformers

9263 ];

9264 homepage = "https://github.com/feuerbach/immortal";

9265 description = "Spawn threads that never die (unless told to do so)";

9266 license = stdenv.lib.licenses.mit;

9267 }) {};

9268 "incremental-parser" = callPackage

9269 ({ mkDerivation, base, checkers, monoid-subclasses, QuickCheck

9270 , tasty, tasty-quickcheck

9271 }:

9272 mkDerivation {

9273 pname = "incremental-parser";

9274 version = "0.2.3.4";

9275 sha256 = "0n2318i4dzgcs9xcs80wcfbm9rc902w02nwqa30b3nrwl21cjag3";

9276 configureFlags = [

9277 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9278 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9279 "-fsplitbase" "-f-test-hlint"

9280 ];

9281 libraryHaskellDepends = [ base monoid-subclasses ];

9282 testHaskellDepends = [

9283 base checkers monoid-subclasses QuickCheck tasty tasty-quickcheck

9284 ];

9285 homepage = "http://patch-tag.com/r/blamario/incremental-parser/wiki/";

9286 description = "Generic parser library capable of providing partial results from partial input";

9287 license = "GPL";

9288 }) {};

9289 "indents" = callPackage

9290 ({ mkDerivation, base, concatenative, mtl, parsec }:

9291 mkDerivation {

9292 pname = "indents";

9293 version = "0.3.3";

9294 sha256 = "16lz21bp9j14xilnq8yym22p3saxvc9fsgfcf5awn2a6i6n527xn";

9295 configureFlags = [

9296 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9297 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9298 "-fsplitbase" "-f-test-hlint"

9299 ];

9300 libraryHaskellDepends = [ base concatenative mtl parsec ];

9301 homepage = "http://patch-tag.com/r/salazar/indents";

9302 description = "indentation sensitive parser-combinators for parsec";

9303 license = stdenv.lib.licenses.bsd3;

9304 }) {};

9305 "ini" = callPackage

9306 ({ mkDerivation, attoparsec, base, text, unordered-containers }:

9307 mkDerivation {

9308 pname = "ini";

9309 version = "0.3.1";

9310 sha256 = "01iwf4ifdx3mrw1rybj4crip4hmjxhab250rv995dgbwldh1iyqb";

9311 configureFlags = [

9312 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9313 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9314 "-fsplitbase" "-f-test-hlint"

9315 ];

9316 libraryHaskellDepends = [

9317 attoparsec base text unordered-containers

9318 ];

9319 description = "Quick and easy configuration files in the INI format";

9320 license = stdenv.lib.licenses.bsd3;

9321 }) {};

9322 "integration" = callPackage

9323 ({ mkDerivation, base, parallel }:

9324 mkDerivation {

9325 pname = "integration";

9326 version = "0.2.1";

9327 sha256 = "0bsqad6q4kc0wykswwqykcn6nd4wj6yd9dzpg075h2n1mmg3h9qc";

9328 configureFlags = [

9329 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9330 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9331 "-fsplitbase" "-f-test-hlint"

9332 ];

9333 libraryHaskellDepends = [ base parallel ];

9334 homepage = "https://github.com/ekmett/integration";

9335 description = "Fast robust numeric integration via tanh-sinh quadrature";

9336 license = stdenv.lib.licenses.bsd3;

9337 }) {};

9338 "interpolate" = callPackage

9339 ({ mkDerivation, base, bytestring, haskell-src-meta, hspec

9340 , QuickCheck, quickcheck-instances, template-haskell, text

9341 }:

9342 mkDerivation {

9343 pname = "interpolate";

9344 version = "0.1.0";

9345 sha256 = "0wlc10qd1bq3xj64a3yq2gzds9kas9zyylkm9kxd46gy35fns6id";

9346 revision = "1";

9347 editedCabalFile = "0ld319k9phmp6dp8m87bdhqp5519dxggf8r2a5z8hkznyjpa131j";

9348 configureFlags = [

9349 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9350 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9351 "-fsplitbase" "-f-test-hlint"

9352 ];

9353 libraryHaskellDepends = [ base haskell-src-meta template-haskell ];

9354 testHaskellDepends = [

9355 base bytestring haskell-src-meta hspec QuickCheck

9356 quickcheck-instances template-haskell text

9357 ];

9358 description = "String interpolation done right";

9359 license = stdenv.lib.licenses.mit;

9360 }) {};

9361 "interpolatedstring-perl6" = callPackage

9362 ({ mkDerivation, base, bytestring, haskell-src-meta

9363 , template-haskell, text

9364 }:

9365 mkDerivation {

9366 pname = "interpolatedstring-perl6";

9367 version = "0.9.0";

9368 sha256 = "15hzmni3wfdgjl0vyk5mcld61ba99wdax87s7wkz2s8bsyxkbq9n";

9369 configureFlags = [

9370 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9371 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9372 "-fsplitbase" "-f-test-hlint"

9373 ];

9374 enableSeparateDataOutput = true;

9375 libraryHaskellDepends = [

9376 base bytestring haskell-src-meta template-haskell text

9377 ];

9378 description = "QuasiQuoter for Perl6-style multi-line interpolated strings";

9379 license = stdenv.lib.licenses.bsd3;

9380 }) {};

9381 "intervals" = callPackage

9382 ({ mkDerivation, array, base, directory, distributive, doctest

9383 , filepath, ghc-prim

9384 }:

9385 mkDerivation {

9386 pname = "intervals";

9387 version = "0.7.1";

9388 sha256 = "03ra3jkch26x4crsq6nh2wnj51jrx7zmwafmq22xqrpsg7hpav92";

9389 configureFlags = [

9390 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9391 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9392 "-fsplitbase" "-f-test-hlint"

9393 ];

9394 libraryHaskellDepends = [ array base distributive ghc-prim ];

9395 testHaskellDepends = [ base directory doctest filepath ];

9396 homepage = "http://github.com/ekmett/intervals";

9397 description = "Interval Arithmetic";

9398 license = stdenv.lib.licenses.bsd3;

9399 }) {};

9400 "io-choice" = callPackage

9401 ({ mkDerivation, base, hspec, lifted-base, monad-control

9402 , template-haskell, transformers, transformers-base

9403 }:

9404 mkDerivation {

9405 pname = "io-choice";

9406 version = "0.0.5";

9407 sha256 = "19nr8kxcg98510cqgjn4c9sd8i9yz8fv4ryqg6lzzgpwqzkvx5ph";

9408 configureFlags = [

9409 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9410 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9411 "-fsplitbase" "-f-test-hlint"

9412 ];

9413 libraryHaskellDepends = [

9414 base lifted-base monad-control template-haskell transformers

9415 transformers-base

9416 ];

9417 testHaskellDepends = [

9418 base hspec lifted-base monad-control transformers

9419 ];

9420 description = "Choice for IO and lifted IO";

9421 license = stdenv.lib.licenses.bsd3;

9422 }) {};

9423 "io-manager" = callPackage

9424 ({ mkDerivation, base, containers }:

9425 mkDerivation {

9426 pname = "io-manager";

9427 version = "0.1.0.2";

9428 sha256 = "0f21h36z2ls0d6g31pcf4kcyfninaxws8w159zy33bwa19saf2mz";

9429 configureFlags = [

9430 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9431 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9432 "-fsplitbase" "-f-test-hlint"

9433 ];

9434 isLibrary = true;

9435 isExecutable = true;

9436 libraryHaskellDepends = [ base containers ];

9437 executableHaskellDepends = [ base containers ];

9438 description = "Skeleton library around the IO monad";

9439 license = stdenv.lib.licenses.bsd3;

9440 }) {};

9441 "io-memoize" = callPackage

9442 ({ mkDerivation, async, base }:

9443 mkDerivation {

9444 pname = "io-memoize";

9445 version = "1.1.1.0";

9446 sha256 = "0ga85wdvz67jjx8qh6f687kfikcrfmp7winn13v6na7vlaqs2ly7";

9447 configureFlags = [

9448 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9449 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9450 "-fsplitbase" "-f-test-hlint"

9451 ];

9452 libraryHaskellDepends = [ async base ];

9453 homepage = "https://github.com/DanBurton/io-memoize";

9454 description = "Memoize IO actions";

9455 license = stdenv.lib.licenses.bsd3;

9456 }) {};

9457 "iproute" = callPackage

9458 ({ mkDerivation, appar, base, byteorder, containers, doctest, hspec

9459 , network, QuickCheck, safe

9460 }:

9461 mkDerivation {

9462 pname = "iproute";

9463 version = "1.3.2";

9464 sha256 = "0zdcpmxyn1acxbdgh0k201ha70yzms1w27s7n6awp67hz7v0n95m";

9465 configureFlags = [

9466 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9467 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9468 "-fsplitbase" "-f-test-hlint"

9469 ];

9470 libraryHaskellDepends = [

9471 appar base byteorder containers network

9472 ];

9473 testHaskellDepends = [

9474 appar base byteorder containers doctest hspec network QuickCheck

9475 safe

9476 ];

9477 homepage = "http://www.mew.org/~kazu/proj/iproute/";

9478 description = "IP Routing Table";

9479 license = stdenv.lib.licenses.bsd3;

9480 }) {};

9481 "iterable" = callPackage

9482 ({ mkDerivation, base, mtl, tagged, template-haskell, vector }:

9483 mkDerivation {

9484 pname = "iterable";

9485 version = "3.0";

9486 sha256 = "194718jpjwkv3ynlpgjlpvf0iqnj7dkd3zmci363gsa425i3vlbc";

9487 configureFlags = [

9488 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9489 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9490 "-fsplitbase" "-f-test-hlint"

9491 ];

9492 enableSeparateDataOutput = true;

9493 libraryHaskellDepends = [

9494 base mtl tagged template-haskell vector

9495 ];

9496 homepage = "https://github.com/BioHaskell/iterable";

9497 description = "API for hierarchical multilevel collections";

9498 license = stdenv.lib.licenses.bsd3;

9499 }) {};

9500 "ixset" = callPackage

9501 ({ mkDerivation, base, containers, safecopy, syb, syb-with-class

9502 , template-haskell

9503 }:

9504 mkDerivation {

9505 pname = "ixset";

9506 version = "1.0.6";

9507 sha256 = "097f9fkm9a2n67bzagr9h2v7acdn8h1ayv9c83n7nv1dh157bpyv";

9508 configureFlags = [

9509 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9510 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9511 "-fsplitbase" "-f-test-hlint"

9512 ];

9513 libraryHaskellDepends = [

9514 base containers safecopy syb syb-with-class template-haskell

9515 ];

9516 homepage = "http://happstack.com";

9517 description = "Efficient relational queries on Haskell sets";

9518 license = stdenv.lib.licenses.bsd3;

9519 }) {};

9520 "js-flot" = callPackage

9521 ({ mkDerivation, base, HTTP }:

9522 mkDerivation {

9523 pname = "js-flot";

9524 version = "0.8.3";

9525 sha256 = "0yjyzqh3qzhy5h3nql1fckw0gcfb0f4wj9pm85nafpfqp2kg58hv";

9526 configureFlags = [

9527 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9528 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9529 "-fsplitbase" "-f-test-hlint"

9530 ];

9531 enableSeparateDataOutput = true;

9532 libraryHaskellDepends = [ base ];

9533 testHaskellDepends = [ base HTTP ];

9534 homepage = "https://github.com/ndmitchell/js-flot#readme";

9535 description = "Obtain minified flot code";

9536 license = stdenv.lib.licenses.mit;

9537 }) {};

9538 "js-jquery" = callPackage

9539 ({ mkDerivation, base, HTTP }:

9540 mkDerivation {

9541 pname = "js-jquery";

9542 version = "1.11.2";

9543 sha256 = "0sdzgz3gfic0i6636kd2szlqczhydi8m6vjr188n1bjc1y1xh112";

9544 configureFlags = [

9545 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9546 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9547 "-fsplitbase" "-f-test-hlint"

9548 ];

9549 enableSeparateDataOutput = true;

9550 libraryHaskellDepends = [ base ];

9551 testHaskellDepends = [ base HTTP ];

9552 homepage = "https://github.com/ndmitchell/js-jquery#readme";

9553 description = "Obtain minified jQuery code";

9554 license = stdenv.lib.licenses.mit;

9555 }) {};

9556 "json-autotype" = callPackage

9557 ({ mkDerivation, aeson, base, bytestring, containers, filepath

9558 , GenericPretty, hashable, hflags, hint, lens, mtl, pretty, process

9559 , scientific, text, uniplate, unordered-containers, vector

9560 }:

9561 mkDerivation {

9562 pname = "json-autotype";

9563 version = "0.2.5.9";

9564 sha256 = "0ajsxg515484bqmg94l9gmg4jpfvv6ykcbnyglkh1j86phggxrf2";

9565 configureFlags = [

9566 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9567 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9568 "-fsplitbase" "-f-test-hlint"

9569 ];

9570 isLibrary = true;

9571 isExecutable = true;

9572 libraryHaskellDepends = [

9573 aeson base bytestring containers filepath GenericPretty hashable

9574 hflags hint lens mtl pretty process scientific text uniplate

9575 unordered-containers vector

9576 ];

9577 executableHaskellDepends = [

9578 aeson base bytestring containers filepath GenericPretty hashable

9579 hflags lens mtl pretty process scientific text uniplate

9580 unordered-containers vector

9581 ];

9582 homepage = "https://github.com/mgajda/json-autotype";

9583 description = "Automatic type declaration for JSON input data";

9584 license = stdenv.lib.licenses.bsd3;

9585 }) {};

9586 "json-schema" = callPackage

9587 ({ mkDerivation, aeson, aeson-utils, attoparsec, base, bytestring

9588 , containers, generic-aeson, generic-deriving, mtl, scientific

9589 , tagged, tasty, tasty-hunit, tasty-th, text, time

9590 , unordered-containers, vector

9591 }:

9592 mkDerivation {

9593 pname = "json-schema";

9594 version = "0.7.3.1";

9595 sha256 = "07jvr0n6vakyvsqxl783fyqsgw83fvk5vk9p93v3hnpxlz0vrfnp";

9596 revision = "1";

9597 editedCabalFile = "0zsiyarh6hr6wmg4znyybl9jjcxljblvb19vry56xd680b95lb05";

9598 configureFlags = [

9599 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9600 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9601 "-fsplitbase" "-f-test-hlint"

9602 ];

9603 libraryHaskellDepends = [

9604 aeson base containers generic-aeson generic-deriving mtl scientific

9605 tagged text time unordered-containers vector

9606 ];

9607 testHaskellDepends = [

9608 aeson aeson-utils attoparsec base bytestring generic-aeson tagged

9609 tasty tasty-hunit tasty-th text vector

9610 ];

9611 description = "Types and type classes for defining JSON schemas";

9612 license = stdenv.lib.licenses.bsd3;

9613 }) {};

9614 "kan-extensions" = callPackage

9615 ({ mkDerivation, adjunctions, array, base, comonad, containers

9616 , contravariant, distributive, free, mtl, semigroupoids, tagged

9617 , transformers

9618 }:

9619 mkDerivation {

9620 pname = "kan-extensions";

9621 version = "4.2.1";

9622 sha256 = "0lymh1njw1zh9is6zk3bmr7jylna28632l4pylh6chlxpjvy4zwl";

9623 revision = "1";

9624 editedCabalFile = "1b9yx3dcnghp5lilypqilndip4j0n96v2nv1b0k2yiaci6yzvcf0";

9625 configureFlags = [

9626 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9627 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9628 "-fsplitbase" "-f-test-hlint"

9629 ];

9630 libraryHaskellDepends = [

9631 adjunctions array base comonad containers contravariant

9632 distributive free mtl semigroupoids tagged transformers

9633 ];

9634 homepage = "http://github.com/ekmett/kan-extensions/";

9635 description = "Kan extensions, Kan lifts, various forms of the Yoneda lemma, and (co)density (co)monads";

9636 license = stdenv.lib.licenses.bsd3;

9637 }) {};

9638 "kdt" = callPackage

9639 ({ mkDerivation, base, criterion, deepseq, deepseq-generics, heap

9640 , mersenne-random-pure64, MonadRandom, QuickCheck

9641 }:

9642 mkDerivation {

9643 pname = "kdt";

9644 version = "0.2.3";

9645 sha256 = "0chxxl53jnnhfs02gxr2a3kzppmsnwrrfr1fjyx71lkvigwy71yk";

9646 configureFlags = [

9647 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9648 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9649 "-fsplitbase" "-f-test-hlint"

9650 ];

9651 libraryHaskellDepends = [ base deepseq deepseq-generics heap ];

9652 testHaskellDepends = [ base deepseq deepseq-generics QuickCheck ];

9653 benchmarkHaskellDepends = [

9654 base criterion deepseq deepseq-generics heap mersenne-random-pure64

9655 MonadRandom QuickCheck

9656 ];

9657 homepage = "https://github.com/giogadi/kdt";

9658 description = "Fast and flexible k-d trees for various types of point queries";

9659 license = stdenv.lib.licenses.mit;

9660 }) {};

9661 "keter" = callPackage

9662 ({ mkDerivation, aeson, array, async, attoparsec, base

9663 , blaze-builder, bytestring, case-insensitive, conduit

9664 , conduit-extra, containers, data-default, directory, filepath

9665 , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy

9666 , http-types, HUnit, lifted-base, mtl, network, network-conduit-tls

9667 , process, random, regex-tdfa, stm, system-fileio, system-filepath

9668 , tar, template-haskell, text, time, transformers, unix

9669 , unix-compat, unordered-containers, vector, wai, wai-app-static

9670 , wai-extra, warp, warp-tls, yaml, zlib

9671 }:

9672 mkDerivation {

9673 pname = "keter";

9674 version = "1.3.9.1";

9675 sha256 = "0b86f7j9yr4q24q88fwd2j4disns8mcwabrqgcz3hghrh6rhpgg9";

9676 revision = "2";

9677 editedCabalFile = "0z2dis0a8gkc41r6h5qp9cm4dlizrm4k7zkkl0vaal4vdzv27hmw";

9678 configureFlags = [

9679 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9680 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9681 "-fsplitbase" "-f-test-hlint"

9682 ];

9683 isLibrary = true;

9684 isExecutable = true;

9685 libraryHaskellDepends = [

9686 aeson array async attoparsec base blaze-builder bytestring

9687 case-insensitive conduit conduit-extra containers data-default

9688 directory filepath fsnotify http-client http-conduit

9689 http-reverse-proxy http-types lifted-base mtl network

9690 network-conduit-tls process random regex-tdfa stm system-fileio

9691 system-filepath tar template-haskell text time transformers unix

9692 unix-compat unordered-containers vector wai wai-app-static

9693 wai-extra warp warp-tls yaml zlib

9694 ];

9695 executableHaskellDepends = [ base data-default system-filepath ];

9696 testHaskellDepends = [

9697 base bytestring conduit hspec HUnit transformers unix

9698 ];

9699 homepage = "http://www.yesodweb.com/";

9700 description = "Web application deployment manager, focusing on Haskell web frameworks";

9701 license = stdenv.lib.licenses.mit;

9702 }) {};

9703 "keys" = callPackage

9704 ({ mkDerivation, array, base, comonad, containers, free

9705 , semigroupoids, semigroups, transformers

9706 }:

9707 mkDerivation {

9708 pname = "keys";

9709 version = "3.10.1";

9710 sha256 = "007lbpfan5n1cgswsrzc4xjv0kjmjr9vn4lpqm3gwk3lnfpg8i4n";

9711 configureFlags = [

9712 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9713 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9714 "-fsplitbase" "-f-test-hlint"

9715 ];

9716 libraryHaskellDepends = [

9717 array base comonad containers free semigroupoids semigroups

9718 transformers

9719 ];

9720 homepage = "http://github.com/ekmett/keys/";

9721 description = "Keyed functors and containers";

9722 license = stdenv.lib.licenses.bsd3;

9723 }) {};

9724 "kure" = callPackage

9725 ({ mkDerivation, base, dlist, transformers }:

9726 mkDerivation {

9727 pname = "kure";

9728 version = "2.16.10";

9729 sha256 = "0xfnrp39w2ip9744898mfd63sbya8an72fx3nwj1s3vzdb1h3lhm";

9730 configureFlags = [

9731 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9732 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9733 "-fsplitbase" "-f-test-hlint"

9734 ];

9735 libraryHaskellDepends = [ base dlist transformers ];

9736 homepage = "http://www.ittc.ku.edu/csdl/fpg/software/kure.html";

9737 description = "Combinators for Strategic Programming";

9738 license = stdenv.lib.licenses.bsd3;

9739 }) {};

9740 "language-c" = callPackage

9741 ({ mkDerivation, alex, array, base, bytestring, containers

9742 , directory, filepath, happy, pretty, process, syb

9743 }:

9744 mkDerivation {

9745 pname = "language-c";

9746 version = "0.4.7";

9747 sha256 = "1r0jlncv6d6ai8kblrdq9gz8abx57b24y6hfh30xx20zdgccjvaz";

9748 configureFlags = [

9749 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9750 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9751 "-fsplitbase" "-f-test-hlint"

9752 ];

9753 libraryHaskellDepends = [

9754 array base bytestring containers directory filepath pretty process

9755 syb

9756 ];

9757 libraryToolDepends = [ alex happy ];

9758 homepage = "http://www.sivity.net/projects/language.c/";

9759 description = "Analysis and generation of C code";

9760 license = stdenv.lib.licenses.bsd3;

9761 }) {};

9762 "language-ecmascript" = callPackage

9763 ({ mkDerivation, base, containers, data-default-class, Diff

9764 , directory, filepath, HUnit, mtl, parsec, QuickCheck

9765 , template-haskell, test-framework, test-framework-hunit

9766 , test-framework-quickcheck2, testing-feat, uniplate, wl-pprint

9767 }:

9768 mkDerivation {

9769 pname = "language-ecmascript";

9770 version = "0.16.2";

9771 sha256 = "15jvq3wblx67hhvgblqzfdnks6x17hfnivifps5wfs9v1ljkiq1k";

9772 revision = "1";

9773 editedCabalFile = "171x5g1dy3fx4zj9kqxm1cdb3mi6awwwbvlbxn8mhlmd96h143a5";

9774 configureFlags = [

9775 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9776 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9777 "-fsplitbase" "-f-test-hlint"

9778 ];

9779 libraryHaskellDepends = [

9780 base containers data-default-class Diff mtl parsec QuickCheck

9781 template-haskell testing-feat uniplate wl-pprint

9782 ];

9783 testHaskellDepends = [

9784 base containers data-default-class Diff directory filepath HUnit

9785 mtl parsec QuickCheck test-framework test-framework-hunit

9786 test-framework-quickcheck2 uniplate wl-pprint

9787 ];

9788 doCheck = false;

9789 homepage = "http://github.com/jswebtools/language-ecmascript";

9790 description = "JavaScript parser and pretty-printer library";

9791 license = stdenv.lib.licenses.bsd3;

9792 }) {};

9793 "language-glsl" = callPackage

9794 ({ mkDerivation, base, HUnit, parsec, pretty, prettyclass

9795 , test-framework, test-framework-hunit

9796 }:

9797 mkDerivation {

9798 pname = "language-glsl";

9799 version = "0.1.1";

9800 sha256 = "06dc339a2cddzgjda3nzprgr0v2clbhlpl8j81m04i66bbj2l15y";

9801 configureFlags = [

9802 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9803 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9804 "-fsplitbase" "-f-test-hlint"

9805 ];

9806 isLibrary = true;

9807 isExecutable = true;

9808 libraryHaskellDepends = [ base parsec prettyclass ];

9809 executableHaskellDepends = [ base parsec pretty prettyclass ];

9810 testHaskellDepends = [

9811 base HUnit parsec prettyclass test-framework test-framework-hunit

9812 ];

9813 description = "GLSL abstract syntax tree, parser, and pretty-printer";

9814 license = stdenv.lib.licenses.bsd3;

9815 }) {};

9816 "language-haskell-extract" = callPackage

9817 ({ mkDerivation, base, regex-posix, template-haskell }:

9818 mkDerivation {

9819 pname = "language-haskell-extract";

9820 version = "0.2.4";

9821 sha256 = "1nxcs7g8a1sp91bzpy4cj6s31k5pvc3gvig04cbrggv5cvjidnhl";

9822 configureFlags = [

9823 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9824 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9825 "-fsplitbase" "-f-test-hlint"

9826 ];

9827 libraryHaskellDepends = [ base regex-posix template-haskell ];

9828 homepage = "http://github.com/finnsson/template-helper";

9829 description = "Module to automatically extract functions from the local code";

9830 license = stdenv.lib.licenses.bsd3;

9831 }) {};

9832 "language-java" = callPackage

9833 ({ mkDerivation, alex, array, base, cpphs, directory, filepath

9834 , HUnit, mtl, parsec, pretty, QuickCheck, test-framework

9835 , test-framework-hunit, test-framework-quickcheck2

9836 }:

9837 mkDerivation {

9838 pname = "language-java";

9839 version = "0.2.7";

9840 sha256 = "1519grsjw0f4skldxs563qz07mmj1cg72ma0plmvzpas7inkikyf";

9841 configureFlags = [

9842 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9843 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9844 "-fsplitbase" "-f-test-hlint"

9845 ];

9846 libraryHaskellDepends = [ array base cpphs parsec pretty ];

9847 libraryToolDepends = [ alex ];

9848 testHaskellDepends = [

9849 base directory filepath HUnit mtl QuickCheck test-framework

9850 test-framework-hunit test-framework-quickcheck2

9851 ];

9852 doCheck = false;

9853 homepage = "http://github.com/vincenthz/language-java";

9854 description = "Manipulating Java source: abstract syntax, lexer, parser, and pretty-printer";

9855 license = stdenv.lib.licenses.bsd3;

9856 }) {};

9857 "language-javascript" = callPackage

9858 ({ mkDerivation, alex, array, base, blaze-builder, bytestring

9859 , Cabal, containers, happy, HUnit, mtl, QuickCheck, test-framework

9860 , test-framework-hunit, utf8-light, utf8-string

9861 }:

9862 mkDerivation {

9863 pname = "language-javascript";

9864 version = "0.5.13.3";

9865 sha256 = "069spax169v0qq5axwccgxdmiyjlnjg1bhzqh09dp5yx9w5fk47x";

9866 configureFlags = [

9867 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9868 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9869 "-fsplitbase" "-f-test-hlint"

9870 ];

9871 libraryHaskellDepends = [

9872 array base blaze-builder bytestring containers mtl utf8-string

9873 ];

9874 libraryToolDepends = [ alex happy ];

9875 testHaskellDepends = [

9876 array base blaze-builder bytestring Cabal containers HUnit mtl

9877 QuickCheck test-framework test-framework-hunit utf8-light

9878 utf8-string

9879 ];

9880 homepage = "http://github.com/alanz/language-javascript";

9881 description = "Parser for JavaScript";

9882 license = stdenv.lib.licenses.bsd3;

9883 }) {};

9884 "lazy-csv" = callPackage

9885 ({ mkDerivation, base, bytestring }:

9886 mkDerivation {

9887 pname = "lazy-csv";

9888 version = "0.5";

9889 sha256 = "0xm5j3why2wfajcn7r8my63ranq2mm7jlj15dj153n2izgvd1dh0";

9890 configureFlags = [

9891 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9892 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9893 "-fsplitbase" "-f-test-hlint"

9894 ];

9895 isLibrary = true;

9896 isExecutable = true;

9897 libraryHaskellDepends = [ base bytestring ];

9898 executableHaskellDepends = [ base bytestring ];

9899 homepage = "http://code.haskell.org/lazy-csv";

9900 description = "Efficient lazy parsers for CSV (comma-separated values)";

9901 license = stdenv.lib.licenses.bsd3;

9902 }) {};

9903 "lca" = callPackage

9904 ({ mkDerivation, base, doctest }:

9905 mkDerivation {

9906 pname = "lca";

9907 version = "0.2.4";

9908 sha256 = "0dj7qz5wnrgqipmxim8y8jwgkwn8skkqxbd2w2kiy9s380pfdbsi";

9909 revision = "1";

9910 editedCabalFile = "08mjkpjrnccvzdpp4g0p0li33lnkk15g0b7lh83v56sz36ckmz59";

9911 configureFlags = [

9912 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9913 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9914 "-fsplitbase" "-f-test-hlint"

9915 ];

9916 libraryHaskellDepends = [ base ];

9917 testHaskellDepends = [ base doctest ];

9918 homepage = "http://github.com/ekmett/lca/";

9919 description = "O(log n) persistent on-line lowest common ancestor calculation without preprocessing";

9920 license = stdenv.lib.licenses.bsd3;

9921 }) {};

9922 "lens" = callPackage

9923 ({ mkDerivation, array, base, bifunctors, bytestring, comonad

9924 , comonads-fd, containers, contravariant, criterion, deepseq

9925 , directory, distributive, doctest, exceptions, filepath, free

9926 , generic-deriving, ghc-prim, hashable, HUnit, mtl, nats, parallel

9927 , primitive, profunctors, QuickCheck, reflection, semigroupoids

9928 , semigroups, simple-reflect, split, tagged, template-haskell

9929 , test-framework, test-framework-hunit, test-framework-quickcheck2

9930 , test-framework-th, text, transformers, transformers-compat

9931 , unordered-containers, vector, void

9932 }:

9933 mkDerivation {

9934 pname = "lens";

9935 version = "4.6.0.1";

9936 sha256 = "099hhkca39zxfj9xavd2rafzgm2r4nm8clngcsgcrn1qsy8knvz2";

9937 revision = "3";

9938 editedCabalFile = "0jnyqfm4fy5iqwwharaxigzd6rffwnmxqgizlpyijkkd57lilf8z";

9939 configureFlags = [

9940 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9941 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9942 "-fsplitbase" "-f-test-hlint"

9943 ];

9944 libraryHaskellDepends = [

9945 array base bifunctors bytestring comonad containers contravariant

9946 distributive exceptions filepath free ghc-prim hashable mtl

9947 parallel primitive profunctors reflection semigroupoids semigroups

9948 split tagged template-haskell text transformers transformers-compat

9949 unordered-containers vector void

9950 ];

9951 testHaskellDepends = [

9952 base bytestring containers deepseq directory doctest filepath

9953 generic-deriving HUnit mtl nats parallel QuickCheck semigroups

9954 simple-reflect split test-framework test-framework-hunit

9955 test-framework-quickcheck2 test-framework-th text transformers

9956 unordered-containers vector

9957 ];

9958 benchmarkHaskellDepends = [

9959 base comonad comonads-fd criterion deepseq generic-deriving

9960 transformers

9961 ];

9962 homepage = "http://github.com/ekmett/lens/";

9963 description = "Lenses, Folds and Traversals";

9964 license = stdenv.lib.licenses.bsd3;

9965 }) {};

9966 "lens-aeson" = callPackage

9967 ({ mkDerivation, aeson, attoparsec, base, bytestring, directory

9968 , doctest, filepath, generic-deriving, lens, scientific, semigroups

9969 , simple-reflect, text, unordered-containers, vector

9970 }:

9971 mkDerivation {

9972 pname = "lens-aeson";

9973 version = "1.0.0.3";

9974 sha256 = "0wfbnazarwcza5dn3icsdvsmkyf9ki5lr5d5yidmgijhs63ak7ac";

9975 configureFlags = [

9976 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

9977 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

9978 "-fsplitbase" "-f-test-hlint"

9979 ];

9980 libraryHaskellDepends = [

9981 aeson attoparsec base bytestring lens scientific text

9982 unordered-containers vector

9983 ];

9984 testHaskellDepends = [

9985 base directory doctest filepath generic-deriving semigroups

9986 simple-reflect

9987 ];

9988 homepage = "http://github.com/lens/lens-aeson/";

9989 description = "Law-abiding lenses for aeson";

9990 license = stdenv.lib.licenses.bsd3;

9991 }) {};

9992 "lens-family-th" = callPackage

9993 ({ mkDerivation, base, template-haskell }:

9994 mkDerivation {

9995 pname = "lens-family-th";

9996 version = "0.4.1.0";

9997 sha256 = "084yng26xyhw6c6hij3p70zvjpvm1dlw6klphw51car9gi6dqkvm";

9998 revision = "2";

9999 editedCabalFile = "0simbh9r9gjb375slxpbnlxfj594fm5k1gh33k4x23i5vjg1934p";

10000 configureFlags = [

10001 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10002 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10003 "-fsplitbase" "-f-test-hlint"

10004 ];

10005 libraryHaskellDepends = [ base template-haskell ];

10006 homepage = "http://github.com/DanBurton/lens-family-th#readme";

10007 description = "Generate lens-family style lenses";

10008 license = stdenv.lib.licenses.bsd3;

10009 }) {};

10010 "lhs2tex" = callPackage

10011 ({ mkDerivation, base, directory, filepath, mtl, process

10012 , regex-compat

10013 }:

10014 mkDerivation {

10015 pname = "lhs2tex";

10016 version = "1.18.1";

10017 sha256 = "0j4n7vkabsggn94gbwixy1vmckdck2nggdiqvk6n9nx164if5jnw";

10018 configureFlags = [

10019 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10020 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10021 "-fsplitbase" "-f-test-hlint"

10022 ];

10023 isLibrary = false;

10024 isExecutable = true;

10025 executableHaskellDepends = [

10026 base directory filepath mtl process regex-compat

10027 ];

10028 doHaddock = false;

10029 homepage = "http://www.andres-loeh.de/lhs2tex/";

10030 description = "Preprocessor for typesetting Haskell sources with LaTeX";

10031 license = "GPL";

10032 }) {};

10033 "libgit" = callPackage

10034 ({ mkDerivation, base, mtl, process }:

10035 mkDerivation {

10036 pname = "libgit";

10037 version = "0.3.0";

10038 sha256 = "0k2287d84s0p73md1mfcyg1qy1l5ncgrvmkaa7607d8zlk9b8ci6";

10039 configureFlags = [

10040 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10041 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10042 "-fsplitbase" "-f-test-hlint"

10043 ];

10044 enableSeparateDataOutput = true;

10045 libraryHaskellDepends = [ base mtl process ];

10046 homepage = "http://github.com/vincenthz/hs-tls";

10047 description = "Simple Git Wrapper";

10048 license = stdenv.lib.licenses.bsd3;

10049 }) {};

10050 "libnotify" = callPackage

10051 ({ mkDerivation, base, bytestring, glib, gtk, libnotify }:

10052 mkDerivation {

10053 pname = "libnotify";

10054 version = "0.1.1.0";

10055 sha256 = "1wc19v14agadj7dzi81lm3qzk2x33apaj5ylmg7x232k56xzfvr0";

10056 configureFlags = [

10057 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10058 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10059 "-fsplitbase" "-f-test-hlint"

10060 ];

10061 libraryHaskellDepends = [ base bytestring glib gtk ];

10062 librarySystemDepends = [ libnotify ];

10063 description = "Bindings to libnotify library";

10064 license = stdenv.lib.licenses.mit;

10065 }) {inherit (pkgs) libnotify;};

10066 "lifted-async" = callPackage

10067 ({ mkDerivation, async, base, criterion, deepseq, HUnit

10068 , lifted-base, monad-control, mtl, tasty, tasty-hunit, tasty-th

10069 , transformers-base

10070 }:

10071 mkDerivation {

10072 pname = "lifted-async";

10073 version = "0.2.0.2";

10074 sha256 = "07sqgd3lxplfwrpys4jhz0068sx99765lpx8n4nj3k117z32slgf";

10075 revision = "1";

10076 editedCabalFile = "1rlk35fgk5403kizfqf4jy7vmv08kx2xwjayma1y4v0q4zygf6d5";

10077 configureFlags = [

10078 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10079 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10080 "-fsplitbase" "-f-test-hlint"

10081 ];

10082 libraryHaskellDepends = [

10083 async base lifted-base monad-control transformers-base

10084 ];

10085 testHaskellDepends = [

10086 async base HUnit lifted-base monad-control mtl tasty tasty-hunit

10087 tasty-th

10088 ];

10089 benchmarkHaskellDepends = [ async base criterion deepseq ];

10090 homepage = "https://github.com/maoe/lifted-async";

10091 description = "Run lifted IO operations asynchronously and wait for their results";

10092 license = stdenv.lib.licenses.bsd3;

10093 }) {};

10094 "lifted-base" = callPackage

10095 ({ mkDerivation, base, monad-control, transformers-base }:

10096 mkDerivation {

10097 pname = "lifted-base";

10098 version = "0.2.3.6";

10099 sha256 = "1yz14a1rsgknwyl08n4kxrlc26hfwmb95a3c2drbnsgmhdyq7iap";

10100 configureFlags = [

10101 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10102 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10103 "-fsplitbase" "-f-test-hlint"

10104 ];

10105 libraryHaskellDepends = [ base monad-control transformers-base ];

10106 doCheck = false;

10107 homepage = "https://github.com/basvandijk/lifted-base";

10108 description = "lifted IO operations from the base library";

10109 license = stdenv.lib.licenses.bsd3;

10110 }) {};

10111 "linear" = callPackage

10112 ({ mkDerivation, adjunctions, base, binary, bytestring, containers

10113 , directory, distributive, doctest, filepath, ghc-prim, hashable

10114 , HUnit, lens, reflection, semigroupoids, semigroups

10115 , simple-reflect, tagged, template-haskell, test-framework

10116 , test-framework-hunit, transformers, unordered-containers, vector

10117 , void

10118 }:

10119 mkDerivation {

10120 pname = "linear";

10121 version = "1.15.5";

10122 sha256 = "17fxz49zj6vklgfs583zpn7naqgp5mv2zsvmxrv80ym8r52mp5mi";

10123 revision = "1";

10124 editedCabalFile = "0s6zj8gi6vrxk0a239s6nc5lnmfrcjx2idccl436xd6c6a8fd6c2";

10125 configureFlags = [

10126 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10127 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10128 "-fsplitbase" "-f-test-hlint"

10129 ];

10130 libraryHaskellDepends = [

10131 adjunctions base binary containers distributive ghc-prim hashable

10132 lens reflection semigroupoids semigroups tagged template-haskell

10133 transformers unordered-containers vector void

10134 ];

10135 testHaskellDepends = [

10136 base binary bytestring directory doctest filepath HUnit lens

10137 simple-reflect test-framework test-framework-hunit

10138 ];

10139 homepage = "http://github.com/ekmett/linear/";

10140 description = "Linear Algebra";

10141 license = stdenv.lib.licenses.bsd3;

10142 }) {};

10143 "linear-accelerate" = callPackage

10144 ({ mkDerivation, accelerate, base, lens, linear }:

10145 mkDerivation {

10146 pname = "linear-accelerate";

10147 version = "0.2";

10148 sha256 = "0433mzw2cswk86nmj3gnygn3d07yq0sbmv2ylxbw8ri35yddjap6";

10149 configureFlags = [

10150 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10151 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10152 "-fsplitbase" "-f-test-hlint"

10153 ];

10154 libraryHaskellDepends = [ accelerate base lens linear ];

10155 homepage = "http://github.com/ekmett/linear-accelerate/";

10156 description = "Instances to use linear vector spaces on accelerate backends";

10157 license = stdenv.lib.licenses.bsd3;

10158 }) {};

10159 "list-t" = callPackage

10160 ({ mkDerivation, base-prelude, mmorph, monad-control, transformers

10161 , transformers-base

10162 }:

10163 mkDerivation {

10164 pname = "list-t";

10165 version = "0.4.3";

10166 sha256 = "0di3w397cib37snazjvqgfsaapcwa136xcn032p5f5s5njkn3sid";

10167 configureFlags = [

10168 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10169 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10170 "-fsplitbase" "-f-test-hlint"

10171 ];

10172 libraryHaskellDepends = [

10173 base-prelude mmorph monad-control transformers transformers-base

10174 ];

10175 doCheck = false;

10176 homepage = "https://github.com/nikita-volkov/list-t";

10177 description = "ListT done right";

10178 license = stdenv.lib.licenses.mit;

10179 }) {};

10180 "loch-th" = callPackage

10181 ({ mkDerivation, base, pretty, template-haskell }:

10182 mkDerivation {

10183 pname = "loch-th";

10184 version = "0.2.1";

10185 sha256 = "1kfrjsgzq6wl749n2wm1fhwwigjxcd9lww7whiwjrbmhiz5ism3p";

10186 configureFlags = [

10187 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10188 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10189 "-fsplitbase" "-f-test-hlint"

10190 ];

10191 libraryHaskellDepends = [ base pretty template-haskell ];

10192 homepage = "https://github.com/liskin/loch-th";

10193 description = "Support for precise error locations in source files (Template Haskell version)";

10194 license = stdenv.lib.licenses.bsd3;

10195 }) {};

10196 "log-domain" = callPackage

10197 ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq

10198 , directory, distributive, doctest, filepath, generic-deriving

10199 , hashable, hashable-extras, safecopy, semigroupoids, semigroups

10200 , simple-reflect, vector

10201 }:

10202 mkDerivation {

10203 pname = "log-domain";

10204 version = "0.9.3";

10205 sha256 = "1l07pi7lnwyk3y747f7bgr1200p6apyfn7bch5v30kh7dy0wyi8m";

10206 configureFlags = [

10207 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10208 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10209 "-fsplitbase" "-f-test-hlint"

10210 ];

10211 libraryHaskellDepends = [

10212 base binary bytes cereal comonad deepseq distributive

10213 generic-deriving hashable hashable-extras safecopy semigroupoids

10214 semigroups vector

10215 ];

10216 testHaskellDepends = [

10217 base directory doctest filepath generic-deriving semigroups

10218 simple-reflect

10219 ];

10220 homepage = "http://github.com/analytics/log-domain/";

10221 description = "Log-domain arithmetic";

10222 license = stdenv.lib.licenses.bsd3;

10223 }) {};

10224 "logfloat" = callPackage

10225 ({ mkDerivation, array, base }:

10226 mkDerivation {

10227 pname = "logfloat";

10228 version = "0.12.1";

10229 sha256 = "1k13jjqv4df341hcj9hzrlisfx9wrsmyqvzi6ricx341d9z4ch05";

10230 revision = "1";

10231 editedCabalFile = "06d4dlwvmr7akcf4cxg1xhq41zgacbalflvbhq7aj0v3pw2rs7as";

10232 configureFlags = [

10233 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10234 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10235 "-fsplitbase" "-f-test-hlint"

10236 ];

10237 libraryHaskellDepends = [ array base ];

10238 homepage = "http://code.haskell.org/~wren/";

10239 description = "Log-domain floating point numbers";

10240 license = stdenv.lib.licenses.bsd3;

10241 }) {};

10242 "logict" = callPackage

10243 ({ mkDerivation, base, mtl }:

10244 mkDerivation {

10245 pname = "logict";

10246 version = "0.6.0.2";

10247 sha256 = "07hnirv6snnym2r7iijlfz00b60jpy2856zvqxh989q0in7bd0hi";

10248 configureFlags = [

10249 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10250 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10251 "-fsplitbase" "-f-test-hlint"

10252 ];

10253 libraryHaskellDepends = [ base mtl ];

10254 homepage = "http://code.haskell.org/~dolio/";

10255 description = "A backtracking logic-programming monad";

10256 license = stdenv.lib.licenses.bsd3;

10257 }) {};

10258 "loop" = callPackage

10259 ({ mkDerivation, base, criterion, hspec, mtl, random, vector }:

10260 mkDerivation {

10261 pname = "loop";

10262 version = "0.2.0";

10263 sha256 = "11ifqahlg9ky5klid1fhsyfvfb6w8yb0dsy43s0cxcmldbw3qv5x";

10264 configureFlags = [

10265 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10266 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10267 "-fsplitbase" "-f-test-hlint"

10268 ];

10269 libraryHaskellDepends = [ base ];

10270 testHaskellDepends = [ base hspec mtl ];

10271 benchmarkHaskellDepends = [ base criterion mtl random vector ];

10272 homepage = "https://github.com/nh2/loop";

10273 description = "Fast loops (for when GHC can't optimize forM_)";

10274 license = stdenv.lib.licenses.mit;

10275 }) {};

10276 "lucid" = callPackage

10277 ({ mkDerivation, base, bifunctors, blaze-builder, bytestring

10278 , containers, criterion, deepseq, hspec, HUnit, mtl, parsec, text

10279 , transformers, unordered-containers

10280 }:

10281 mkDerivation {

10282 pname = "lucid";

10283 version = "2.5";

10284 sha256 = "0q6jkz4czjr4bdwjdv5yvkiq1dhkjcn3zc1y4xj5yrlbn93708zj";

10285 revision = "1";

10286 editedCabalFile = "061cxf8vz2gxsw604kjnzy8wh79605hfqlb2gy34nb3zqdni8ag0";

10287 configureFlags = [

10288 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10289 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10290 "-fsplitbase" "-f-test-hlint"

10291 ];

10292 libraryHaskellDepends = [

10293 base blaze-builder bytestring containers mtl text transformers

10294 unordered-containers

10295 ];

10296 testHaskellDepends = [

10297 base bifunctors hspec HUnit mtl parsec text

10298 ];

10299 benchmarkHaskellDepends = [

10300 base blaze-builder bytestring criterion deepseq text

10301 ];

10302 homepage = "https://github.com/chrisdone/lucid";

10303 description = "Clear to write, read and edit DSL for HTML";

10304 license = stdenv.lib.licenses.bsd3;

10305 }) {};

10306 "lzma-conduit" = callPackage

10307 ({ mkDerivation, base, bindings-DSL, bytestring, conduit, HUnit

10308 , lzma, QuickCheck, resourcet, test-framework, test-framework-hunit

10309 , test-framework-quickcheck2, transformers

10310 }:

10311 mkDerivation {

10312 pname = "lzma-conduit";

10313 version = "1.1.3";

10314 sha256 = "01pf7q56y4m377qcbfwdv767dhlvkhd4cs01bqcg9k667iy21fr4";

10315 configureFlags = [

10316 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10317 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10318 "-fsplitbase" "-f-test-hlint"

10319 ];

10320 libraryHaskellDepends = [

10321 base bindings-DSL bytestring conduit resourcet transformers

10322 ];

10323 librarySystemDepends = [ lzma ];

10324 testHaskellDepends = [

10325 base bytestring conduit HUnit QuickCheck resourcet test-framework

10326 test-framework-hunit test-framework-quickcheck2

10327 ];

10328 homepage = "http://github.com/alphaHeavy/lzma-conduit";

10329 description = "Conduit interface for lzma/xz compression";

10330 license = stdenv.lib.licenses.bsd3;

10331 }) {inherit (pkgs) lzma;};

10332 "machines" = callPackage

10333 ({ mkDerivation, base, comonad, containers, directory, doctest

10334 , filepath, free, mtl, pointed, profunctors, semigroups

10335 , transformers, void

10336 }:

10337 mkDerivation {

10338 pname = "machines";

10339 version = "0.4.1";

10340 sha256 = "1wripnvpzfdnf7i2aygjyh33cp7srkb5638snwyn700bjbi2j7gb";

10341 revision = "2";

10342 editedCabalFile = "0afl8xydl9n29wysznrfwbx64y12243nnji6vzqvdarfwgv5h06i";

10343 configureFlags = [

10344 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10345 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10346 "-fsplitbase" "-f-test-hlint"

10347 ];

10348 libraryHaskellDepends = [

10349 base comonad containers free mtl pointed profunctors semigroups

10350 transformers void

10351 ];

10352 testHaskellDepends = [ base directory doctest filepath ];

10353 homepage = "http://github.com/ekmett/machines/";

10354 description = "Networked stream transducers";

10355 license = stdenv.lib.licenses.bsd3;

10356 }) {};

10357 "mandrill" = callPackage

10358 ({ mkDerivation, aeson, base, base64-bytestring, blaze-html

10359 , bytestring, containers, email-validate, http-client

10360 , http-client-tls, http-types, lens, mtl, old-locale, QuickCheck

10361 , raw-strings-qq, tasty, tasty-hunit, tasty-quickcheck, text, time

10362 }:

10363 mkDerivation {

10364 pname = "mandrill";

10365 version = "0.1.1.0";

10366 sha256 = "12i7475r75n1azgpliyw8q1k6vhaksg7dasrn38x19czzg5mijq9";

10367 configureFlags = [

10368 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10369 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10370 "-fsplitbase" "-f-test-hlint"

10371 ];

10372 libraryHaskellDepends = [

10373 aeson base base64-bytestring blaze-html bytestring containers

10374 email-validate http-client http-client-tls http-types lens mtl

10375 old-locale QuickCheck text time

10376 ];

10377 testHaskellDepends = [

10378 aeson base bytestring QuickCheck raw-strings-qq tasty tasty-hunit

10379 tasty-quickcheck text

10380 ];

10381 description = "Library for interfacing with the Mandrill JSON API";

10382 license = stdenv.lib.licenses.mit;

10383 }) {};

10384 "map-syntax" = callPackage

10385 ({ mkDerivation, base, containers, deepseq, HUnit, mtl, QuickCheck

10386 , test-framework, test-framework-hunit, test-framework-quickcheck2

10387 , transformers

10388 }:

10389 mkDerivation {

10390 pname = "map-syntax";

10391 version = "0.2";

10392 sha256 = "02v1dvq86qzbfbwbza4myj3a6a6a5p059fi5m3g548hmqk3v2p1r";

10393 configureFlags = [

10394 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10395 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10396 "-fsplitbase" "-f-test-hlint"

10397 ];

10398 libraryHaskellDepends = [ base containers mtl ];

10399 testHaskellDepends = [

10400 base containers deepseq HUnit mtl QuickCheck test-framework

10401 test-framework-hunit test-framework-quickcheck2 transformers

10402 ];

10403 description = "Syntax sugar for defining maps";

10404 license = stdenv.lib.licenses.bsd3;

10405 }) {};

10406 "markdown" = callPackage

10407 ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup

10408 , conduit, conduit-extra, containers, data-default, hspec

10409 , system-fileio, system-filepath, text, transformers, xss-sanitize

10410 }:

10411 mkDerivation {

10412 pname = "markdown";

10413 version = "0.1.13.1";

10414 sha256 = "0b10cvz5yryzrzfg2j0pikhfxcly7x4hfmjwnwycs4hy97h2rdnq";

10415 configureFlags = [

10416 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10417 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10418 "-fsplitbase" "-f-test-hlint"

10419 ];

10420 libraryHaskellDepends = [

10421 attoparsec base blaze-html blaze-markup conduit conduit-extra

10422 containers data-default text transformers xss-sanitize

10423 ];

10424 testHaskellDepends = [

10425 base blaze-html conduit conduit-extra containers hspec

10426 system-fileio system-filepath text transformers

10427 ];

10428 homepage = "https://github.com/snoyberg/markdown";

10429 description = "Convert Markdown to HTML, with XSS protection";

10430 license = stdenv.lib.licenses.bsd3;

10431 }) {};

10432 "markdown-unlit" = callPackage

10433 ({ mkDerivation, base, directory, hspec, QuickCheck, silently

10434 , stringbuilder

10435 }:

10436 mkDerivation {

10437 pname = "markdown-unlit";

10438 version = "0.2.0.1";

10439 sha256 = "1bc3vcifv2xcddh8liq380c6sxarrs5pf21pfs9i4dx9rfl3hvhq";

10440 configureFlags = [

10441 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10442 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10443 "-fsplitbase" "-f-test-hlint"

10444 ];

10445 isLibrary = true;

10446 isExecutable = true;

10447 libraryHaskellDepends = [ base ];

10448 executableHaskellDepends = [ base ];

10449 testHaskellDepends = [

10450 base directory hspec QuickCheck silently stringbuilder

10451 ];

10452 description = "Literate Haskell support for Markdown";

10453 license = stdenv.lib.licenses.mit;

10454 }) {};

10455 "math-functions" = callPackage

10456 ({ mkDerivation, base, deepseq, erf, HUnit, ieee754, QuickCheck

10457 , test-framework, test-framework-hunit, test-framework-quickcheck2

10458 , vector, vector-th-unbox

10459 }:

10460 mkDerivation {

10461 pname = "math-functions";

10462 version = "0.1.5.2";

10463 sha256 = "12cznf7gwia1ki7xhvlhk5p8d09zrdvfgn07pkp4sfrwsc4vijcy";

10464 revision = "1";

10465 editedCabalFile = "1zb582xpxpybfvxnivkf7l4mr2sbds4673h89gb1slqxgq7haary";

10466 configureFlags = [

10467 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10468 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10469 "-fsplitbase" "-f-test-hlint"

10470 ];

10471 libraryHaskellDepends = [

10472 base deepseq erf vector vector-th-unbox

10473 ];

10474 testHaskellDepends = [

10475 base HUnit ieee754 QuickCheck test-framework test-framework-hunit

10476 test-framework-quickcheck2 vector

10477 ];

10478 doCheck = false;

10479 homepage = "https://github.com/bos/math-functions";

10480 description = "Special functions and Chebyshev polynomials";

10481 license = stdenv.lib.licenses.bsd3;

10482 }) {};

10483 "matrix" = callPackage

10484 ({ mkDerivation, base, criterion, deepseq, loop, primitive

10485 , QuickCheck, tasty, tasty-quickcheck, vector

10486 }:

10487 mkDerivation {

10488 pname = "matrix";

10489 version = "0.3.4.2";

10490 sha256 = "0i45k524z4hf43dab9dgis3ggcswjm0chlxqfc2rqh581gx85sgm";

10491 revision = "1";

10492 editedCabalFile = "0d2q4dybsmyrqx7llww6ff42inck3fq5h63246kq11xzaa3hxkgz";

10493 configureFlags = [

10494 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10495 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10496 "-fsplitbase" "-f-test-hlint"

10497 ];

10498 libraryHaskellDepends = [ base deepseq loop primitive vector ];

10499 testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];

10500 benchmarkHaskellDepends = [ base criterion ];

10501 description = "A native implementation of matrix operations";

10502 license = stdenv.lib.licenses.bsd3;

10503 }) {};

10504 "mersenne-random-pure64" = callPackage

10505 ({ mkDerivation, base, old-time, random }:

10506 mkDerivation {

10507 pname = "mersenne-random-pure64";

10508 version = "0.2.0.4";

10509 sha256 = "0qh72ynfg1k4c70qxdzsa6f1x9wyxil2d9gi85c879wrc41k899h";

10510 configureFlags = [

10511 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10512 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-f-small_base"

10513 "-fsplitbase" "-f-test-hlint"

10514 ];

10515 libraryHaskellDepends = [ base old-time random ];

10516 homepage = "http://code.haskell.org/~dons/code/mersenne-random-pure64/";

10517 description = "Generate high quality pseudorandom numbers purely using a Mersenne Twister";

10518 license = stdenv.lib.licenses.bsd3;

10519 }) {};

10520 "messagepack" = callPackage

10521 ({ mkDerivation, attoparsec, base, bytestring, cereal, containers

10522 , QuickCheck, test-framework, test-framework-quickcheck2

10523 , test-framework-th, text

10524 }:

10525 mkDerivation {

10526 pname = "messagepack";

10527 version = "0.3.0";

10528 sha256 = "1icl40fh9glzr105aha3971gnbnzw528sgdia8kwlj751v3nnpa0";

10529 configureFlags = [

10530 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10531 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10532 "-fsplitbase" "-f-test-hlint"

10533 ];

10534 libraryHaskellDepends = [

10535 attoparsec base bytestring cereal containers text

10536 ];

10537 testHaskellDepends = [

10538 base bytestring cereal containers QuickCheck test-framework

10539 test-framework-quickcheck2 test-framework-th text

10540 ];

10541 homepage = "https://github.com/rodrigosetti/messagepack";

10542 description = "Serialize instance for Message Pack Object";

10543 license = stdenv.lib.licenses.mit;

10544 }) {};

10545 "messagepack-rpc" = callPackage

10546 ({ mkDerivation, base, bytestring, cereal, containers, messagepack

10547 , network-simple, text

10548 }:

10549 mkDerivation {

10550 pname = "messagepack-rpc";

10551 version = "0.1.0.3";

10552 sha256 = "0g9lj3fb81gng3z4kdikwa9vgz73hjdqygzhcqd8fphcynv8j6m1";

10553 configureFlags = [

10554 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10555 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10556 "-fsplitbase" "-f-test-hlint"

10557 ];

10558 libraryHaskellDepends = [

10559 base bytestring cereal containers messagepack network-simple text

10560 ];

10561 homepage = "http://github.com/rodrigosetti/messagepack-rpc";

10562 description = "Message Pack RPC over TCP";

10563 license = stdenv.lib.licenses.mit;

10564 }) {};

10565 "mime-mail" = callPackage

10566 ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring

10567 , filepath, hspec, process, random, text

10568 }:

10569 mkDerivation {

10570 pname = "mime-mail";

10571 version = "0.4.8.2";

10572 sha256 = "19f2q4x8b19sc7y1yyxvl3fsyggjs07yhf1zjw42a875lp4mnvia";

10573 configureFlags = [

10574 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10575 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10576 "-fsplitbase" "-f-test-hlint"

10577 ];

10578 libraryHaskellDepends = [

10579 base base64-bytestring blaze-builder bytestring filepath process

10580 random text

10581 ];

10582 testHaskellDepends = [ base blaze-builder bytestring hspec text ];

10583 homepage = "http://github.com/snoyberg/mime-mail";

10584 description = "Compose MIME email messages";

10585 license = stdenv.lib.licenses.mit;

10586 }) {};

10587 "mime-mail-ses" = callPackage

10588 ({ mkDerivation, base, base64-bytestring, byteable, bytestring

10589 , conduit, cryptohash, http-client, http-conduit, http-types

10590 , mime-mail, old-locale, text, time, transformers, xml-conduit

10591 , xml-types

10592 }:

10593 mkDerivation {

10594 pname = "mime-mail-ses";

10595 version = "0.3.2.2";

10596 sha256 = "1dzlfrpqw3bdqkwgp5i52azkp8lv2cgvrdvl1w39q484ra4by2y1";

10597 configureFlags = [

10598 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10599 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10600 "-fsplitbase" "-f-test-hlint"

10601 ];

10602 libraryHaskellDepends = [

10603 base base64-bytestring byteable bytestring conduit cryptohash

10604 http-client http-conduit http-types mime-mail old-locale text time

10605 transformers xml-conduit xml-types

10606 ];

10607 homepage = "http://github.com/snoyberg/mime-mail";

10608 description = "Send mime-mail messages via Amazon SES";

10609 license = stdenv.lib.licenses.mit;

10610 }) {};

10611 "mime-types" = callPackage

10612 ({ mkDerivation, base, bytestring, containers, text }:

10613 mkDerivation {

10614 pname = "mime-types";

10615 version = "0.1.0.6";

10616 sha256 = "090z3dp928243amnc6s8g10rk2h2bprk9y138q6wj3cpflzr72pw";

10617 configureFlags = [

10618 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10619 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10620 "-fsplitbase" "-f-test-hlint"

10621 ];

10622 libraryHaskellDepends = [ base bytestring containers text ];

10623 homepage = "https://github.com/yesodweb/wai";

10624 description = "Basic mime-type handling types and functions";

10625 license = stdenv.lib.licenses.mit;

10626 }) {};

10627 "missing-foreign" = callPackage

10628 ({ mkDerivation, base }:

10629 mkDerivation {

10630 pname = "missing-foreign";

10631 version = "0.1.1";

10632 sha256 = "11f8pknbarlj956nmalqhd2v704z7d7xbi61hs1q8vb2p36kc6wy";

10633 configureFlags = [

10634 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10635 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10636 "-fsplitbase" "-f-test-hlint"

10637 ];

10638 libraryHaskellDepends = [ base ];

10639 description = "Convenience functions for FFI work";

10640 license = stdenv.lib.licenses.bsd3;

10641 }) {};

10642 "mmap" = callPackage

10643 ({ mkDerivation, base, bytestring }:

10644 mkDerivation {

10645 pname = "mmap";

10646 version = "0.5.9";

10647 sha256 = "1y5mk3yf4b8r6rzmlx1xqn4skaigrqnv08sqq0v7r3nbw42bpz2q";

10648 configureFlags = [

10649 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10650 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10651 "-fsplitbase" "-f-test-hlint"

10652 ];

10653 isLibrary = true;

10654 isExecutable = true;

10655 libraryHaskellDepends = [ base bytestring ];

10656 description = "Memory mapped files for POSIX and Windows";

10657 license = stdenv.lib.licenses.bsd3;

10658 }) {};

10659 "mmorph" = callPackage

10660 ({ mkDerivation, base, transformers }:

10661 mkDerivation {

10662 pname = "mmorph";

10663 version = "1.0.4";

10664 sha256 = "0k5zlzmnixfwcjrqvhgi3i6xg532b0gsjvc39v5jigw69idndqr2";

10665 configureFlags = [

10666 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10667 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10668 "-fsplitbase" "-f-test-hlint"

10669 ];

10670 libraryHaskellDepends = [ base transformers ];

10671 description = "Monad morphisms";

10672 license = stdenv.lib.licenses.bsd3;

10673 }) {};

10674 "monad-control" = callPackage

10675 ({ mkDerivation, base, transformers, transformers-base

10676 , transformers-compat

10677 }:

10678 mkDerivation {

10679 pname = "monad-control";

10680 version = "0.3.3.1";

10681 sha256 = "02v4j0z92r1za8l5q87zmhns1lbnfqqg1cnfy4l4yf8y9d2l2g2z";

10682 configureFlags = [

10683 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10684 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10685 "-fsplitbase" "-f-test-hlint"

10686 ];

10687 libraryHaskellDepends = [

10688 base transformers transformers-base transformers-compat

10689 ];

10690 homepage = "https://github.com/basvandijk/monad-control";

10691 description = "Lift control operations, like exception catching, through monad transformers";

10692 license = stdenv.lib.licenses.bsd3;

10693 }) {};

10694 "monad-coroutine" = callPackage

10695 ({ mkDerivation, base, monad-parallel, transformers

10696 , transformers-compat

10697 }:

10698 mkDerivation {

10699 pname = "monad-coroutine";

10700 version = "0.8.0.1";

10701 sha256 = "0jzy6rdkwh7cfrq1ci8kfxyy6mydk5xlksxba8fy1qzsi8a7dshy";

10702 configureFlags = [

10703 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10704 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10705 "-fsplitbase" "-f-test-hlint"

10706 ];

10707 libraryHaskellDepends = [

10708 base monad-parallel transformers transformers-compat

10709 ];

10710 homepage = "http://trac.haskell.org/SCC/wiki/monad-coroutine";

10711 description = "Coroutine monad transformer for suspending and resuming monadic computations";

10712 license = "GPL";

10713 }) {};

10714 "monad-extras" = callPackage

10715 ({ mkDerivation, base, mmorph, monad-control, stm, transformers

10716 , transformers-base

10717 }:

10718 mkDerivation {

10719 pname = "monad-extras";

10720 version = "0.5.9";

10721 sha256 = "1y24yz635brllfygia1mbln4d8xiwb0pq0izh5pil7511gijhs0s";

10722 configureFlags = [

10723 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10724 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10725 "-fsplitbase" "-f-test-hlint"

10726 ];

10727 libraryHaskellDepends = [

10728 base mmorph monad-control stm transformers transformers-base

10729 ];

10730 homepage = "http://github.com/jwiegley/monad-extras";

10731 description = "Extra utility functions for working with monads";

10732 license = stdenv.lib.licenses.bsd3;

10733 }) {};

10734 "monad-journal" = callPackage

10735 ({ mkDerivation, base, either, monad-control, mtl, transformers

10736 , transformers-base

10737 }:

10738 mkDerivation {

10739 pname = "monad-journal";

10740 version = "0.6.0.2";

10741 sha256 = "1lbvmc1192jvncza6mmbvz8szjgin6v0xmn80xlhsccjv4bkryx5";

10742 configureFlags = [

10743 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10744 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10745 "-fsplitbase" "-f-test-hlint"

10746 ];

10747 libraryHaskellDepends = [

10748 base either monad-control mtl transformers transformers-base

10749 ];

10750 homepage = "http://github.com/phaazon/monad-journal";

10751 description = "Pure logger typeclass and monad transformer";

10752 license = stdenv.lib.licenses.bsd3;

10753 }) {};

10754 "monad-logger" = callPackage

10755 ({ mkDerivation, base, blaze-builder, bytestring, conduit

10756 , conduit-extra, exceptions, fast-logger, lifted-base

10757 , monad-control, monad-loops, mtl, resourcet, stm, stm-chans

10758 , template-haskell, text, transformers, transformers-base

10759 , transformers-compat

10760 }:

10761 mkDerivation {

10762 pname = "monad-logger";

10763 version = "0.3.13.1";

10764 sha256 = "0mwdihxly22axrjs9g741zab2yyrm6zy73di99m7lvg8jdj4m2r6";

10765 configureFlags = [

10766 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10767 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10768 "-fsplitbase" "-f-test-hlint"

10769 ];

10770 libraryHaskellDepends = [

10771 base blaze-builder bytestring conduit conduit-extra exceptions

10772 fast-logger lifted-base monad-control monad-loops mtl resourcet stm

10773 stm-chans template-haskell text transformers transformers-base

10774 transformers-compat

10775 ];

10776 homepage = "https://github.com/kazu-yamamoto/logger";

10777 description = "A class of monads which can log messages";

10778 license = stdenv.lib.licenses.mit;

10779 }) {};

10780 "monad-loops" = callPackage

10781 ({ mkDerivation, base }:

10782 mkDerivation {

10783 pname = "monad-loops";

10784 version = "0.4.2.1";

10785 sha256 = "1dprwndc0bxzpmrkj1xb9kzjrg3i06zsg43yaabn5x5gcaj8is56";

10786 configureFlags = [

10787 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10788 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10789 "-fsplitbase" "-f-test-hlint"

10790 ];

10791 libraryHaskellDepends = [ base ];

10792 homepage = "https://github.com/mokus0/monad-loops";

10793 description = "Monadic loops";

10794 license = stdenv.lib.licenses.publicDomain;

10795 }) {};

10796 "monad-par" = callPackage

10797 ({ mkDerivation, abstract-deque, abstract-par, array, base

10798 , containers, deepseq, HUnit, monad-par-extras, mtl, mwc-random

10799 , parallel, QuickCheck, test-framework, test-framework-hunit

10800 , test-framework-quickcheck2, test-framework-th, time

10801 }:

10802 mkDerivation {

10803 pname = "monad-par";

10804 version = "0.3.4.7";

10805 sha256 = "12n27hs274nrfkpa6hx0gdkrc76wxzliqf53x6689idl363sdf13";

10806 configureFlags = [

10807 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10808 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10809 "-fsplitbase" "-f-test-hlint"

10810 ];

10811 libraryHaskellDepends = [

10812 abstract-deque abstract-par array base containers deepseq

10813 monad-par-extras mtl mwc-random parallel

10814 ];

10815 testHaskellDepends = [

10816 abstract-deque abstract-par array base containers deepseq HUnit

10817 monad-par-extras mtl mwc-random QuickCheck test-framework

10818 test-framework-hunit test-framework-quickcheck2 test-framework-th

10819 time

10820 ];

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

10822 description = "A library for parallel programming based on a monad";

10823 license = stdenv.lib.licenses.bsd3;

10824 }) {};

10825 "monad-par-extras" = callPackage

10826 ({ mkDerivation, abstract-par, base, cereal, deepseq, mtl, random

10827 , transformers

10828 }:

10829 mkDerivation {

10830 pname = "monad-par-extras";

10831 version = "0.3.3";

10832 sha256 = "0bl4bd6jzdc5zm20q1g67ppkfh6j6yn8fwj6msjayj621cck67p2";

10833 configureFlags = [

10834 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10835 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10836 "-fsplitbase" "-f-test-hlint"

10837 ];

10838 libraryHaskellDepends = [

10839 abstract-par base cereal deepseq mtl random transformers

10840 ];

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

10842 description = "Combinators and extra features for Par monads";

10843 license = stdenv.lib.licenses.bsd3;

10844 }) {};

10845 "monad-parallel" = callPackage

10846 ({ mkDerivation, base, parallel, transformers, transformers-compat

10847 }:

10848 mkDerivation {

10849 pname = "monad-parallel";

10850 version = "0.7.1.4";

10851 sha256 = "01sadhl3kv7gsx1m90fb76n2xh7b9awjc9071gzn0ab26d67a98b";

10852 configureFlags = [

10853 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10854 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10855 "-fsplitbase" "-f-test-hlint"

10856 ];

10857 libraryHaskellDepends = [

10858 base parallel transformers transformers-compat

10859 ];

10860 homepage = "http://trac.haskell.org/SCC/wiki/monad-parallel";

10861 description = "Parallel execution of monadic computations";

10862 license = stdenv.lib.licenses.bsd3;

10863 }) {};

10864 "monad-primitive" = callPackage

10865 ({ mkDerivation, base, primitive, transformers }:

10866 mkDerivation {

10867 pname = "monad-primitive";

10868 version = "0.1";

10869 sha256 = "1vi6g65hdyq5vq78mfag0qljxgzb6vq83m82x3cpgjl7dr9k5h1x";

10870 configureFlags = [

10871 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10872 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10873 "-fsplitbase" "-f-test-hlint"

10874 ];

10875 libraryHaskellDepends = [ base primitive transformers ];

10876 homepage = "http://bitbucket.org/Shimuuar/monad-primitive";

10877 description = "Type class for monad transformers stack with pirimitive base monad";

10878 license = stdenv.lib.licenses.bsd3;

10879 }) {};

10880 "monad-products" = callPackage

10881 ({ mkDerivation, base, semigroupoids }:

10882 mkDerivation {

10883 pname = "monad-products";

10884 version = "4.0.0.1";

10885 sha256 = "017cxiavxfw0f08sr0d6m3avla1lplmdj51rxpf1103ripq20r53";

10886 revision = "1";

10887 editedCabalFile = "03kif3rrx24a5xj83jk1rqz6pypsfyvrjb1558ziy26k1aphfkgv";

10888 configureFlags = [

10889 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10890 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10891 "-fsplitbase" "-f-test-hlint"

10892 ];

10893 libraryHaskellDepends = [ base semigroupoids ];

10894 homepage = "http://github.com/ekmett/monad-products";

10895 description = "Monad products";

10896 license = stdenv.lib.licenses.bsd3;

10897 }) {};

10898 "monad-st" = callPackage

10899 ({ mkDerivation, base, transformers }:

10900 mkDerivation {

10901 pname = "monad-st";

10902 version = "0.2.4";

10903 sha256 = "1j67s07p5lsr81cjl0ch5d1q7zarmpak5kmnwckhavihg3l5m3bi";

10904 configureFlags = [

10905 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10906 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10907 "-fsplitbase" "-f-test-hlint"

10908 ];

10909 libraryHaskellDepends = [ base transformers ];

10910 homepage = "http://github.com/ekmett/monad-st";

10911 description = "Provides a MonadST class";

10912 license = stdenv.lib.licenses.bsd3;

10913 }) {};

10914 "monadcryptorandom" = callPackage

10915 ({ mkDerivation, base, bytestring, crypto-api, mtl, tagged

10916 , transformers

10917 }:

10918 mkDerivation {

10919 pname = "monadcryptorandom";

10920 version = "0.6.1";

10921 sha256 = "0j99j0f2qwhslimfgslsdlv0xihsddas3i69pfnjwnsd9zg5pgj2";

10922 configureFlags = [

10923 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10924 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10925 "-fsplitbase" "-f-test-hlint"

10926 ];

10927 libraryHaskellDepends = [

10928 base bytestring crypto-api mtl tagged transformers

10929 ];

10930 homepage = "https://github.com/TomMD/monadcryptorandom";

10931 description = "A monad for using CryptoRandomGen";

10932 license = stdenv.lib.licenses.bsd3;

10933 }) {};

10934 "monadic-arrays" = callPackage

10935 ({ mkDerivation, array, base, stm, transformers }:

10936 mkDerivation {

10937 pname = "monadic-arrays";

10938 version = "0.2.1.4";

10939 sha256 = "1vlqh0mqfkg1f47dhl5lw49b7xawlbyjmq7xpmmf16q3idxnkahh";

10940 configureFlags = [

10941 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10942 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10943 "-fsplitbase" "-f-test-hlint"

10944 ];

10945 libraryHaskellDepends = [ array base stm transformers ];

10946 homepage = "http://github.com/ekmett/monadic-arrays/";

10947 description = "Boxed and unboxed arrays for monad transformers";

10948 license = stdenv.lib.licenses.bsd3;

10949 }) {};

10950 "monads-tf" = callPackage

10951 ({ mkDerivation, base, transformers }:

10952 mkDerivation {

10953 pname = "monads-tf";

10954 version = "0.1.0.2";

10955 sha256 = "0z07z2lfm3l93fx0qhfd98j76d1rksi5llq67l5v09pm8da4jvyb";

10956 configureFlags = [

10957 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10958 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10959 "-fsplitbase" "-f-test-hlint"

10960 ];

10961 libraryHaskellDepends = [ base transformers ];

10962 description = "Monad classes, using type families";

10963 license = stdenv.lib.licenses.bsd3;

10964 }) {};

10965 "mongoDB" = callPackage

10966 ({ mkDerivation, array, base, binary, bson, bytestring, containers

10967 , cryptohash, hashtables, lifted-base, monad-control, mtl, network

10968 , parsec, random, random-shuffle, text, transformers-base

10969 }:

10970 mkDerivation {

10971 pname = "mongoDB";

10972 version = "2.0.3";

10973 sha256 = "1blqd30mw9fl861f07zn7az4psl9byjjbd986884p6rx07m28abk";

10974 configureFlags = [

10975 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

10976 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

10977 "-fsplitbase" "-f-test-hlint"

10978 ];

10979 libraryHaskellDepends = [

10980 array base binary bson bytestring containers cryptohash hashtables

10981 lifted-base monad-control mtl network parsec random random-shuffle

10982 text transformers-base

10983 ];

10984 homepage = "https://github.com/mongodb-haskell/mongodb";

10985 description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";

10986 license = "unknown";

10987 }) {};

10988 "mono-traversable" = callPackage

10989 ({ mkDerivation, base, bytestring, comonad, containers, criterion

10990 , dlist, dlist-instances, foldl, hashable, hspec, mwc-random

10991 , QuickCheck, semigroupoids, semigroups, text, transformers

10992 , unordered-containers, vector, vector-algorithms, vector-instances

10993 }:

10994 mkDerivation {

10995 pname = "mono-traversable";

10996 version = "0.7.0";

10997 sha256 = "0154spqy8k060hqq2qdj5hyj5fyf6r0dcm7nmz3w4wlg2labc0i4";

10998 revision = "2";

10999 editedCabalFile = "0p02vlz19s9xrp597vknlqmhwsy008qdjhm0x8dh14f3sazx7v75";

11000 configureFlags = [

11001 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11002 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11003 "-fsplitbase" "-f-test-hlint"

11004 ];

11005 libraryHaskellDepends = [

11006 base bytestring comonad containers dlist dlist-instances hashable

11007 semigroupoids semigroups text transformers unordered-containers

11008 vector vector-algorithms vector-instances

11009 ];

11010 testHaskellDepends = [

11011 base bytestring containers foldl hspec QuickCheck semigroups text

11012 transformers unordered-containers vector

11013 ];

11014 benchmarkHaskellDepends = [ base criterion mwc-random vector ];

11015 homepage = "https://github.com/snoyberg/mono-traversable";

11016 description = "Type classes for mapping, folding, and traversing monomorphic containers";

11017 license = stdenv.lib.licenses.mit;

11018 }) {};

11019 "monoid-extras" = callPackage

11020 ({ mkDerivation, base, groups, semigroupoids, semigroups }:

11021 mkDerivation {

11022 pname = "monoid-extras";

11023 version = "0.3.3.5";

11024 sha256 = "07xll4pz0ijjxj75z0s0bz1lia2f65hsm61snlx0jv3aybrnw280";

11025 configureFlags = [

11026 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11027 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11028 "-fsplitbase" "-f-test-hlint"

11029 ];

11030 libraryHaskellDepends = [ base groups semigroupoids semigroups ];

11031 description = "Various extra monoid-related definitions and utilities";

11032 license = stdenv.lib.licenses.bsd3;

11033 }) {};

11034 "monoid-subclasses" = callPackage

11035 ({ mkDerivation, base, bytestring, containers, primes, QuickCheck

11036 , quickcheck-instances, test-framework, test-framework-quickcheck2

11037 , text, vector

11038 }:

11039 mkDerivation {

11040 pname = "monoid-subclasses";

11041 version = "0.3.6.2";

11042 sha256 = "1v9mahl8w0q8ink7qx0flfm2aplqidkgxx5fm091b69g612qlz0j";

11043 revision = "1";

11044 editedCabalFile = "0cxd2x2l19yznxcpwwagy5s144jqffz777v1jlpd1gbjqi48lcs2";

11045 configureFlags = [

11046 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11047 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11048 "-fsplitbase" "-f-test-hlint"

11049 ];

11050 libraryHaskellDepends = [

11051 base bytestring containers primes text vector

11052 ];

11053 testHaskellDepends = [

11054 base bytestring containers primes QuickCheck quickcheck-instances

11055 test-framework test-framework-quickcheck2 text vector

11056 ];

11057 homepage = "https://github.com/blamario/monoid-subclasses/";

11058 description = "Subclasses of Monoid";

11059 license = stdenv.lib.licenses.bsd3;

11060 }) {};

11061 "mtl" = callPackage

11062 ({ mkDerivation, base, transformers }:

11063 mkDerivation {

11064 pname = "mtl";

11065 version = "2.1.3.1";

11066 sha256 = "1xpn2wjmqbh2cg1yssc6749xpgcqlrrg4iilwqgkcjgvaxlpdbvp";

11067 configureFlags = [

11068 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11069 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11070 "-fsplitbase" "-f-test-hlint"

11071 ];

11072 libraryHaskellDepends = [ base transformers ];

11073 homepage = "http://github.com/ekmett/mtl";

11074 description = "Monad classes, using functional dependencies";

11075 license = stdenv.lib.licenses.bsd3;

11076 }) {};

11077 "mtl-prelude" = callPackage

11078 ({ mkDerivation, base, mtl, transformers }:

11079 mkDerivation {

11080 pname = "mtl-prelude";

11081 version = "1.0.3";

11082 sha256 = "1qr0bwcg9rlj53gbnji969s86qh8laaiibkfy2msziqnp011108x";

11083 configureFlags = [

11084 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11085 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11086 "-fsplitbase" "-f-test-hlint"

11087 ];

11088 libraryHaskellDepends = [ base mtl transformers ];

11089 doCheck = false;

11090 homepage = "https://github.com/nikita-volkov/mtl-prelude";

11091 description = "Reexports of most definitions from \"mtl\" and \"transformers\"";

11092 license = stdenv.lib.licenses.mit;

11093 }) {};

11094 "mtlparse" = callPackage

11095 ({ mkDerivation, base, mtl }:

11096 mkDerivation {

11097 pname = "mtlparse";

11098 version = "0.1.4.0";

11099 sha256 = "1fl5rvmgk37bqgjzs3c2wh80pfhr0i4yakxbsaryg7piws7j6ygc";

11100 configureFlags = [

11101 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11102 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11103 "-fsplitbase" "-f-test-hlint"

11104 ];

11105 libraryHaskellDepends = [ base mtl ];

11106 homepage = "http://homepage3.nifty.com/salamander/second/projects/mtlparse/";

11107 description = "parse library using mtl package";

11108 license = "LGPL";

11109 }) {};

11110 "multimap" = callPackage

11111 ({ mkDerivation, base, containers }:

11112 mkDerivation {

11113 pname = "multimap";

11114 version = "1.2.1";

11115 sha256 = "0d3l5q4yvmywl6i9ip96zz0fvhjdh00mfbbniphbjxsi8wlwack3";

11116 configureFlags = [

11117 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11118 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11119 "-fsplitbase" "-f-test-hlint"

11120 ];

11121 libraryHaskellDepends = [ base containers ];

11122 homepage = "http://hub.darcs.net/scravy/multimap";

11123 description = "A multimap";

11124 license = stdenv.lib.licenses.mit;

11125 }) {};

11126 "multipart" = callPackage

11127 ({ mkDerivation, base, bytestring, parsec }:

11128 mkDerivation {

11129 pname = "multipart";

11130 version = "0.1.2";

11131 sha256 = "0g04jhyw1ib1s7c9bcldyyn4n90qd9x7dmvic4vgq57bgcqgnhz5";

11132 configureFlags = [

11133 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11134 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11135 "-fsplitbase" "-f-test-hlint"

11136 ];

11137 libraryHaskellDepends = [ base bytestring parsec ];

11138 homepage = "http://www.github.com/silkapp/multipart";

11139 description = "HTTP multipart split out of the cgi package";

11140 license = stdenv.lib.licenses.bsd3;

11141 }) {};

11142 "mutable-containers" = callPackage

11143 ({ mkDerivation, base, containers, criterion, ghc-prim, hspec

11144 , mono-traversable, primitive, QuickCheck, vector

11145 }:

11146 mkDerivation {

11147 pname = "mutable-containers";

11148 version = "0.2.1.2";

11149 sha256 = "1j1dzx8iniq3arpjrndkpvkjad175hl4ijjryaf3s59pzpbz17y8";

11150 revision = "1";

11151 editedCabalFile = "1n9hkz3sqjbly76wc4mb2h5k77rmpxqpim0s3z07p45v2i3gqfdw";

11152 libraryHaskellDepends = [

11153 base containers ghc-prim mono-traversable primitive vector

11154 ];

11155 testHaskellDepends = [

11156 base containers hspec primitive QuickCheck vector

11157 ];

11158 benchmarkHaskellDepends = [ base containers criterion ];

11159 homepage = "https://github.com/fpco/mutable-containers";

11160 description = "Abstactions and concrete implementations of mutable containers";

11161 license = stdenv.lib.licenses.mit;

11162 }) {};

11163 "mwc-random" = callPackage

11164 ({ mkDerivation, base, HUnit, primitive, QuickCheck, statistics

11165 , test-framework, test-framework-hunit, test-framework-quickcheck2

11166 , time, vector

11167 }:

11168 mkDerivation {

11169 pname = "mwc-random";

11170 version = "0.13.3.0";

11171 sha256 = "0navzgw1y1zm3n4zs7x0lk2nmnjysk5cpw0clpl0w7iwb75yrnjd";

11172 revision = "1";

11173 editedCabalFile = "178w67d4d3mb015bhsfds73r4wk2q8bhjv36nhx4rvyzf24kck0y";

11174 configureFlags = [

11175 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11176 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11177 "-fsplitbase" "-f-test-hlint"

11178 ];

11179 libraryHaskellDepends = [ base primitive time vector ];

11180 testHaskellDepends = [

11181 base HUnit QuickCheck statistics test-framework

11182 test-framework-hunit test-framework-quickcheck2 vector

11183 ];

11184 homepage = "https://github.com/bos/mwc-random";

11185 description = "Fast, high quality pseudo random number generation";

11186 license = stdenv.lib.licenses.bsd3;

11187 }) {};

11188 "mysql" = callPackage

11189 ({ mkDerivation, base, bytestring, containers, mysql }:

11190 mkDerivation {

11191 pname = "mysql";

11192 version = "0.1.1.8";

11193 sha256 = "115xz4khg4klrgjvv9dy83pv197b4y1zgw6fbpv8j88yr3qjmw4h";

11194 revision = "1";

11195 editedCabalFile = "02znpf0s1sjyxd3kyw52nd3702mdl907i9vnb4dbsrfsx5hz3c10";

11196 configureFlags = [

11197 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11198 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11199 "-fsplitbase" "-f-test-hlint"

11200 ];

11201 libraryHaskellDepends = [ base bytestring containers ];

11202 librarySystemDepends = [ mysql ];

11203 homepage = "https://github.com/paul-rouse/mysql";

11204 description = "A low-level MySQL client library";

11205 license = stdenv.lib.licenses.bsd3;

11206 }) {inherit (pkgs) mysql;};

11207 "mysql-simple" = callPackage

11208 ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder

11209 , blaze-textual, bytestring, mysql, old-locale, pcre-light, text

11210 , time

11211 }:

11212 mkDerivation {

11213 pname = "mysql-simple";

11214 version = "0.2.2.5";

11215 sha256 = "132igmgrgkpc0g9063d593ha3iv40k5dd017nlb07sz0qs9hi8w6";

11216 revision = "2";

11217 editedCabalFile = "1x0bfmf9czb3av9m16b1n024ic9j496g67hmbja7y8piah6fq3q0";

11218 configureFlags = [

11219 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11220 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11221 "-fsplitbase" "-f-test-hlint"

11222 ];

11223 libraryHaskellDepends = [

11224 attoparsec base base16-bytestring blaze-builder blaze-textual

11225 bytestring mysql old-locale pcre-light text time

11226 ];

11227 homepage = "https://github.com/paul-rouse/mysql-simple";

11228 description = "A mid-level MySQL client library";

11229 license = stdenv.lib.licenses.bsd3;

11230 }) {};

11231 "nanospec" = callPackage

11232 ({ mkDerivation, base, hspec, silently }:

11233 mkDerivation {

11234 pname = "nanospec";

11235 version = "0.2.0";

11236 sha256 = "0g10l86cv33r58zxn2bprqlm80i7g86bwzhn9jqg9s81xc0aw2qv";

11237 configureFlags = [

11238 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11239 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11240 "-fsplitbase" "-f-test-hlint"

11241 ];

11242 libraryHaskellDepends = [ base ];

11243 testHaskellDepends = [ base hspec silently ];

11244 description = "A lightweight implementation of a subset of Hspec's API";

11245 license = stdenv.lib.licenses.mit;

11246 }) {};

11247 "nats" = callPackage

11248 ({ mkDerivation, base, hashable }:

11249 mkDerivation {

11250 pname = "nats";

11251 version = "1";

11252 sha256 = "0r6s8l4s0yq3x2crrkv0b8zac13magfasr9v8hnq6rn1icsfhic0";

11253 revision = "1";

11254 editedCabalFile = "0wjbskzx423pq0lv1j66913xgrp7s1i9bn7b60qvcvi9g7l96bpa";

11255 configureFlags = [

11256 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11257 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11258 "-fsplitbase" "-f-test-hlint"

11259 ];

11260 libraryHaskellDepends = [ base hashable ];

11261 homepage = "http://github.com/ekmett/nats/";

11262 description = "Natural numbers";

11263 license = stdenv.lib.licenses.bsd3;

11264 }) {};

11265 "neat-interpolation" = callPackage

11266 ({ mkDerivation, base, base-prelude, parsec, template-haskell }:

11267 mkDerivation {

11268 pname = "neat-interpolation";

11269 version = "0.2.2";

11270 sha256 = "0hjv33gpikfiwfhzna35bxiqh62d54776d3ahfb98dxfrjijl20c";

11271 configureFlags = [

11272 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11273 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11274 "-fsplitbase" "-f-test-hlint"

11275 ];

11276 libraryHaskellDepends = [

11277 base base-prelude parsec template-haskell

11278 ];

11279 doCheck = false;

11280 homepage = "https://github.com/nikita-volkov/neat-interpolation";

11281 description = "A quasiquoter for neat and simple multiline text interpolation";

11282 license = stdenv.lib.licenses.mit;

11283 }) {};

11284 "nettle" = callPackage

11285 ({ mkDerivation, array, base, byteable, bytestring

11286 , crypto-cipher-tests, crypto-cipher-types, HUnit, nettle

11287 , QuickCheck, securemem, tagged, test-framework

11288 , test-framework-hunit, test-framework-quickcheck2

11289 }:

11290 mkDerivation {

11291 pname = "nettle";

11292 version = "0.1.0";

11293 sha256 = "1ms96laa9d2ns39ymw6mlwm0mj03vss7855cs9npymhb4fmqkcas";

11294 configureFlags = [

11295 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11296 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11297 "-fsplitbase" "-f-test-hlint"

11298 ];

11299 libraryHaskellDepends = [

11300 base byteable bytestring crypto-cipher-types securemem tagged

11301 ];

11302 libraryPkgconfigDepends = [ nettle ];

11303 testHaskellDepends = [

11304 array base bytestring crypto-cipher-tests crypto-cipher-types HUnit

11305 QuickCheck tagged test-framework test-framework-hunit

11306 test-framework-quickcheck2

11307 ];

11308 doCheck = false;

11309 homepage = "https://github.com/stbuehler/haskell-nettle";

11310 description = "safe nettle binding";

11311 license = stdenv.lib.licenses.mit;

11312 }) {inherit (pkgs) nettle;};

11313 "network" = callPackage

11314 ({ mkDerivation, base, bytestring, HUnit, test-framework

11315 , test-framework-hunit, unix

11316 }:

11317 mkDerivation {

11318 pname = "network";

11319 version = "2.6.0.2";

11320 sha256 = "12b7saam5ga6l4cplgkad49xa4vkynz2ri9jxidx1cxiqjcl0vc4";

11321 configureFlags = [

11322 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11323 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11324 "-fsplitbase" "-f-test-hlint"

11325 ];

11326 libraryHaskellDepends = [ base bytestring unix ];

11327 testHaskellDepends = [

11328 base bytestring HUnit test-framework test-framework-hunit

11329 ];

11330 doCheck = false;

11331 homepage = "https://github.com/haskell/network";

11332 description = "Low-level networking interface";

11333 license = stdenv.lib.licenses.bsd3;

11334 }) {};

11335 "network-conduit-tls" = callPackage

11336 ({ mkDerivation, base, bytestring, conduit, conduit-extra

11337 , connection, cprng-aes, data-default, HUnit, monad-control, mtl

11338 , network, streaming-commons, system-fileio, system-filepath, tls

11339 , transformers

11340 }:

11341 mkDerivation {

11342 pname = "network-conduit-tls";

11343 version = "1.1.1";

11344 sha256 = "0wq074k6nwn3h1ww1an7n6i9zx6ii9hsm9vw6x51w22mp787dj1p";

11345 revision = "1";

11346 editedCabalFile = "10s8zhnzfbbk0bacd2x3r5chf4cmrxnismgzba93axqahhi53vwf";

11347 configureFlags = [

11348 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11349 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11350 "-fsplitbase" "-f-test-hlint"

11351 ];

11352 libraryHaskellDepends = [

11353 base bytestring conduit conduit-extra connection cprng-aes

11354 data-default monad-control network streaming-commons system-fileio

11355 system-filepath tls transformers

11356 ];

11357 testHaskellDepends = [

11358 base bytestring conduit conduit-extra connection HUnit mtl

11359 ];

11360 homepage = "https://github.com/snoyberg/conduit";

11361 description = "Create TLS-aware network code with conduits";

11362 license = stdenv.lib.licenses.mit;

11363 }) {};

11364 "network-info" = callPackage

11365 ({ mkDerivation, base }:

11366 mkDerivation {

11367 pname = "network-info";

11368 version = "0.2.0.5";

11369 sha256 = "0ggxnkjkbspynma0wjrc1wwwb9ygx2dhl0n9lfaq7l8r69z7pqwf";

11370 configureFlags = [

11371 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11372 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11373 "-fsplitbase" "-f-test-hlint"

11374 ];

11375 libraryHaskellDepends = [ base ];

11376 homepage = "http://github.com/jystic/network-info";

11377 description = "Access the local computer's basic network configuration";

11378 license = stdenv.lib.licenses.bsd3;

11379 }) {};

11380 "network-multicast" = callPackage

11381 ({ mkDerivation, base, network }:

11382 mkDerivation {

11383 pname = "network-multicast";

11384 version = "0.0.11";

11385 sha256 = "0fgscv9crk2lx99rh234ipgl5psbrjili95inxj23drvwmsj3135";

11386 configureFlags = [

11387 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11388 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11389 "-fsplitbase" "-f-test-hlint"

11390 ];

11391 libraryHaskellDepends = [ base network ];

11392 description = "Simple multicast library";

11393 license = stdenv.lib.licenses.publicDomain;

11394 }) {};

11395 "network-simple" = callPackage

11396 ({ mkDerivation, base, bytestring, exceptions, network

11397 , transformers

11398 }:

11399 mkDerivation {

11400 pname = "network-simple";

11401 version = "0.4.0.4";

11402 sha256 = "0qa3ax29ci7m01af0d2rvnx9m24q1d9zw727bzhc88k2g6k2xzah";

11403 configureFlags = [

11404 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11405 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11406 "-fsplitbase" "-f-test-hlint"

11407 ];

11408 libraryHaskellDepends = [

11409 base bytestring exceptions network transformers

11410 ];

11411 homepage = "https://github.com/k0001/network-simple";

11412 description = "Simple network sockets usage patterns";

11413 license = stdenv.lib.licenses.bsd3;

11414 }) {};

11415 "network-transport" = callPackage

11416 ({ mkDerivation, base, binary, bytestring, hashable, transformers

11417 }:

11418 mkDerivation {

11419 pname = "network-transport";

11420 version = "0.4.1.0";

11421 sha256 = "0xn879ngrbnm71i1wsbxxiih22sdb6csy6aip6fgqyafqlpc1c93";

11422 configureFlags = [

11423 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11424 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11425 "-fsplitbase" "-f-test-hlint"

11426 ];

11427 libraryHaskellDepends = [

11428 base binary bytestring hashable transformers

11429 ];

11430 homepage = "http://haskell-distributed.github.com";

11431 description = "Network abstraction layer";

11432 license = stdenv.lib.licenses.bsd3;

11433 }) {};

11434 "network-transport-tcp" = callPackage

11435 ({ mkDerivation, base, bytestring, containers, data-accessor

11436 , network, network-transport, network-transport-tests

11437 }:

11438 mkDerivation {

11439 pname = "network-transport-tcp";

11440 version = "0.4.1";

11441 sha256 = "11fj0f2yrvdqn3sivfb4p0chs74bx26a0yc49fh160kkcmk42yaf";

11442 configureFlags = [

11443 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11444 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11445 "-fsplitbase" "-f-test-hlint"

11446 ];

11447 libraryHaskellDepends = [

11448 base bytestring containers data-accessor network network-transport

11449 ];

11450 testHaskellDepends = [

11451 base network network-transport network-transport-tests

11452 ];

11453 doCheck = false;

11454 homepage = "http://haskell-distributed.github.com";

11455 description = "TCP instantiation of Network.Transport";

11456 license = stdenv.lib.licenses.bsd3;

11457 }) {};

11458 "network-transport-tests" = callPackage

11459 ({ mkDerivation, ansi-terminal, base, bytestring, containers, mtl

11460 , network-transport, random

11461 }:

11462 mkDerivation {

11463 pname = "network-transport-tests";

11464 version = "0.2.2.0";

11465 sha256 = "0914sj3884sp5sxbm460x5frvl0ipn8v1jpkskhc9ajjx4v0s106";

11466 configureFlags = [

11467 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11468 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11469 "-fsplitbase" "-f-test-hlint"

11470 ];

11471 libraryHaskellDepends = [

11472 ansi-terminal base bytestring containers mtl network-transport

11473 random

11474 ];

11475 homepage = "http://haskell-distributed.github.com";

11476 description = "Unit tests for Network.Transport implementations";

11477 license = stdenv.lib.licenses.bsd3;

11478 }) {};

11479 "network-uri" = callPackage

11480 ({ mkDerivation, base, HUnit, network, parsec, test-framework

11481 , test-framework-hunit, test-framework-quickcheck2

11482 }:

11483 mkDerivation {

11484 pname = "network-uri";

11485 version = "2.6.0.1";

11486 sha256 = "09ymamb128jgqghpda4nixncr73all8qc6q53976aricm6a27p37";

11487 configureFlags = [

11488 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11489 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11490 "-fsplitbase" "-f-test-hlint"

11491 ];

11492 libraryHaskellDepends = [ base parsec ];

11493 testHaskellDepends = [

11494 base HUnit network test-framework test-framework-hunit

11495 test-framework-quickcheck2

11496 ];

11497 doCheck = false;

11498 homepage = "https://github.com/haskell/network-uri";

11499 description = "URI manipulation";

11500 license = stdenv.lib.licenses.bsd3;

11501 }) {};

11502 "newtype" = callPackage

11503 ({ mkDerivation, base }:

11504 mkDerivation {

11505 pname = "newtype";

11506 version = "0.2";

11507 sha256 = "0ng4i5r73256gzwl6bw57h0abqixj783c3ggph1hk2wsplx0655p";

11508 configureFlags = [

11509 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11510 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11511 "-fsplitbase" "-f-test-hlint"

11512 ];

11513 libraryHaskellDepends = [ base ];

11514 description = "A typeclass and set of functions for working with newtypes";

11515 license = stdenv.lib.licenses.bsd3;

11516 }) {};

11517 "nsis" = callPackage

11518 ({ mkDerivation, base, directory, process, transformers, uniplate

11519 }:

11520 mkDerivation {

11521 pname = "nsis";

11522 version = "0.2.5";

11523 sha256 = "1lbd1yx2yr96mv58jk3d9qpxpvc9nqkgvi62z4jahwv6wz5wap61";

11524 configureFlags = [

11525 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11526 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11527 "-fsplitbase" "-f-test-hlint"

11528 ];

11529 libraryHaskellDepends = [ base transformers uniplate ];

11530 testHaskellDepends = [

11531 base directory process transformers uniplate

11532 ];

11533 doCheck = false;

11534 homepage = "https://github.com/ndmitchell/nsis#readme";

11535 description = "DSL for producing Windows Installer using NSIS";

11536 license = stdenv.lib.licenses.bsd3;

11537 }) {};

11538 "numbers" = callPackage

11539 ({ mkDerivation, base, QuickCheck, test-framework

11540 , test-framework-quickcheck2

11541 }:

11542 mkDerivation {

11543 pname = "numbers";

11544 version = "3000.2.0.1";

11545 sha256 = "10z1bi5qbc81z5xx2v1ylwcpmcfl1ci7lxrswkgi0dd1wi8havbk";

11546 configureFlags = [

11547 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11548 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11549 "-fsplitbase" "-f-test-hlint"

11550 ];

11551 libraryHaskellDepends = [ base ];

11552 testHaskellDepends = [

11553 base QuickCheck test-framework test-framework-quickcheck2

11554 ];

11555 homepage = "https://github.com/jwiegley/numbers#readme";

11556 description = "Various number types";

11557 license = stdenv.lib.licenses.bsd3;

11558 }) {};

11559 "numeric-extras" = callPackage

11560 ({ mkDerivation, base }:

11561 mkDerivation {

11562 pname = "numeric-extras";

11563 version = "0.0.3";

11564 sha256 = "18jyjrk6iizz3sgkwgbh1rxf6zdf166bkgs7wia8b4z7f6261nzg";

11565 configureFlags = [

11566 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11567 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11568 "-fsplitbase" "-f-test-hlint"

11569 ];

11570 libraryHaskellDepends = [ base ];

11571 homepage = "http://github.com/ekmett/numeric-extras";

11572 description = "Useful tools from the C standard library";

11573 license = stdenv.lib.licenses.bsd3;

11574 }) {};

11575 "numtype" = callPackage

11576 ({ mkDerivation, base }:

11577 mkDerivation {

11578 pname = "numtype";

11579 version = "1.1";

11580 sha256 = "1az10xcfl6qpyy9qnh8g2iqx53rxnjxzc1h8kl1gira6yv7g6857";

11581 configureFlags = [

11582 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11583 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11584 "-fsplitbase" "-f-test-hlint"

11585 ];

11586 libraryHaskellDepends = [ base ];

11587 homepage = "http://dimensional.googlecode.com/";

11588 description = "Type-level (low cardinality) integers";

11589 license = stdenv.lib.licenses.bsd3;

11590 }) {};

11591 "opaleye" = callPackage

11592 ({ mkDerivation, attoparsec, base, base16-bytestring, bytestring

11593 , case-insensitive, contravariant, postgresql-simple, pretty

11594 , product-profunctors, profunctors, semigroups, text, time

11595 , time-locale-compat, transformers, uuid

11596 }:

11597 mkDerivation {

11598 pname = "opaleye";

11599 version = "0.3.1.2";

11600 sha256 = "01ldghza5l1qgcpvsphajfkq7g09fw0dm4vnya9wbs0hla307av9";

11601 revision = "3";

11602 editedCabalFile = "0ljqc3q84111zmbqgfjmi23d4wrkph9laj57rh0zw9mwp0ck5s4y";

11603 configureFlags = [

11604 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11605 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11606 "-fsplitbase" "-f-test-hlint"

11607 ];

11608 libraryHaskellDepends = [

11609 attoparsec base base16-bytestring bytestring case-insensitive

11610 contravariant postgresql-simple pretty product-profunctors

11611 profunctors semigroups text time time-locale-compat transformers

11612 uuid

11613 ];

11614 testHaskellDepends = [

11615 base postgresql-simple product-profunctors profunctors time

11616 ];

11617 doCheck = false;

11618 homepage = "https://github.com/tomjaguarpaw/haskell-opaleye";

11619 description = "An SQL-generating DSL targeting PostgreSQL";

11620 license = stdenv.lib.licenses.bsd3;

11621 }) {};

11622 "openpgp-asciiarmor" = callPackage

11623 ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring

11624 , cereal, HUnit, test-framework, test-framework-hunit

11625 }:

11626 mkDerivation {

11627 pname = "openpgp-asciiarmor";

11628 version = "0.1";

11629 sha256 = "1xrv0n7n1n8izvxvqm8wmj6mkn5l6wcq18bxs9zd1q5riynmmm2w";

11630 configureFlags = [

11631 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11632 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11633 "-fsplitbase" "-f-test-hlint"

11634 ];

11635 libraryHaskellDepends = [

11636 attoparsec base base64-bytestring bytestring cereal

11637 ];

11638 testHaskellDepends = [

11639 attoparsec base base64-bytestring bytestring cereal HUnit

11640 test-framework test-framework-hunit

11641 ];

11642 homepage = "http://floss.scru.org/openpgp-asciiarmor";

11643 description = "OpenPGP (RFC4880) ASCII Armor codec";

11644 license = "unknown";

11645 }) {};

11646 "operational" = callPackage

11647 ({ mkDerivation, base, mtl, random }:

11648 mkDerivation {

11649 pname = "operational";

11650 version = "0.2.3.2";

11651 sha256 = "1aj3jhiyz4190b0qmyp684b8lbzrp8jn56s898892rvbp0hxa0pd";

11652 configureFlags = [

11653 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11654 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11655 "-fsplitbase" "-f-test-hlint"

11656 ];

11657 isLibrary = true;

11658 isExecutable = true;

11659 libraryHaskellDepends = [ base mtl ];

11660 executableHaskellDepends = [ random ];

11661 homepage = "http://haskell.org/haskellwiki/Operational";

11662 description = "Implementation of difficult monads made easy with operational semantics";

11663 license = stdenv.lib.licenses.bsd3;

11664 }) {};

11665 "options" = callPackage

11666 ({ mkDerivation, base, containers, monads-tf, transformers }:

11667 mkDerivation {

11668 pname = "options";

11669 version = "1.2.1.1";

11670 sha256 = "0qjs0v1ny52w51n5582d4z8wy9h6n0zw1xb5dh686ff5wadflgi8";

11671 configureFlags = [

11672 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11673 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11674 "-fsplitbase" "-f-test-hlint"

11675 ];

11676 libraryHaskellDepends = [ base containers monads-tf transformers ];

11677 doCheck = false;

11678 homepage = "https://john-millikin.com/software/haskell-options/";

11679 description = "A powerful and easy-to-use command-line option parser";

11680 license = stdenv.lib.licenses.mit;

11681 }) {};

11682 "optparse-applicative" = callPackage

11683 ({ mkDerivation, ansi-wl-pprint, base, process, transformers

11684 , transformers-compat

11685 }:

11686 mkDerivation {

11687 pname = "optparse-applicative";

11688 version = "0.11.0.2";

11689 sha256 = "0ni52ii9555jngljvzxn1ngicr6i2w647ww3rzhdrmng04y95iii";

11690 configureFlags = [

11691 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11692 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11693 "-fsplitbase" "-f-test-hlint"

11694 ];

11695 libraryHaskellDepends = [

11696 ansi-wl-pprint base process transformers transformers-compat

11697 ];

11698 homepage = "https://github.com/pcapriotti/optparse-applicative";

11699 description = "Utilities and combinators for parsing command line options";

11700 license = stdenv.lib.licenses.bsd3;

11701 }) {};

11702 "osdkeys" = callPackage

11703 ({ mkDerivation, base, bytestring, conduit, conduit-extra

11704 , containers, libnotify, process, resourcet, time, transformers

11705 }:

11706 mkDerivation {

11707 pname = "osdkeys";

11708 version = "0.0";

11709 sha256 = "18pc2r5acb3b6dr7niib4fn8x2la6y3f5zlj3ibrxhl5c1q35j6y";

11710 configureFlags = [

11711 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11712 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11713 "-fsplitbase" "-f-test-hlint"

11714 ];

11715 isLibrary = true;

11716 isExecutable = true;

11717 libraryHaskellDepends = [

11718 base bytestring conduit conduit-extra containers libnotify

11719 resourcet time transformers

11720 ];

11721 executableHaskellDepends = [ base process ];

11722 description = "Show keys pressed with an on-screen display (Linux only)";

11723 license = stdenv.lib.licenses.bsd3;

11724 }) {};

11725 "pandoc" = callPackage

11726 ({ mkDerivation, aeson, ansi-terminal, array, base

11727 , base64-bytestring, binary, blaze-html, blaze-markup, bytestring

11728 , containers, data-default, deepseq-generics, Diff, directory

11729 , executable-path, extensible-exceptions, filepath, haddock-library

11730 , highlighting-kate, hslua, HTTP, http-client, http-client-tls

11731 , http-types, HUnit, JuicyPixels, mtl, network, network-uri

11732 , old-locale, old-time, pandoc-types, parsec, process, QuickCheck

11733 , random, scientific, SHA, syb, tagsoup, temporary, test-framework

11734 , test-framework-hunit, test-framework-quickcheck2, texmath, text

11735 , time, unordered-containers, vector, xml, yaml, zip-archive, zlib

11736 }:

11737 mkDerivation {

11738 pname = "pandoc";

11739 version = "1.13.2";

11740 sha256 = "12kd71g70d1wzz19p5yq7f00hw8d4ra8ghn83g7yzsal8igl8p76";

11741 revision = "3";

11742 editedCabalFile = "11xzzzr0b8bmp0ysipizpv989mklwhxbgxf2a6xhpj1lmi950ci3";

11743 configureFlags = [

11744 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11745 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11746 "-fsplitbase" "-f-test-hlint"

11747 ];

11748 isLibrary = true;

11749 isExecutable = true;

11750 enableSeparateDataOutput = true;

11751 libraryHaskellDepends = [

11752 aeson array base base64-bytestring binary blaze-html blaze-markup

11753 bytestring containers data-default deepseq-generics directory

11754 extensible-exceptions filepath haddock-library highlighting-kate

11755 hslua HTTP http-client http-client-tls http-types JuicyPixels mtl

11756 network network-uri old-locale old-time pandoc-types parsec process

11757 random scientific SHA syb tagsoup temporary texmath text time

11758 unordered-containers vector xml yaml zip-archive zlib

11759 ];

11760 executableHaskellDepends = [

11761 aeson base bytestring containers directory extensible-exceptions

11762 filepath highlighting-kate HTTP network network-uri old-time

11763 pandoc-types text time yaml

11764 ];

11765 testHaskellDepends = [

11766 ansi-terminal base bytestring containers Diff directory

11767 executable-path filepath highlighting-kate HUnit pandoc-types

11768 process QuickCheck syb test-framework test-framework-hunit

11769 test-framework-quickcheck2 text zip-archive

11770 ];

11771 homepage = "http://johnmacfarlane.net/pandoc";

11772 description = "Conversion between markup formats";

11773 license = "GPL";

11774 }) {};

11775 "pandoc-citeproc" = callPackage

11776 ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring

11777 , containers, data-default, directory, filepath, hs-bibutils, mtl

11778 , old-locale, pandoc, pandoc-types, parsec, process, rfc5051, split

11779 , syb, tagsoup, temporary, text, time, vector, xml-conduit, yaml

11780 }:

11781 mkDerivation {

11782 pname = "pandoc-citeproc";

11783 version = "0.6";

11784 sha256 = "1whi8mrbhfi8wr3qbj1lkgc1pngn8151jjri409hshl1mng4aq5b";

11785 configureFlags = [

11786 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11787 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11788 "-fsplitbase" "-f-test-hlint"

11789 ];

11790 isLibrary = true;

11791 isExecutable = true;

11792 enableSeparateDataOutput = true;

11793 libraryHaskellDepends = [

11794 aeson base bytestring containers data-default directory filepath

11795 hs-bibutils mtl old-locale pandoc pandoc-types parsec rfc5051 split

11796 syb tagsoup text time vector xml-conduit yaml

11797 ];

11798 executableHaskellDepends = [

11799 aeson aeson-pretty attoparsec base bytestring containers directory

11800 filepath pandoc pandoc-types process syb temporary text vector yaml

11801 ];

11802 testHaskellDepends = [

11803 aeson base bytestring directory filepath pandoc pandoc-types

11804 process temporary text yaml

11805 ];

11806 description = "Supports using pandoc with citeproc";

11807 license = stdenv.lib.licenses.bsd3;

11808 }) {};

11809 "pandoc-types" = callPackage

11810 ({ mkDerivation, aeson, base, bytestring, containers

11811 , deepseq-generics, ghc-prim, syb

11812 }:

11813 mkDerivation {

11814 pname = "pandoc-types";

11815 version = "1.12.4.2";

11816 sha256 = "0j9zzlpwjyy8fqr91fsnzy507ylwrwk7hhl9nkxzk19iva2c42n9";

11817 configureFlags = [

11818 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11819 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11820 "-fsplitbase" "-f-test-hlint"

11821 ];

11822 libraryHaskellDepends = [

11823 aeson base bytestring containers deepseq-generics ghc-prim syb

11824 ];

11825 homepage = "http://johnmacfarlane.net/pandoc";

11826 description = "Types for representing a structured document";

11827 license = stdenv.lib.licenses.bsd3;

11828 }) {};

11829 "pango" = callPackage

11830 ({ mkDerivation, array, base, cairo, containers, directory, glib

11831 , gtk2hs-buildtools, mtl, pango, pretty, process, text

11832 }:

11833 mkDerivation {

11834 pname = "pango";

11835 version = "0.13.0.5";

11836 sha256 = "031yrfz6i4sc8jp2r1ar3mhz4cg8ih3kics2g7qvrxi1s3ai3d3x";

11837 configureFlags = [

11838 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11839 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11840 "-fsplitbase" "-f-test-hlint"

11841 ];

11842 enableSeparateDataOutput = true;

11843 libraryHaskellDepends = [

11844 array base cairo containers directory glib mtl pretty process text

11845 ];

11846 libraryPkgconfigDepends = [ pango ];

11847 libraryToolDepends = [ gtk2hs-buildtools ];

11848 homepage = "http://projects.haskell.org/gtk2hs/";

11849 description = "Binding to the Pango text rendering engine";

11850 license = stdenv.lib.licenses.lgpl21;

11851 }) {inherit (pkgs.gnome2) pango;};

11852 "parallel" = callPackage

11853 ({ mkDerivation, array, base, containers, deepseq }:

11854 mkDerivation {

11855 pname = "parallel";

11856 version = "3.2.0.6";

11857 sha256 = "0hp6vf4zxsw6vz6lj505xihmnfhgjp39c9q7nyzlgcmps3xx6a5r";

11858 revision = "1";

11859 editedCabalFile = "0nhnixsi85nl0m5swgk3mk56jmnif0b088rl172py2ggsrc08w4s";

11860 configureFlags = [

11861 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11862 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11863 "-fsplitbase" "-f-test-hlint"

11864 ];

11865 libraryHaskellDepends = [ array base containers deepseq ];

11866 description = "Parallel programming library";

11867 license = stdenv.lib.licenses.bsd3;

11868 }) {};

11869 "parallel-io" = callPackage

11870 ({ mkDerivation, base, containers, extensible-exceptions, random }:

11871 mkDerivation {

11872 pname = "parallel-io";

11873 version = "0.3.3";

11874 sha256 = "0i86x3bf8pjlg6mdg1zg5lcrjpg75pbqs2mrgrbp4z4bkcmw051s";

11875 revision = "1";

11876 editedCabalFile = "1vlb2x1ghih4l64031rmh7h643c3knh5r5mwilf7g8izb58ypvkm";

11877 configureFlags = [

11878 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11879 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11880 "-fsplitbase" "-f-test-hlint"

11881 ];

11882 isLibrary = true;

11883 isExecutable = true;

11884 libraryHaskellDepends = [

11885 base containers extensible-exceptions random

11886 ];

11887 homepage = "http://batterseapower.github.com/parallel-io";

11888 description = "Combinators for executing IO actions in parallel on a thread pool";

11889 license = stdenv.lib.licenses.bsd3;

11890 }) {};

11891 "parseargs" = callPackage

11892 ({ mkDerivation, base, containers }:

11893 mkDerivation {

11894 pname = "parseargs";

11895 version = "0.1.5.2";

11896 sha256 = "0pzw7w1kr2rv6ffqgn93rypn37wy2r5k01p3y5256laaplm575am";

11897 configureFlags = [

11898 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11899 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11900 "-fsplitbase" "-f-test-hlint"

11901 ];

11902 isLibrary = true;

11903 isExecutable = true;

11904 libraryHaskellDepends = [ base containers ];

11905 executableHaskellDepends = [ base ];

11906 homepage = "http://github.com/BartMassey/parseargs";

11907 description = "Command-line argument parsing library for Haskell programs";

11908 license = stdenv.lib.licenses.bsd3;

11909 }) {};

11910 "parsec" = callPackage

11911 ({ mkDerivation, base, bytestring, HUnit, mtl, test-framework

11912 , test-framework-hunit, text

11913 }:

11914 mkDerivation {

11915 pname = "parsec";

11916 version = "3.1.8";

11917 sha256 = "01vqk7krbhy6bf30ydjdjvbzx5ynjdbc3dwlhzinzq6a69a6brlq";

11918 configureFlags = [

11919 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11920 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11921 "-fsplitbase" "-f-test-hlint"

11922 ];

11923 libraryHaskellDepends = [ base bytestring mtl text ];

11924 testHaskellDepends = [

11925 base HUnit test-framework test-framework-hunit

11926 ];

11927 homepage = "http://www.cs.uu.nl/~daan/parsec.html";

11928 description = "Monadic parser combinators";

11929 license = stdenv.lib.licenses.bsd3;

11930 }) {};

11931 "parsers" = callPackage

11932 ({ mkDerivation, attoparsec, base, bytestring, charset, containers

11933 , directory, doctest, filepath, parsec, QuickCheck

11934 , quickcheck-instances, text, transformers, unordered-containers

11935 }:

11936 mkDerivation {

11937 pname = "parsers";

11938 version = "0.12.1.1";

11939 sha256 = "1yx75xbmg3lms0hj79r5w9fl81g5cbsm842lijhd9jnnbli2mzfw";

11940 configureFlags = [

11941 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11942 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11943 "-fsplitbase" "-f-test-hlint"

11944 ];

11945 libraryHaskellDepends = [

11946 attoparsec base charset containers parsec text transformers

11947 unordered-containers

11948 ];

11949 testHaskellDepends = [

11950 attoparsec base bytestring containers directory doctest filepath

11951 parsec QuickCheck quickcheck-instances

11952 ];

11953 homepage = "http://github.com/ekmett/parsers/";

11954 description = "Parsing combinators";

11955 license = stdenv.lib.licenses.bsd3;

11956 }) {};

11957 "partial-handler" = callPackage

11958 ({ mkDerivation, base }:

11959 mkDerivation {

11960 pname = "partial-handler";

11961 version = "0.1.0";

11962 sha256 = "07dhsm2r89iviz481r9wxw0scq40dgfzw0mi6klky78xn8r9x4ds";

11963 revision = "1";

11964 editedCabalFile = "121jkr036ilsiamjg1pszd48q2v2nf5s9gz96p69nxqd37sbgp1h";

11965 configureFlags = [

11966 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11967 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11968 "-fsplitbase" "-f-test-hlint"

11969 ];

11970 libraryHaskellDepends = [ base ];

11971 doCheck = false;

11972 homepage = "https://github.com/nikita-volkov/partial-handler";

11973 description = "A composable exception handler";

11974 license = stdenv.lib.licenses.mit;

11975 }) {};

11976 "path-pieces" = callPackage

11977 ({ mkDerivation, base, hspec, HUnit, QuickCheck, text, time }:

11978 mkDerivation {

11979 pname = "path-pieces";

11980 version = "0.1.5";

11981 sha256 = "05rya4gvpmm3pa4qp6cvvh4552qsrsgi61i1cx0aj8slakqrk8xw";

11982 configureFlags = [

11983 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

11984 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

11985 "-fsplitbase" "-f-test-hlint"

11986 ];

11987 libraryHaskellDepends = [ base text time ];

11988 testHaskellDepends = [ base hspec HUnit QuickCheck text ];

11989 description = "Components of paths";

11990 license = stdenv.lib.licenses.bsd3;

11991 }) {};

11992 "patience" = callPackage

11993 ({ mkDerivation, base, containers }:

11994 mkDerivation {

11995 pname = "patience";

11996 version = "0.1.1";

11997 sha256 = "0qyv20gqy9pb1acy700ahv70lc6vprcwb26cc7fcpcs4scsc7irm";

11998 configureFlags = [

11999 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12000 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12001 "-fsplitbase" "-f-test-hlint"

12002 ];

12003 libraryHaskellDepends = [ base containers ];

12004 description = "Patience diff and longest increasing subsequence";

12005 license = stdenv.lib.licenses.bsd3;

12006 }) {};

12007 "pcre-light" = callPackage

12008 ({ mkDerivation, base, bytestring, pcre }:

12009 mkDerivation {

12010 pname = "pcre-light";

12011 version = "0.4.0.3";

12012 sha256 = "0l1df2sk5qwf424bvb8mbdkr2xjg43fi92n5r22yd7vm1zz0jqvf";

12013 configureFlags = [

12014 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12015 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12016 "-fsplitbase" "-f-test-hlint"

12017 ];

12018 libraryHaskellDepends = [ base bytestring ];

12019 librarySystemDepends = [ pcre ];

12020 homepage = "https://github.com/Daniel-Diaz/pcre-light";

12021 description = "A small, efficient and portable regex library for Perl 5 compatible regular expressions";

12022 license = stdenv.lib.licenses.bsd3;

12023 }) {inherit (pkgs) pcre;};

12024 "pdfinfo" = callPackage

12025 ({ mkDerivation, base, mtl, old-locale, process-extras, text, time

12026 }:

12027 mkDerivation {

12028 pname = "pdfinfo";

12029 version = "1.5.2";

12030 sha256 = "1s2hhmcqsg57fppqjvrkp77bms1npblysjvfl37fgn0jafn0mhjq";

12031 configureFlags = [

12032 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12033 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12034 "-fsplitbase" "-f-test-hlint"

12035 ];

12036 libraryHaskellDepends = [

12037 base mtl old-locale process-extras text time

12038 ];

12039 homepage = "https://github.com/chrisdone/pdfinfo";

12040 description = "Wrapper around the pdfinfo command";

12041 license = stdenv.lib.licenses.bsd3;

12042 }) {};

12043 "pem" = callPackage

12044 ({ mkDerivation, base, base64-bytestring, bytestring, HUnit, mtl

12045 , QuickCheck, test-framework, test-framework-hunit

12046 , test-framework-quickcheck2

12047 }:

12048 mkDerivation {

12049 pname = "pem";

12050 version = "0.2.2";

12051 sha256 = "162sk5sg22w21wqz5qv8kx6ibxp99v5p20g3nknhm1kddk3hha1p";

12052 configureFlags = [

12053 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12054 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12055 "-fsplitbase" "-f-test-hlint"

12056 ];

12057 enableSeparateDataOutput = true;

12058 libraryHaskellDepends = [ base base64-bytestring bytestring mtl ];

12059 testHaskellDepends = [

12060 base bytestring HUnit QuickCheck test-framework

12061 test-framework-hunit test-framework-quickcheck2

12062 ];

12063 homepage = "http://github.com/vincenthz/hs-pem";

12064 description = "Privacy Enhanced Mail (PEM) format reader and writer";

12065 license = stdenv.lib.licenses.bsd3;

12066 }) {};

12067 "persistent" = callPackage

12068 ({ mkDerivation, aeson, attoparsec, base, base64-bytestring

12069 , blaze-html, blaze-markup, bytestring, conduit, containers

12070 , exceptions, fast-logger, hspec, lifted-base, monad-control

12071 , monad-logger, mtl, old-locale, path-pieces, resource-pool

12072 , resourcet, scientific, silently, tagged, template-haskell, text

12073 , time, transformers, transformers-base, unordered-containers

12074 , vector

12075 }:

12076 mkDerivation {

12077 pname = "persistent";

12078 version = "2.1.2";

12079 sha256 = "17p81s1w7wqs2hm5zcwncvidd808gm4zlha7mqv9wwpf6ql1b359";

12080 configureFlags = [

12081 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12082 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12083 "-fsplitbase" "-f-test-hlint"

12084 ];

12085 libraryHaskellDepends = [

12086 aeson attoparsec base base64-bytestring blaze-html blaze-markup

12087 bytestring conduit containers exceptions fast-logger lifted-base

12088 monad-control monad-logger mtl old-locale path-pieces resource-pool

12089 resourcet scientific silently tagged template-haskell text time

12090 transformers transformers-base unordered-containers vector

12091 ];

12092 testHaskellDepends = [

12093 aeson attoparsec base base64-bytestring blaze-html bytestring

12094 conduit containers hspec monad-control monad-logger old-locale

12095 path-pieces resourcet scientific text time transformers

12096 unordered-containers vector

12097 ];

12098 homepage = "http://www.yesodweb.com/book/persistent";

12099 description = "Type-safe, multi-backend data serialization";

12100 license = stdenv.lib.licenses.mit;

12101 }) {};

12102 "persistent-mongoDB" = callPackage

12103 ({ mkDerivation, aeson, attoparsec, base, bson, bytestring, cereal

12104 , conduit, containers, monad-control, mongoDB, network, path-pieces

12105 , persistent, resource-pool, resourcet, text, time, transformers

12106 }:

12107 mkDerivation {

12108 pname = "persistent-mongoDB";

12109 version = "2.1.2.1";

12110 sha256 = "130jd85h1fl5klfr369kg11w29aavl81d22w1is5dg38s0pzn76a";

12111 configureFlags = [

12112 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12113 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12114 "-fsplitbase" "-f-test-hlint"

12115 ];

12116 libraryHaskellDepends = [

12117 aeson attoparsec base bson bytestring cereal conduit containers

12118 monad-control mongoDB network path-pieces persistent resource-pool

12119 resourcet text time transformers

12120 ];

12121 homepage = "http://www.yesodweb.com/book/persistent";

12122 description = "Backend for the persistent library using mongoDB";

12123 license = stdenv.lib.licenses.mit;

12124 }) {};

12125 "persistent-mysql" = callPackage

12126 ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit

12127 , containers, monad-control, monad-logger, mysql, mysql-simple

12128 , persistent, resourcet, text, transformers

12129 }:

12130 mkDerivation {

12131 pname = "persistent-mysql";

12132 version = "2.1.3";

12133 sha256 = "1k1sjzxz96z6pgk4012v8p4w6scgm4g2j5fs4sjgsj9azp3b7gwh";

12134 configureFlags = [

12135 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12136 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12137 "-fsplitbase" "-f-test-hlint"

12138 ];

12139 libraryHaskellDepends = [

12140 aeson base blaze-builder bytestring conduit containers

12141 monad-control monad-logger mysql mysql-simple persistent resourcet

12142 text transformers

12143 ];

12144 homepage = "http://www.yesodweb.com/book/persistent";

12145 description = "Backend for the persistent library using MySQL database server";

12146 license = stdenv.lib.licenses.mit;

12147 }) {};

12148 "persistent-postgresql" = callPackage

12149 ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit

12150 , containers, monad-control, monad-logger, persistent

12151 , postgresql-libpq, postgresql-simple, resourcet, text, time

12152 , transformers

12153 }:

12154 mkDerivation {

12155 pname = "persistent-postgresql";

12156 version = "2.1.3";

12157 sha256 = "0hgvpfgbwb1q0zkl5g9hxdz1wh4xbl0hx26j5944qcll5f6298is";

12158 configureFlags = [

12159 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12160 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12161 "-fsplitbase" "-f-test-hlint"

12162 ];

12163 libraryHaskellDepends = [

12164 aeson base blaze-builder bytestring conduit containers

12165 monad-control monad-logger persistent postgresql-libpq

12166 postgresql-simple resourcet text time transformers

12167 ];

12168 homepage = "http://www.yesodweb.com/book/persistent";

12169 description = "Backend for the persistent library using postgresql";

12170 license = stdenv.lib.licenses.mit;

12171 }) {};

12172 "persistent-sqlite" = callPackage

12173 ({ mkDerivation, aeson, base, bytestring, conduit, containers

12174 , hspec, monad-control, monad-logger, old-locale, persistent

12175 , persistent-template, resourcet, sqlite, text, time, transformers

12176 }:

12177 mkDerivation {

12178 pname = "persistent-sqlite";

12179 version = "2.1.3";

12180 sha256 = "1vyfhiwahyfgv6xwbfyn42f19dijbmjshlyy6a5rf0bfllc2k7gf";

12181 configureFlags = [

12182 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12183 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12184 "-fsplitbase" "-fsystemlib" "-f-test-hlint"

12185 ];

12186 isLibrary = true;

12187 isExecutable = true;

12188 libraryHaskellDepends = [

12189 aeson base bytestring conduit containers monad-control monad-logger

12190 old-locale persistent resourcet text time transformers

12191 ];

12192 librarySystemDepends = [ sqlite ];

12193 executableHaskellDepends = [ base ];

12194 testHaskellDepends = [

12195 base hspec persistent persistent-template time transformers

12196 ];

12197 homepage = "http://www.yesodweb.com/book/persistent";

12198 description = "Backend for the persistent library using sqlite3";

12199 license = stdenv.lib.licenses.mit;

12200 }) {inherit (pkgs) sqlite;};

12201 "persistent-template" = callPackage

12202 ({ mkDerivation, aeson, base, bytestring, containers, ghc-prim

12203 , hspec, monad-control, monad-logger, path-pieces, persistent

12204 , QuickCheck, tagged, template-haskell, text, transformers

12205 , unordered-containers

12206 }:

12207 mkDerivation {

12208 pname = "persistent-template";

12209 version = "2.1.1";

12210 sha256 = "1bvmxpx8dqqsq87v079sw8wy795iykkz0fknrlpxhywja2j40dxc";

12211 revision = "1";

12212 editedCabalFile = "0g183cnhhhihxvcpngkxi3i081b5cial39px4xivwhxa6yr47z8r";

12213 configureFlags = [

12214 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12215 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12216 "-fsplitbase" "-f-test-hlint"

12217 ];

12218 libraryHaskellDepends = [

12219 aeson base bytestring containers ghc-prim monad-control

12220 monad-logger path-pieces persistent tagged template-haskell text

12221 transformers unordered-containers

12222 ];

12223 testHaskellDepends = [

12224 aeson base bytestring hspec persistent QuickCheck text transformers

12225 ];

12226 homepage = "http://www.yesodweb.com/book/persistent";

12227 description = "Type-safe, non-relational, multi-backend persistence";

12228 license = stdenv.lib.licenses.mit;

12229 }) {};

12230 "phantom-state" = callPackage

12231 ({ mkDerivation, base, criterion, transformers, vector }:

12232 mkDerivation {

12233 pname = "phantom-state";

12234 version = "0.2.0.2";

12235 sha256 = "04fg0j79nkajsiw8n2yy62mwiw1r4fjy2jln5ng07h64pwyncdnm";

12236 configureFlags = [

12237 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12238 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12239 "-fsplitbase" "-f-test-hlint"

12240 ];

12241 libraryHaskellDepends = [ base transformers ];

12242 benchmarkHaskellDepends = [ base criterion transformers vector ];

12243 description = "Phantom State Transformer. Like State Monad, but without values.";

12244 license = stdenv.lib.licenses.bsd3;

12245 }) {};

12246 "pipes" = callPackage

12247 ({ mkDerivation, base, criterion, deepseq, mmorph, mtl, QuickCheck

12248 , test-framework, test-framework-quickcheck2, transformers

12249 }:

12250 mkDerivation {

12251 pname = "pipes";

12252 version = "4.1.4";

12253 sha256 = "0bv7i18lf15mvfscnif4hkwgm4anw8b7bbqhzdw4wbjqcvrrsppb";

12254 revision = "1";

12255 editedCabalFile = "01c4ygz08srjcs3svg044hadj3rdi3vdyhgq8zaxdii8iy6yrhmq";

12256 configureFlags = [

12257 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12258 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12259 "-fsplitbase" "-f-test-hlint"

12260 ];

12261 libraryHaskellDepends = [ base mmorph mtl transformers ];

12262 testHaskellDepends = [

12263 base mtl QuickCheck test-framework test-framework-quickcheck2

12264 transformers

12265 ];

12266 benchmarkHaskellDepends = [

12267 base criterion deepseq mtl transformers

12268 ];

12269 description = "Compositional pipelines";

12270 license = stdenv.lib.licenses.bsd3;

12271 }) {};

12272 "pipes-concurrency" = callPackage

12273 ({ mkDerivation, async, base, pipes, stm }:

12274 mkDerivation {

12275 pname = "pipes-concurrency";

12276 version = "2.0.3";

12277 sha256 = "0jsfnlzl6yvhikgn6v361ld9aypv2h2nsz1q24dxfk953zvm2sp5";

12278 configureFlags = [

12279 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12280 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12281 "-fsplitbase" "-f-test-hlint"

12282 ];

12283 libraryHaskellDepends = [ base pipes stm ];

12284 testHaskellDepends = [ async base pipes stm ];

12285 description = "Concurrency for the pipes ecosystem";

12286 license = stdenv.lib.licenses.bsd3;

12287 }) {};

12288 "pipes-parse" = callPackage

12289 ({ mkDerivation, base, pipes, transformers }:

12290 mkDerivation {

12291 pname = "pipes-parse";

12292 version = "3.0.2";

12293 sha256 = "1d5lhh8knk0hmvd9wv2ihs5z9ybyvhd1n7qaazqkazqkyl14pd08";

12294 configureFlags = [

12295 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12296 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12297 "-fsplitbase" "-f-test-hlint"

12298 ];

12299 libraryHaskellDepends = [ base pipes transformers ];

12300 description = "Parsing infrastructure for the pipes ecosystem";

12301 license = stdenv.lib.licenses.bsd3;

12302 }) {};

12303 "placeholders" = callPackage

12304 ({ mkDerivation, base, template-haskell }:

12305 mkDerivation {

12306 pname = "placeholders";

12307 version = "0.1";

12308 sha256 = "0ih35n2pw5gr9ggj2xz5zfcs4bdk200fdw6q9hdy3xna7maphak5";

12309 configureFlags = [

12310 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12311 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12312 "-fsplitbase" "-f-test-hlint"

12313 ];

12314 libraryHaskellDepends = [ base template-haskell ];

12315 homepage = "http://github.com/ahammar/placeholders";

12316 description = "Placeholders for use while developing Haskell code";

12317 license = stdenv.lib.licenses.bsd3;

12318 }) {};

12319 "pointed" = callPackage

12320 ({ mkDerivation, base, comonad, containers, data-default-class

12321 , kan-extensions, semigroupoids, semigroups, stm, tagged

12322 , transformers, transformers-compat

12323 }:

12324 mkDerivation {

12325 pname = "pointed";

12326 version = "4.2";

12327 sha256 = "1rwavs2vycb02d04ba8ziywsxbl6k4yqk6pnmzcx5zhnkcfqvmbm";

12328 configureFlags = [

12329 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12330 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12331 "-fsplitbase" "-f-test-hlint"

12332 ];

12333 libraryHaskellDepends = [

12334 base comonad containers data-default-class kan-extensions

12335 semigroupoids semigroups stm tagged transformers

12336 transformers-compat

12337 ];

12338 homepage = "http://github.com/ekmett/pointed/";

12339 description = "Pointed and copointed data";

12340 license = stdenv.lib.licenses.bsd3;

12341 }) {};

12342 "polyparse" = callPackage

12343 ({ mkDerivation, base, bytestring, text }:

12344 mkDerivation {

12345 pname = "polyparse";

12346 version = "1.10";

12347 sha256 = "0nz7dv91a2f7gf4jnma8qcqa4n6qjcyggf8qdja46sdcabpd0ij2";

12348 revision = "2";

12349 editedCabalFile = "04wy78fnn7qgwsk870zp3a0p8sdsgwk79nhldhn1iqz1vg6i05hj";

12350 configureFlags = [

12351 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12352 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12353 "-fsplitbase" "-f-test-hlint"

12354 ];

12355 libraryHaskellDepends = [ base bytestring text ];

12356 homepage = "http://code.haskell.org/~malcolm/polyparse/";

12357 description = "A variety of alternative parser combinator libraries";

12358 license = "LGPL";

12359 }) {};

12360 "pool-conduit" = callPackage

12361 ({ mkDerivation, base, monad-control, resource-pool, resourcet

12362 , transformers

12363 }:

12364 mkDerivation {

12365 pname = "pool-conduit";

12366 version = "0.1.2.3";

12367 sha256 = "1myjbmbh0jm89ycx9d961mpgw8hp7al8wgnsls4p19gvr73gcbfv";

12368 revision = "1";

12369 editedCabalFile = "19dgfhd4392vc9b6v77siv21sz5wxxrq4gkm0l54m0mkah8gg55q";

12370 configureFlags = [

12371 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12372 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12373 "-fsplitbase" "-f-test-hlint"

12374 ];

12375 libraryHaskellDepends = [

12376 base monad-control resource-pool resourcet transformers

12377 ];

12378 homepage = "http://www.yesodweb.com/book/persistent";

12379 description = "Resource pool allocations via ResourceT. (deprecated)";

12380 license = stdenv.lib.licenses.mit;

12381 }) {};

12382 "postgresql-binary" = callPackage

12383 ({ mkDerivation, attoparsec, base, base-prelude, bytestring

12384 , criterion, deepseq, loch-th, mtl-prelude, placeholders

12385 , scientific, text, time, transformers, uuid

12386 }:

12387 mkDerivation {

12388 pname = "postgresql-binary";

12389 version = "0.5.1";

12390 sha256 = "09y7llixrzqyl64zv2a40i6jsvq2c03szw8y7y8pz81awd6pid4q";

12391 configureFlags = [

12392 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12393 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12394 "-fsplitbase" "-f-test-hlint"

12395 ];

12396 libraryHaskellDepends = [

12397 attoparsec base base-prelude bytestring loch-th placeholders

12398 scientific text time transformers uuid

12399 ];

12400 benchmarkHaskellDepends = [

12401 base base-prelude bytestring criterion deepseq mtl-prelude

12402 scientific text time

12403 ];

12404 doCheck = false;

12405 homepage = "https://github.com/nikita-volkov/postgresql-binary";

12406 description = "Encoders and decoders for the PostgreSQL's binary format";

12407 license = stdenv.lib.licenses.mit;

12408 }) {};

12409 "postgresql-libpq" = callPackage

12410 ({ mkDerivation, base, bytestring, postgresql }:

12411 mkDerivation {

12412 pname = "postgresql-libpq";

12413 version = "0.9.0.2";

12414 sha256 = "1x1nmzl1j6vc3vy746ch6ps4wy6hwqm78yl9cq9fvkpllh0a2dnw";

12415 configureFlags = [

12416 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12417 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12418 "-fsplitbase" "-f-test-hlint"

12419 ];

12420 libraryHaskellDepends = [ base bytestring ];

12421 librarySystemDepends = [ postgresql ];

12422 homepage = "http://github.com/lpsmith/postgresql-libpq";

12423 description = "low-level binding to libpq";

12424 license = stdenv.lib.licenses.bsd3;

12425 }) {inherit (pkgs) postgresql;};

12426 "postgresql-simple" = callPackage

12427 ({ mkDerivation, aeson, attoparsec, base, base16-bytestring

12428 , blaze-builder, blaze-textual, bytestring, case-insensitive

12429 , containers, cryptohash, hashable, HUnit, postgresql-libpq

12430 , scientific, template-haskell, text, time, transformers, uuid

12431 , vector

12432 }:

12433 mkDerivation {

12434 pname = "postgresql-simple";

12435 version = "0.4.10.0";

12436 sha256 = "0ar8rjd3fsk56ykf7ys3f14ld3771dknhvkfk08fq7054rilrir0";

12437 configureFlags = [

12438 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12439 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12440 "-fsplitbase" "-f-test-hlint"

12441 ];

12442 libraryHaskellDepends = [

12443 aeson attoparsec base blaze-builder blaze-textual bytestring

12444 case-insensitive containers hashable postgresql-libpq scientific

12445 template-haskell text time transformers uuid vector

12446 ];

12447 testHaskellDepends = [

12448 aeson base base16-bytestring bytestring containers cryptohash HUnit

12449 text time vector

12450 ];

12451 doCheck = false;

12452 description = "Mid-Level PostgreSQL client library";

12453 license = stdenv.lib.licenses.bsd3;

12454 }) {};

12455 "pqueue" = callPackage

12456 ({ mkDerivation, base, deepseq }:

12457 mkDerivation {

12458 pname = "pqueue";

12459 version = "1.2.1";

12460 sha256 = "1fily60f4njby7zknmik7a2wxsm3y77ckr69w9bb3fgq22gbzky6";

12461 revision = "1";

12462 editedCabalFile = "18szw5gxjvws2ygg2g18mysabqh9hib0p4c9n5pb3f62i6my47ga";

12463 configureFlags = [

12464 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12465 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12466 "-fsplitbase" "-f-test-hlint"

12467 ];

12468 libraryHaskellDepends = [ base deepseq ];

12469 description = "Reliable, persistent, fast priority queues";

12470 license = stdenv.lib.licenses.bsd3;

12471 }) {};

12472 "prefix-units" = callPackage

12473 ({ mkDerivation, base, Cabal, HUnit, QuickCheck, test-framework

12474 , test-framework-hunit, test-framework-quickcheck2

12475 }:

12476 mkDerivation {

12477 pname = "prefix-units";

12478 version = "0.1.0.2";

12479 sha256 = "07b5s2bsqlaad06dgr5psidfgi1nmgc5c16j6kzayw9f4najjrav";

12480 revision = "1";

12481 editedCabalFile = "02mh9m5yx7n25zl4vggjqckysphp60n2gic0m128wrsj7aannba9";

12482 configureFlags = [

12483 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12484 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12485 "-fsplitbase" "-f-test-hlint"

12486 ];

12487 libraryHaskellDepends = [ base ];

12488 testHaskellDepends = [

12489 base Cabal HUnit QuickCheck test-framework test-framework-hunit

12490 test-framework-quickcheck2

12491 ];

12492 homepage = "https://github.com/iustin/prefix-units";

12493 description = "A basic library for SI/binary prefix units";

12494 license = stdenv.lib.licenses.bsd3;

12495 }) {};

12496 "prelude-extras" = callPackage

12497 ({ mkDerivation, base }:

12498 mkDerivation {

12499 pname = "prelude-extras";

12500 version = "0.4";

12501 sha256 = "0mzsc9pzcamaa7i3g9hkajy35sbpqdjrflv6r98r8hhlr0yrdjan";

12502 configureFlags = [

12503 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12504 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12505 "-fsplitbase" "-f-test-hlint"

12506 ];

12507 libraryHaskellDepends = [ base ];

12508 homepage = "http://github.com/ekmett/prelude-extras";

12509 description = "Haskell 98 - higher order versions of Prelude classes";

12510 license = stdenv.lib.licenses.bsd3;

12511 }) {};

12512 "present" = callPackage

12513 ({ mkDerivation, aeson, atto-lisp, base, bytestring, data-default

12514 , mtl, semigroups, text

12515 }:

12516 mkDerivation {

12517 pname = "present";

12518 version = "2.2";

12519 sha256 = "1z9zvmszda7h1h4inq4b6ig9bd205mskqq85ns3rzsffxaj471p4";

12520 revision = "1";

12521 editedCabalFile = "1hb9symzrc8f447rgni8rndnka0qpcg4p7n4khd49qipdaxm3947";

12522 configureFlags = [

12523 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12524 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12525 "-fsplitbase" "-f-test-hlint"

12526 ];

12527 libraryHaskellDepends = [

12528 aeson atto-lisp base bytestring data-default mtl semigroups text

12529 ];

12530 description = "Make presentations for data types";

12531 license = stdenv.lib.licenses.bsd3;

12532 }) {};

12533 "pretty-class" = callPackage

12534 ({ mkDerivation, base, pretty }:

12535 mkDerivation {

12536 pname = "pretty-class";

12537 version = "1.0.1.1";

12538 sha256 = "1qdfp2kpahzflq9a3idwmb0pqs4l7almxn5rbw5gp2pmdx81p3am";

12539 configureFlags = [

12540 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12541 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12542 "-fsplitbase" "-f-test-hlint"

12543 ];

12544 libraryHaskellDepends = [ base pretty ];

12545 homepage = "https://github.com/ddssff/pretty-class";

12546 description = "Pretty printing class similar to Show";

12547 license = stdenv.lib.licenses.bsd3;

12548 }) {};

12549 "pretty-show" = callPackage

12550 ({ mkDerivation, array, base, filepath, ghc-prim, happy

12551 , haskell-lexer, pretty

12552 }:

12553 mkDerivation {

12554 pname = "pretty-show";

12555 version = "1.6.8.2";

12556 sha256 = "1s95nzjkmqb747s50i68c9s8p91cxgydzqkd2l5yjzdaygrvrhqv";

12557 revision = "1";

12558 editedCabalFile = "0622xpyhzybywq0ybdy0mclb5xhhs3al7jpvndgwd37i64qnfm1l";

12559 configureFlags = [

12560 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12561 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12562 "-fsplitbase" "-f-test-hlint"

12563 ];

12564 isLibrary = true;

12565 isExecutable = true;

12566 enableSeparateDataOutput = true;

12567 libraryHaskellDepends = [

12568 array base filepath ghc-prim haskell-lexer pretty

12569 ];

12570 libraryToolDepends = [ happy ];

12571 executableHaskellDepends = [ base ];

12572 homepage = "http://wiki.github.com/yav/pretty-show";

12573 description = "Tools for working with derived `Show` instances and generic inspection of values";

12574 license = stdenv.lib.licenses.mit;

12575 }) {};

12576 "prettyclass" = callPackage

12577 ({ mkDerivation, base, pretty }:

12578 mkDerivation {

12579 pname = "prettyclass";

12580 version = "1.0.0.0";

12581 sha256 = "11l9ajci7nh1r547hx8hgxrhq8mh5gdq30pdf845wvilg9p48dz5";

12582 configureFlags = [

12583 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12584 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12585 "-fsplitbase" "-f-test-hlint"

12586 ];

12587 libraryHaskellDepends = [ base pretty ];

12588 description = "Pretty printing class similar to Show";

12589 license = stdenv.lib.licenses.bsd3;

12590 }) {};

12591 "primes" = callPackage

12592 ({ mkDerivation, base }:

12593 mkDerivation {

12594 pname = "primes";

12595 version = "0.2.1.0";

12596 sha256 = "0ny6fzr967d1fifk050k95j9snnbjjif2bxf3v9s93k3zdc6bmkl";

12597 configureFlags = [

12598 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12599 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12600 "-fsplitbase" "-f-test-hlint"

12601 ];

12602 libraryHaskellDepends = [ base ];

12603 homepage = "http://github.com/sebfisch/primes";

12604 description = "Efficient, purely functional generation of prime numbers";

12605 license = stdenv.lib.licenses.bsd3;

12606 }) {};

12607 "primitive" = callPackage

12608 ({ mkDerivation, base, ghc-prim }:

12609 mkDerivation {

12610 pname = "primitive";

12611 version = "0.5.4.0";

12612 sha256 = "05gdgj383xdrdkhxh26imlvs8ji0z28ny38ms9snpvv5i8l2lg10";

12613 revision = "1";

12614 editedCabalFile = "17pgp8vyqhwg9fr7lvff9hjhn78v13g9hf0j09ma0qcc2sf142nz";

12615 configureFlags = [

12616 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12617 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12618 "-fsplitbase" "-f-test-hlint"

12619 ];

12620 libraryHaskellDepends = [ base ghc-prim ];

12621 testHaskellDepends = [ base ghc-prim ];

12622 homepage = "https://github.com/haskell/primitive";

12623 description = "Primitive memory-related operations";

12624 license = stdenv.lib.licenses.bsd3;

12625 }) {};

12626 "process-conduit" = callPackage

12627 ({ mkDerivation, base, bytestring, conduit, conduit-extra

12628 , control-monad-loop, hspec, mtl, process, resourcet, shakespeare

12629 , shakespeare-text, template-haskell, text

12630 }:

12631 mkDerivation {

12632 pname = "process-conduit";

12633 version = "1.2.0.1";

12634 sha256 = "0hnbywmjvk3y26sc9a0jfqzm04pg08zd2bflld1mvni02s89lvc8";

12635 configureFlags = [

12636 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12637 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12638 "-fsplitbase" "-f-test-hlint"

12639 ];

12640 libraryHaskellDepends = [

12641 base bytestring conduit control-monad-loop mtl process resourcet

12642 shakespeare shakespeare-text template-haskell text

12643 ];

12644 testHaskellDepends = [

12645 base bytestring conduit conduit-extra hspec resourcet

12646 ];

12647 homepage = "http://github.com/snoyberg/process-conduit";

12648 description = "Conduits for processes (deprecated)";

12649 license = stdenv.lib.licenses.bsd3;

12650 }) {};

12651 "process-extras" = callPackage

12652 ({ mkDerivation, base, bytestring, deepseq, process, text }:

12653 mkDerivation {

12654 pname = "process-extras";

12655 version = "0.2.0";

12656 sha256 = "0mr4f2v19qz6d6jhffz9gky0ykdqwl8c11adbdm04wm2a3xsvf7g";

12657 configureFlags = [

12658 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12659 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12660 "-fsplitbase" "-f-test-hlint"

12661 ];

12662 libraryHaskellDepends = [ base bytestring deepseq process text ];

12663 homepage = "https://github.com/davidlazar/process-extras";

12664 description = "Process extras";

12665 license = stdenv.lib.licenses.mit;

12666 }) {};

12667 "product-profunctors" = callPackage

12668 ({ mkDerivation, base, contravariant, profunctors, template-haskell

12669 }:

12670 mkDerivation {

12671 pname = "product-profunctors";

12672 version = "0.6";

12673 sha256 = "1qhl2v0shzip5yh7x7b6k7xsnd4d5spf1f69h0qr0l57lm6jywl4";

12674 revision = "5";

12675 editedCabalFile = "0jg4j2vsjrqxpzzprygqdfgvqy2jvhy5556101g5ixryhx9k21cx";

12676 configureFlags = [

12677 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12678 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12679 "-fsplitbase" "-f-test-hlint"

12680 ];

12681 libraryHaskellDepends = [

12682 base contravariant profunctors template-haskell

12683 ];

12684 testHaskellDepends = [ base profunctors ];

12685 homepage = "https://github.com/tomjaguarpaw/product-profunctors";

12686 description = "product-profunctors";

12687 license = stdenv.lib.licenses.bsd3;

12688 }) {};

12689 "profunctor-extras" = callPackage

12690 ({ mkDerivation, base, profunctors }:

12691 mkDerivation {

12692 pname = "profunctor-extras";

12693 version = "4.0";

12694 sha256 = "10j458liqlyz5s9gkg95c6aq7ap5fa7d8pc7hygy71nn87pm2g4a";

12695 configureFlags = [

12696 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12697 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12698 "-fsplitbase" "-f-test-hlint"

12699 ];

12700 libraryHaskellDepends = [ base profunctors ];

12701 doHaddock = false;

12702 homepage = "http://github.com/ekmett/profunctor-extras/";

12703 description = "This package has been absorbed into profunctors 4.0";

12704 license = stdenv.lib.licenses.bsd3;

12705 }) {};

12706 "profunctors" = callPackage

12707 ({ mkDerivation, base, comonad, distributive, semigroupoids, tagged

12708 , transformers

12709 }:

12710 mkDerivation {

12711 pname = "profunctors";

12712 version = "4.3.2";

12713 sha256 = "06dv9bjz2hsm32kzfqqm6z54197dfjm3wycnbbgl9pib711w484v";

12714 revision = "2";

12715 editedCabalFile = "0galplr91gxb3n8z5l3l6sbvlwkcxnlg1144m459h5qyngklww19";

12716 configureFlags = [

12717 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12718 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12719 "-fsplitbase" "-f-test-hlint"

12720 ];

12721 libraryHaskellDepends = [

12722 base comonad distributive semigroupoids tagged transformers

12723 ];

12724 homepage = "http://github.com/ekmett/profunctors/";

12725 description = "Profunctors";

12726 license = stdenv.lib.licenses.bsd3;

12727 }) {};

12728 "project-template" = callPackage

12729 ({ mkDerivation, base, base64-bytestring, bytestring, conduit

12730 , conduit-extra, containers, hspec, mtl, QuickCheck, resourcet

12731 , system-fileio, system-filepath, text, transformers

12732 }:

12733 mkDerivation {

12734 pname = "project-template";

12735 version = "0.1.4.2";

12736 sha256 = "10n23s6g7fv0l42hsb804z0qqcyxqw32kwzg1f0w3c6gka844akr";

12737 configureFlags = [

12738 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12739 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12740 "-fsplitbase" "-f-test-hlint"

12741 ];

12742 libraryHaskellDepends = [

12743 base base64-bytestring bytestring conduit conduit-extra containers

12744 mtl resourcet system-fileio system-filepath text transformers

12745 ];

12746 testHaskellDepends = [

12747 base base64-bytestring bytestring conduit containers hspec

12748 QuickCheck resourcet system-filepath text transformers

12749 ];

12750 homepage = "https://github.com/fpco/haskell-ide";

12751 description = "Specify Haskell project templates and generate files";

12752 license = stdenv.lib.licenses.bsd3;

12753 }) {};

12754 "publicsuffixlist" = callPackage

12755 ({ mkDerivation, base, bytestring, cereal, containers, data-default

12756 , HUnit, idna, text, utf8-string

12757 }:

12758 mkDerivation {

12759 pname = "publicsuffixlist";

12760 version = "0.1";

12761 sha256 = "0mbrmhgyjp8jms3fd3nq4knc4j97sw8ijrmnlfjs7qj8jw4vwzxk";

12762 configureFlags = [

12763 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12764 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12765 "-fsplitbase" "-f-test-hlint"

12766 ];

12767 libraryHaskellDepends = [

12768 base bytestring cereal containers data-default text utf8-string

12769 ];

12770 testHaskellDepends = [

12771 base bytestring cereal containers data-default HUnit idna text

12772 utf8-string

12773 ];

12774 homepage = "https://github.com/litherum/publicsuffixlist";

12775 description = "Is a given string a domain suffix?";

12776 license = stdenv.lib.licenses.bsd3;

12777 }) {};

12778 "punycode" = callPackage

12779 ({ mkDerivation, base, bytestring, cereal, mtl, text }:

12780 mkDerivation {

12781 pname = "punycode";

12782 version = "2.0";

12783 sha256 = "192jgfixnpxdj6jiiz92kx5bi6ij3c389b76q9f4vyfmvcajj1sr";

12784 configureFlags = [

12785 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12786 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12787 "-fsplitbase" "-f-test-hlint"

12788 ];

12789 libraryHaskellDepends = [ base bytestring cereal mtl text ];

12790 doCheck = false;

12791 homepage = "https://github.com/litherum/punycode";

12792 description = "Encode unicode strings to ascii forms according to RFC 3492";

12793 license = stdenv.lib.licenses.bsd3;

12794 }) {};

12795 "pure-io" = callPackage

12796 ({ mkDerivation, base, containers, mtl, safe }:

12797 mkDerivation {

12798 pname = "pure-io";

12799 version = "0.2.1";

12800 sha256 = "0pzvkd8jxw859s187n972yaq5wmwi00cxwhivgffr7z29hr0zvx9";

12801 configureFlags = [

12802 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12803 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12804 "-fsplitbase" "-f-test-hlint"

12805 ];

12806 libraryHaskellDepends = [ base containers mtl safe ];

12807 description = "Pure IO monad";

12808 license = stdenv.lib.licenses.bsd3;

12809 }) {};

12810 "pureMD5" = callPackage

12811 ({ mkDerivation, base, binary, bytestring, cereal, crypto-api

12812 , tagged

12813 }:

12814 mkDerivation {

12815 pname = "pureMD5";

12816 version = "2.1.2.1";

12817 sha256 = "1zsn949qk95bwx1fbyv84q0lhb4k18bgixl7nivfzsnmhr31fs37";

12818 configureFlags = [

12819 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12820 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12821 "-fsplitbase" "-f-test-hlint"

12822 ];

12823 libraryHaskellDepends = [

12824 base binary bytestring cereal crypto-api tagged

12825 ];

12826 description = "A Haskell-only implementation of the MD5 digest (hash) algorithm";

12827 license = stdenv.lib.licenses.bsd3;

12828 }) {};

12829 "pwstore-fast" = callPackage

12830 ({ mkDerivation, base, base64-bytestring, binary, byteable

12831 , bytestring, cryptohash, random

12832 }:

12833 mkDerivation {

12834 pname = "pwstore-fast";

12835 version = "2.4.4";

12836 sha256 = "1cpvlwzg3qznhygrr78f75p65mnljd9v5cvnagfxjqppnrkay6bj";

12837 configureFlags = [

12838 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12839 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12840 "-fsplitbase" "-f-test-hlint"

12841 ];

12842 libraryHaskellDepends = [

12843 base base64-bytestring binary byteable bytestring cryptohash random

12844 ];

12845 homepage = "https://github.com/PeterScott/pwstore";

12846 description = "Secure password storage";

12847 license = stdenv.lib.licenses.bsd3;

12848 }) {};

12849 "quandl-api" = callPackage

12850 ({ mkDerivation, aeson, base, blaze-builder, bytestring

12851 , http-conduit, http-types, old-locale, syb, text, time

12852 , unordered-containers

12853 }:

12854 mkDerivation {

12855 pname = "quandl-api";

12856 version = "0.2.0.0";

12857 sha256 = "1h6gh9wssb8dw9r5f7caanxq542d0jw9shvp7wx0i1k47f54kb3k";

12858 configureFlags = [

12859 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12860 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12861 "-fsplitbase" "-f-test-hlint"

12862 ];

12863 libraryHaskellDepends = [

12864 aeson base blaze-builder bytestring http-conduit http-types

12865 old-locale syb text time unordered-containers

12866 ];

12867 homepage = "https://github.com/pvdbrand/quandl-api";

12868 description = "Quandl.com API library";

12869 license = stdenv.lib.licenses.bsd3;

12870 }) {};

12871 "quickcheck-assertions" = callPackage

12872 ({ mkDerivation, base, hspec, ieee754, QuickCheck }:

12873 mkDerivation {

12874 pname = "quickcheck-assertions";

12875 version = "0.1.1";

12876 sha256 = "0hrnr17wafng7nc6d8w6pp1lygplri8xkb5380aq64zg9iik2s21";

12877 configureFlags = [

12878 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12879 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12880 "-fsplitbase" "-f-test-hlint"

12881 ];

12882 libraryHaskellDepends = [ base ieee754 QuickCheck ];

12883 testHaskellDepends = [ base hspec ieee754 QuickCheck ];

12884 homepage = "https://github.com/s9gf4ult/quickcheck-assertions";

12885 description = "HUnit like assertions for QuickCheck";

12886 license = stdenv.lib.licenses.lgpl3;

12887 }) {};

12888 "quickcheck-instances" = callPackage

12889 ({ mkDerivation, array, base, bytestring, containers, hashable

12890 , old-time, QuickCheck, text, time, unordered-containers

12891 }:

12892 mkDerivation {

12893 pname = "quickcheck-instances";

12894 version = "0.3.11";

12895 sha256 = "041s6963czs1pz0fc9cx17lgd6p83czqy2nxji7bhxqxwl2j15h2";

12896 revision = "1";

12897 editedCabalFile = "0k2gkhyy0d8ii1hyi9gfhwzdz4yd54brmw9xxcccy06jdal48xxq";

12898 configureFlags = [

12899 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12900 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12901 "-fsplitbase" "-f-test-hlint"

12902 ];

12903 libraryHaskellDepends = [

12904 array base bytestring containers hashable old-time QuickCheck text

12905 time unordered-containers

12906 ];

12907 homepage = "https://github.com/aslatter/qc-instances";

12908 description = "Common quickcheck instances";

12909 license = stdenv.lib.licenses.bsd3;

12910 }) {};

12911 "quickcheck-io" = callPackage

12912 ({ mkDerivation, base, HUnit, QuickCheck }:

12913 mkDerivation {

12914 pname = "quickcheck-io";

12915 version = "0.1.1";

12916 sha256 = "16q3sqvxnaqmbb1zbda8f61mdlmmzxhrznqxab113lmg380nwfm2";

12917 revision = "2";

12918 editedCabalFile = "02c482j3h72qyc58xgwc7iwwh7wgxi3liqbc8gk9nb9sxciikd9j";

12919 configureFlags = [

12920 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12921 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12922 "-fsplitbase" "-f-test-hlint"

12923 ];

12924 libraryHaskellDepends = [ base HUnit QuickCheck ];

12925 description = "Use HUnit assertions as QuickCheck properties";

12926 license = stdenv.lib.licenses.mit;

12927 }) {};

12928 "quickcheck-unicode" = callPackage

12929 ({ mkDerivation, base, QuickCheck }:

12930 mkDerivation {

12931 pname = "quickcheck-unicode";

12932 version = "1.0.0.1";

12933 sha256 = "1a8nl6x7l9b22yx61wm0bh2n1xzb1hd5i5zgg1w4fpaivjnrrhi4";

12934 configureFlags = [

12935 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12936 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12937 "-fsplitbase" "-f-test-hlint"

12938 ];

12939 libraryHaskellDepends = [ base QuickCheck ];

12940 homepage = "https://github.com/bos/quickcheck-unicode";

12941 description = "Generator and shrink functions for testing Unicode-related software";

12942 license = stdenv.lib.licenses.bsd3;

12943 }) {};

12944 "quickpull" = callPackage

12945 ({ mkDerivation, barecheck, base, directory, filepath, QuickCheck

12946 }:

12947 mkDerivation {

12948 pname = "quickpull";

12949 version = "0.4.2.2";

12950 sha256 = "0vy5s3qa67kwj68rxqc0zhqizqpvqa1x0bg3dakq5pimrqhmb7d4";

12951 configureFlags = [

12952 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12953 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12954 "-fsplitbase" "-f-test-hlint"

12955 ];

12956 isLibrary = true;

12957 isExecutable = true;

12958 libraryHaskellDepends = [ base directory filepath QuickCheck ];

12959 executableHaskellDepends = [

12960 barecheck base directory filepath QuickCheck

12961 ];

12962 testHaskellDepends = [ base directory filepath QuickCheck ];

12963 homepage = "http://www.github.com/massysett/quickpull";

12964 description = "Generate Main module with QuickCheck tests";

12965 license = stdenv.lib.licenses.bsd3;

12966 }) {};

12967 "rainbow" = callPackage

12968 ({ mkDerivation, base, terminfo, text }:

12969 mkDerivation {

12970 pname = "rainbow";

12971 version = "0.20.0.4";

12972 sha256 = "0myipv34pfyi71h1ni9hdi1662whjnl83g9jpag77a00sk0p3rkm";

12973 configureFlags = [

12974 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12975 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12976 "-fsplitbase" "-f-test-hlint"

12977 ];

12978 libraryHaskellDepends = [ base terminfo text ];

12979 homepage = "http://www.github.com/massysett/rainbow";

12980 description = "Print text to terminal with colors and effects";

12981 license = stdenv.lib.licenses.bsd3;

12982 }) {};

12983 "rainbow-tests" = callPackage

12984 ({ mkDerivation, barecheck, base, QuickCheck, rainbow, terminfo

12985 , text

12986 }:

12987 mkDerivation {

12988 pname = "rainbow-tests";

12989 version = "0.20.0.4";

12990 sha256 = "0cjq2m2zpk4j2f7gw65yqqvyc4kng1rsnq48fs4xcs6bdzw0zhlg";

12991 configureFlags = [

12992 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

12993 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

12994 "-fsplitbase" "-f-test-hlint"

12995 ];

12996 libraryHaskellDepends = [

12997 barecheck base QuickCheck rainbow terminfo text

12998 ];

12999 homepage = "http://www.github.com/massysett/rainbow";

13000 description = "Tests and QuickCheck generators to accompany rainbow";

13001 license = stdenv.lib.licenses.bsd3;

13002 }) {};

13003 "random" = callPackage

13004 ({ mkDerivation, base, time }:

13005 mkDerivation {

13006 pname = "random";

13007 version = "1.0.1.1";

13008 sha256 = "0n8m2744gg233s357vqzq3mfhhnbhynqvp4gxsi2gb70bm03nz6z";

13009 configureFlags = [

13010 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13011 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13012 "-fsplitbase" "-f-test-hlint"

13013 ];

13014 libraryHaskellDepends = [ base time ];

13015 description = "random number library";

13016 license = stdenv.lib.licenses.bsd3;

13017 }) {};

13018 "random-fu" = callPackage

13019 ({ mkDerivation, base, erf, log-domain, math-functions, monad-loops

13020 , mtl, random-shuffle, random-source, rvar, syb, template-haskell

13021 , transformers, vector

13022 }:

13023 mkDerivation {

13024 pname = "random-fu";

13025 version = "0.2.6.2";

13026 sha256 = "1j7zr7h860vjwlh9d9sj319xs44ly2vyzn3s72c5qc39r0yv00ng";

13027 configureFlags = [

13028 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13029 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13030 "-fsplitbase" "-f-test-hlint"

13031 ];

13032 libraryHaskellDepends = [

13033 base erf log-domain math-functions monad-loops mtl random-shuffle

13034 random-source rvar syb template-haskell transformers vector

13035 ];

13036 homepage = "https://github.com/mokus0/random-fu";

13037 description = "Random number generation";

13038 license = stdenv.lib.licenses.publicDomain;

13039 }) {};

13040 "random-shuffle" = callPackage

13041 ({ mkDerivation, base, MonadRandom, random }:

13042 mkDerivation {

13043 pname = "random-shuffle";

13044 version = "0.0.4";

13045 sha256 = "0586bnlh0g2isc44jbjvafkcl4yw6lp1db8x6vr0pza0y08l8w2j";

13046 configureFlags = [

13047 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13048 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13049 "-fsplitbase" "-f-test-hlint"

13050 ];

13051 libraryHaskellDepends = [ base MonadRandom random ];

13052 description = "Random shuffle implementation";

13053 license = stdenv.lib.licenses.bsd3;

13054 }) {};

13055 "random-source" = callPackage

13056 ({ mkDerivation, base, flexible-defaults, mersenne-random-pure64

13057 , mtl, mwc-random, random, stateref, syb, template-haskell

13058 , th-extras

13059 }:

13060 mkDerivation {

13061 pname = "random-source";

13062 version = "0.3.0.6";

13063 sha256 = "0wsv41kpswqml04ym5bq2nan4i637f7h3fmvda2zy506xwxfrpzk";

13064 configureFlags = [

13065 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13066 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13067 "-fsplitbase" "-f-test-hlint"

13068 ];

13069 libraryHaskellDepends = [

13070 base flexible-defaults mersenne-random-pure64 mtl mwc-random random

13071 stateref syb template-haskell th-extras

13072 ];

13073 homepage = "https://github.com/mokus0/random-fu";

13074 description = "Generic basis for random number generators";

13075 license = stdenv.lib.licenses.publicDomain;

13076 }) {};

13077 "rank1dynamic" = callPackage

13078 ({ mkDerivation, base, binary, constraints, ghc-prim, HUnit

13079 , test-framework, test-framework-hunit

13080 }:

13081 mkDerivation {

13082 pname = "rank1dynamic";

13083 version = "0.2.0.1";

13084 sha256 = "1np3ghp7wdn0clsyslk5j6fhs4c5cd6y0xlvdg2jj6ydaglzcchl";

13085 configureFlags = [

13086 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13087 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13088 "-fsplitbase" "-f-test-hlint"

13089 ];

13090 libraryHaskellDepends = [ base binary ghc-prim ];

13091 testHaskellDepends = [

13092 base constraints HUnit test-framework test-framework-hunit

13093 ];

13094 homepage = "http://haskell-distributed.github.com";

13095 description = "Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types";

13096 license = stdenv.lib.licenses.bsd3;

13097 }) {};

13098 "raw-strings-qq" = callPackage

13099 ({ mkDerivation, base, template-haskell }:

13100 mkDerivation {

13101 pname = "raw-strings-qq";

13102 version = "1.0.2";

13103 sha256 = "0wnifa97am2s9bqixlidw3nf8w14h2qkg3sn1rxzgvc3fws57jg9";

13104 configureFlags = [

13105 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13106 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13107 "-fsplitbase" "-f-test-hlint"

13108 ];

13109 libraryHaskellDepends = [ base template-haskell ];

13110 homepage = "https://github.com/23Skidoo/raw-strings-qq";

13111 description = "Raw string literals for Haskell";

13112 license = stdenv.lib.licenses.bsd3;

13113 }) {};

13114 "reducers" = callPackage

13115 ({ mkDerivation, array, base, bytestring, comonad, containers

13116 , fingertree, hashable, keys, pointed, semigroupoids, semigroups

13117 , text, transformers, unordered-containers

13118 }:

13119 mkDerivation {

13120 pname = "reducers";

13121 version = "3.10.3.1";

13122 sha256 = "0qmd93jdh0qjyc9if9hr2yjanrqx5nlbz5j0daiywzxcb0hi7ri8";

13123 revision = "1";

13124 editedCabalFile = "166gd2dmmxz7g04r23bbkn3709cqq6d9vmmy82dzp6sx0d1ryxir";

13125 configureFlags = [

13126 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13127 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13128 "-fsplitbase" "-f-test-hlint"

13129 ];

13130 libraryHaskellDepends = [

13131 array base bytestring comonad containers fingertree hashable keys

13132 pointed semigroupoids semigroups text transformers

13133 unordered-containers

13134 ];

13135 homepage = "http://github.com/ekmett/reducers/";

13136 description = "Semigroups, specialized containers and a general map/reduce framework";

13137 license = stdenv.lib.licenses.bsd3;

13138 }) {};

13139 "reflection" = callPackage

13140 ({ mkDerivation, base, template-haskell }:

13141 mkDerivation {

13142 pname = "reflection";

13143 version = "1.5.1.2";

13144 sha256 = "09fs42gmhdgfag7k4gm19l63sz5b1sxw6s3hgszpcnnsbv1g9ad4";

13145 configureFlags = [

13146 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13147 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13148 "-fsplitbase" "-f-test-hlint"

13149 ];

13150 libraryHaskellDepends = [ base template-haskell ];

13151 homepage = "http://github.com/ekmett/reflection";

13152 description = "Reifies arbitrary terms into types that can be reflected back into terms";

13153 license = stdenv.lib.licenses.bsd3;

13154 }) {};

13155 "regex-applicative" = callPackage

13156 ({ mkDerivation, base, containers, smallcheck, tasty, tasty-hunit

13157 , tasty-smallcheck, transformers

13158 }:

13159 mkDerivation {

13160 pname = "regex-applicative";

13161 version = "0.3.1";

13162 sha256 = "1klmi101zfpngf8c7fp2ch48kadbw6xs5lg0h00x7wi0zfrdbf0y";

13163 configureFlags = [

13164 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13165 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13166 "-fsplitbase" "-f-test-hlint"

13167 ];

13168 libraryHaskellDepends = [ base containers transformers ];

13169 testHaskellDepends = [

13170 base containers smallcheck tasty tasty-hunit tasty-smallcheck

13171 transformers

13172 ];

13173 homepage = "https://github.com/feuerbach/regex-applicative";

13174 description = "Regex-based parsing with applicative interface";

13175 license = stdenv.lib.licenses.mit;

13176 }) {};

13177 "regex-base" = callPackage

13178 ({ mkDerivation, array, base, bytestring, containers, mtl }:

13179 mkDerivation {

13180 pname = "regex-base";

13181 version = "0.93.2";

13182 sha256 = "0y1j4h2pg12c853nzmczs263di7xkkmlnsq5dlp5wgbgl49mgp10";

13183 configureFlags = [

13184 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13185 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13186 "-fsplitbase" "-f-test-hlint"

13187 ];

13188 libraryHaskellDepends = [ array base bytestring containers mtl ];

13189 homepage = "http://sourceforge.net/projects/lazy-regex";

13190 description = "Replaces/Enhances Text.Regex";

13191 license = stdenv.lib.licenses.bsd3;

13192 }) {};

13193 "regex-compat" = callPackage

13194 ({ mkDerivation, array, base, regex-base, regex-posix }:

13195 mkDerivation {

13196 pname = "regex-compat";

13197 version = "0.95.1";

13198 sha256 = "0fwmima3f04p9y4h3c23493n1xj629ia2dxaisqm6rynljjv2z6m";

13199 configureFlags = [

13200 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13201 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13202 "-fsplitbase" "-f-test-hlint"

13203 ];

13204 libraryHaskellDepends = [ array base regex-base regex-posix ];

13205 homepage = "http://sourceforge.net/projects/lazy-regex";

13206 description = "Replaces/Enhances Text.Regex";

13207 license = stdenv.lib.licenses.bsd3;

13208 }) {};

13209 "regex-pcre-builtin" = callPackage

13210 ({ mkDerivation, array, base, bytestring, containers, regex-base }:

13211 mkDerivation {

13212 pname = "regex-pcre-builtin";

13213 version = "0.94.4.8.8.35";

13214 sha256 = "0y7as9wqlkykpipka2cfdhmcnin345q01pp0wsva8fwmvsavdl8b";

13215 configureFlags = [

13216 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13217 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13218 "-fsplitbase" "-f-test-hlint"

13219 ];

13220 libraryHaskellDepends = [

13221 array base bytestring containers regex-base

13222 ];

13223 homepage = "http://hackage.haskell.org/package/regex-pcre";

13224 description = "Replaces/Enhances Text.Regex";

13225 license = stdenv.lib.licenses.bsd3;

13226 }) {};

13227 "regex-posix" = callPackage

13228 ({ mkDerivation, array, base, bytestring, containers, regex-base }:

13229 mkDerivation {

13230 pname = "regex-posix";

13231 version = "0.95.2";

13232 sha256 = "0gkhzhj8nvfn1ija31c7xnl6p0gadwii9ihyp219ck2arlhrj0an";

13233 configureFlags = [

13234 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13235 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13236 "-fsplitbase" "-f-test-hlint"

13237 ];

13238 libraryHaskellDepends = [

13239 array base bytestring containers regex-base

13240 ];

13241 homepage = "http://sourceforge.net/projects/lazy-regex";

13242 description = "Replaces/Enhances Text.Regex";

13243 license = stdenv.lib.licenses.bsd3;

13244 }) {};

13245 "regex-tdfa" = callPackage

13246 ({ mkDerivation, array, base, bytestring, containers, ghc-prim, mtl

13247 , parsec, regex-base

13248 }:

13249 mkDerivation {

13250 pname = "regex-tdfa";

13251 version = "1.2.0";

13252 sha256 = "00gl9sx3hzd83lp38jlcj7wvzrda8kww7njwlm1way73m8aar0pw";

13253 revision = "1";

13254 editedCabalFile = "13j7a3xkaq0qb4y25i9l8a8lyaqfpc0dakqkwlg1i3hfkydvd2al";

13255 configureFlags = [

13256 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13257 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13258 "-fsplitbase" "-f-test-hlint"

13259 ];

13260 libraryHaskellDepends = [

13261 array base bytestring containers ghc-prim mtl parsec regex-base

13262 ];

13263 homepage = "http://hackage.haskell.org/package/regex-tdfa";

13264 description = "Replaces/Enhances Text.Regex";

13265 license = stdenv.lib.licenses.bsd3;

13266 }) {};

13267 "regex-tdfa-rc" = callPackage

13268 ({ mkDerivation, array, base, bytestring, containers, ghc-prim, mtl

13269 , parsec, regex-base

13270 }:

13271 mkDerivation {

13272 pname = "regex-tdfa-rc";

13273 version = "1.1.8.3";

13274 sha256 = "1vi11i23gkkjg6193ak90g55akj69bhahy542frkwb68haky4pp3";

13275 configureFlags = [

13276 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13277 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13278 "-fsplitbase" "-f-test-hlint"

13279 ];

13280 libraryHaskellDepends = [

13281 array base bytestring containers ghc-prim mtl parsec regex-base

13282 ];

13283 homepage = "http://hackage.haskell.org/package/regex-tdfa";

13284 description = "Replaces/Enhances Text.Regex";

13285 license = stdenv.lib.licenses.bsd3;

13286 }) {};

13287 "regexpr" = callPackage

13288 ({ mkDerivation, base, HUnit, mtl, mtlparse }:

13289 mkDerivation {

13290 pname = "regexpr";

13291 version = "0.5.4";

13292 sha256 = "0136wp6hrnmj6pbdhp3a131dzz8bp1pbd92bpagpv1r6gwj16y5z";

13293 configureFlags = [

13294 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13295 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13296 "-fsplitbase" "-f-test-hlint"

13297 ];

13298 libraryHaskellDepends = [ base HUnit mtl mtlparse ];

13299 homepage = "http://homepage3.nifty.com/salamander/second/projects/regexpr/";

13300 description = "regular expression like Perl/Ruby in Haskell";

13301 license = "LGPL";

13302 }) {};

13303 "regular" = callPackage

13304 ({ mkDerivation, base, template-haskell }:

13305 mkDerivation {

13306 pname = "regular";

13307 version = "0.3.4.4";

13308 sha256 = "112n3j27ac9lzs0lc3q12r6wmpkmfgdalv18h1qklhd5nh4j9wl5";

13309 revision = "1";

13310 editedCabalFile = "0hrr2drpmrsb3jim2lgfx7nx2pvycdvfff51j2v3ihgdy8d8zqrw";

13311 configureFlags = [

13312 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13313 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13314 "-fsplitbase" "-f-test-hlint"

13315 ];

13316 libraryHaskellDepends = [ base template-haskell ];

13317 description = "Generic programming library for regular datatypes";

13318 license = stdenv.lib.licenses.bsd3;

13319 }) {};

13320 "regular-xmlpickler" = callPackage

13321 ({ mkDerivation, base, hxt, regular, text }:

13322 mkDerivation {

13323 pname = "regular-xmlpickler";

13324 version = "0.2";

13325 sha256 = "1qjx4xsidnpr2as3m2ir97ap5vc9cw6a0z332g53ifx9gskjli9f";

13326 configureFlags = [

13327 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13328 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13329 "-fsplitbase" "-f-test-hlint"

13330 ];

13331 libraryHaskellDepends = [ base hxt regular text ];

13332 homepage = "http://github.com/silkapp/regular-xmlpickler";

13333 description = "Generic generation of HXT XmlPickler instances using Regular";

13334 license = stdenv.lib.licenses.bsd3;

13335 }) {};

13336 "rematch" = callPackage

13337 ({ mkDerivation, base, hspec, HUnit }:

13338 mkDerivation {

13339 pname = "rematch";

13340 version = "0.2.0.0";

13341 sha256 = "0law4al9hzn9qljfm8rwgmb15pzpcs8i44v1l6279977q0lxx5pr";

13342 configureFlags = [

13343 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13344 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13345 "-fsplitbase" "-f-test-hlint"

13346 ];

13347 libraryHaskellDepends = [ base ];

13348 testHaskellDepends = [ base hspec HUnit ];

13349 doCheck = false;

13350 description = "A simple api for matchers";

13351 license = stdenv.lib.licenses.mit;

13352 }) {};

13353 "repa" = callPackage

13354 ({ mkDerivation, base, bytestring, ghc-prim, QuickCheck

13355 , template-haskell, vector

13356 }:

13357 mkDerivation {

13358 pname = "repa";

13359 version = "3.3.1.2";

13360 sha256 = "0rsahd6c1mxd8hq9zfx4jqgmcfs4di4askky87y71xy5v4k1x4ai";

13361 configureFlags = [

13362 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13363 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13364 "-fsplitbase" "-f-test-hlint"

13365 ];

13366 libraryHaskellDepends = [

13367 base bytestring ghc-prim QuickCheck template-haskell vector

13368 ];

13369 homepage = "http://repa.ouroborus.net";

13370 description = "High performance, regular, shape polymorphic parallel arrays";

13371 license = stdenv.lib.licenses.bsd3;

13372 }) {};

13373 "repa-algorithms" = callPackage

13374 ({ mkDerivation, base, repa, vector }:

13375 mkDerivation {

13376 pname = "repa-algorithms";

13377 version = "3.3.1.2";

13378 sha256 = "12fizvma877ws3xiz3k34jg5xh5yhnl0n5aq2za005l9i5angkk9";

13379 configureFlags = [

13380 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13381 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13382 "-fsplitbase" "-f-test-hlint"

13383 ];

13384 libraryHaskellDepends = [ base repa vector ];

13385 homepage = "http://repa.ouroborus.net";

13386 description = "Algorithms using the Repa array library";

13387 license = stdenv.lib.licenses.bsd3;

13388 }) {};

13389 "repa-devil" = callPackage

13390 ({ mkDerivation, base, libdevil, repa, transformers }:

13391 mkDerivation {

13392 pname = "repa-devil";

13393 version = "0.3.2.2";

13394 sha256 = "0p46ni9z8wymyk4qmcy04kwycxb31yyprd8ddxsxpjilhbw848lh";

13395 configureFlags = [

13396 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13397 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13398 "-fsplitbase" "-f-test-hlint"

13399 ];

13400 libraryHaskellDepends = [ base repa transformers ];

13401 librarySystemDepends = [ libdevil ];

13402 homepage = "https://github.com/RaphaelJ/repa-devil";

13403 description = "Support for image reading and writing of Repa arrays using in-place FFI calls";

13404 license = stdenv.lib.licenses.bsd3;

13405 }) {inherit (pkgs) libdevil;};

13406 "repa-io" = callPackage

13407 ({ mkDerivation, base, binary, bmp, bytestring, old-time, repa

13408 , vector

13409 }:

13410 mkDerivation {

13411 pname = "repa-io";

13412 version = "3.3.1.2";

13413 sha256 = "1i58ysk44y7s6z1jmns2fi83flqma4k5nsjh1pblqb2rgl7x0z5p";

13414 configureFlags = [

13415 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13416 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13417 "-fsplitbase" "-f-test-hlint"

13418 ];

13419 libraryHaskellDepends = [

13420 base binary bmp bytestring old-time repa vector

13421 ];

13422 homepage = "http://repa.ouroborus.net";

13423 description = "Read and write Repa arrays in various formats";

13424 license = stdenv.lib.licenses.bsd3;

13425 }) {};

13426 "reroute" = callPackage

13427 ({ mkDerivation, base, criterion, deepseq, graph-core, hashable

13428 , hspec, mtl, path-pieces, random, regex-compat, text, transformers

13429 , unordered-containers, vector

13430 }:

13431 mkDerivation {

13432 pname = "reroute";

13433 version = "0.2.2.1";

13434 sha256 = "1hrzbjvsdkz3c27lksxzxlhhdrwqbvq90xyawwsc8zh3fp1nzqpn";

13435 configureFlags = [

13436 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13437 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13438 "-fsplitbase" "-f-test-hlint"

13439 ];

13440 libraryHaskellDepends = [

13441 base deepseq graph-core hashable mtl path-pieces regex-compat text

13442 transformers unordered-containers vector

13443 ];

13444 testHaskellDepends = [

13445 base hspec mtl text unordered-containers vector

13446 ];

13447 benchmarkHaskellDepends = [

13448 base criterion deepseq graph-core hashable mtl path-pieces random

13449 regex-compat text unordered-containers vector

13450 ];

13451 homepage = "http://github.com/agrafix/reroute";

13452 description = "abstract implementation of typed and untyped web routing";

13453 license = stdenv.lib.licenses.mit;

13454 }) {};

13455 "resource-pool" = callPackage

13456 ({ mkDerivation, base, hashable, monad-control, stm, time

13457 , transformers, transformers-base, vector

13458 }:

13459 mkDerivation {

13460 pname = "resource-pool";

13461 version = "0.2.3.2";

13462 sha256 = "04mw8b9djb14zp4rdi6h7mc3zizh597ffiinfbr4m0m8psifw9w6";

13463 configureFlags = [

13464 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13465 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13466 "-fsplitbase" "-f-test-hlint"

13467 ];

13468 libraryHaskellDepends = [

13469 base hashable monad-control stm time transformers transformers-base

13470 vector

13471 ];

13472 homepage = "http://github.com/bos/pool";

13473 description = "A high-performance striped resource pooling implementation";

13474 license = stdenv.lib.licenses.bsd3;

13475 }) {};

13476 "resourcet" = callPackage

13477 ({ mkDerivation, base, containers, exceptions, hspec, lifted-base

13478 , mmorph, monad-control, mtl, transformers, transformers-base

13479 , transformers-compat

13480 }:

13481 mkDerivation {

13482 pname = "resourcet";

13483 version = "1.1.4.1";

13484 sha256 = "1qw9bjr22g8a1fr84cmwjqpqs7cfc8iagix4s618snrg1r1gp6p2";

13485 revision = "1";

13486 editedCabalFile = "1mvan3gkx1vnxi3hswly39pyzkwp0sch6rmlvz7k4jr0wxlnf418";

13487 configureFlags = [

13488 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13489 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13490 "-fsplitbase" "-f-test-hlint"

13491 ];

13492 libraryHaskellDepends = [

13493 base containers exceptions lifted-base mmorph monad-control mtl

13494 transformers transformers-base transformers-compat

13495 ];

13496 testHaskellDepends = [ base hspec lifted-base transformers ];

13497 homepage = "http://github.com/snoyberg/conduit";

13498 description = "Deterministic allocation and freeing of scarce resources";

13499 license = stdenv.lib.licenses.bsd3;

13500 }) {};

13501 "rest-client" = callPackage

13502 ({ mkDerivation, aeson-utils, base, bytestring, case-insensitive

13503 , data-default, exception-transformers, http-conduit, http-types

13504 , hxt, hxt-pickle-utils, monad-control, mtl, primitive, resourcet

13505 , rest-types, tostring, transformers-base, uri-encode, utf8-string

13506 }:

13507 mkDerivation {

13508 pname = "rest-client";

13509 version = "0.4.0.5";

13510 sha256 = "11rsy9an7ck94ijafqd2ddichz0xgb01w2ybyg3iiwy5ckiy384s";

13511 configureFlags = [

13512 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13513 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13514 "-fsplitbase" "-f-test-hlint"

13515 ];

13516 libraryHaskellDepends = [

13517 aeson-utils base bytestring case-insensitive data-default

13518 exception-transformers http-conduit http-types hxt hxt-pickle-utils

13519 monad-control mtl primitive resourcet rest-types tostring

13520 transformers-base uri-encode utf8-string

13521 ];

13522 description = "Utility library for use in generated API client libraries";

13523 license = stdenv.lib.licenses.bsd3;

13524 }) {};

13525 "rest-core" = callPackage

13526 ({ mkDerivation, aeson, aeson-utils, base, bytestring, either

13527 , errors, fclabels, HUnit, hxt, hxt-pickle-utils, json-schema, mtl

13528 , multipart, random, rest-stringmap, rest-types, safe, split

13529 , test-framework, test-framework-hunit, text, transformers

13530 , unordered-containers, uri-encode, utf8-string, uuid

13531 }:

13532 mkDerivation {

13533 pname = "rest-core";

13534 version = "0.33.1.2";

13535 sha256 = "0axl6d28agyzklrnl264413a8hpfi7ih296i453r6fg4c63ma5h4";

13536 configureFlags = [

13537 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13538 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13539 "-fsplitbase" "-f-test-hlint"

13540 ];

13541 libraryHaskellDepends = [

13542 aeson aeson-utils base bytestring either errors fclabels hxt

13543 hxt-pickle-utils json-schema mtl multipart random rest-stringmap

13544 rest-types safe split text transformers unordered-containers

13545 uri-encode utf8-string uuid

13546 ];

13547 testHaskellDepends = [

13548 base bytestring HUnit mtl test-framework test-framework-hunit

13549 unordered-containers

13550 ];

13551 description = "Rest API library";

13552 license = stdenv.lib.licenses.bsd3;

13553 }) {};

13554 "rest-gen" = callPackage

13555 ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder

13556 , directory, fclabels, filepath, hashable, haskell-src-exts

13557 , HStringTemplate, HUnit, hxt, json-schema, pretty, process

13558 , rest-core, safe, scientific, semigroups, split, tagged

13559 , test-framework, test-framework-hunit, text, uniplate

13560 , unordered-containers, vector

13561 }:

13562 mkDerivation {

13563 pname = "rest-gen";

13564 version = "0.16.1.8";

13565 sha256 = "0wwxx5a5s4b7j1qbcphprdpba2jy8qx449mq4k4qmz55xzacii2v";

13566 configureFlags = [

13567 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13568 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13569 "-fsplitbase" "-f-test-hlint"

13570 ];

13571 enableSeparateDataOutput = true;

13572 libraryHaskellDepends = [

13573 aeson base blaze-html Cabal code-builder directory fclabels

13574 filepath hashable haskell-src-exts HStringTemplate hxt json-schema

13575 pretty process rest-core safe scientific semigroups split tagged

13576 text uniplate unordered-containers vector

13577 ];

13578 testHaskellDepends = [

13579 base fclabels haskell-src-exts HUnit rest-core test-framework

13580 test-framework-hunit

13581 ];

13582 description = "Documentation and client generation from rest definition";

13583 license = stdenv.lib.licenses.bsd3;

13584 }) {};

13585 "rest-happstack" = callPackage

13586 ({ mkDerivation, base, containers, happstack-server, mtl, rest-core

13587 , rest-gen, utf8-string

13588 }:

13589 mkDerivation {

13590 pname = "rest-happstack";

13591 version = "0.2.10.4";

13592 sha256 = "0p4dcd37hhzmd1acg9404bfy43yf15aqvs9jm4x5sbli22d9bfyp";

13593 revision = "1";

13594 editedCabalFile = "0mi6ynimhsf5zz3ha7ppjc554syy2yxd7yk4gpls0sfgv1iy86zy";

13595 configureFlags = [

13596 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13597 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13598 "-fsplitbase" "-f-test-hlint"

13599 ];

13600 libraryHaskellDepends = [

13601 base containers happstack-server mtl rest-core rest-gen utf8-string

13602 ];

13603 description = "Rest driver for Happstack";

13604 license = stdenv.lib.licenses.bsd3;

13605 }) {};

13606 "rest-snap" = callPackage

13607 ({ mkDerivation, base, bytestring, case-insensitive, rest-core

13608 , safe, snap-core, unordered-containers, uri-encode, utf8-string

13609 }:

13610 mkDerivation {

13611 pname = "rest-snap";

13612 version = "0.1.17.14";

13613 sha256 = "0fd6d85gzp9mr7y7bgfk9wscrhrych9q7cssps8m5l03n83d8asp";

13614 configureFlags = [

13615 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13616 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13617 "-fsplitbase" "-f-test-hlint"

13618 ];

13619 libraryHaskellDepends = [

13620 base bytestring case-insensitive rest-core safe snap-core

13621 unordered-containers uri-encode utf8-string

13622 ];

13623 description = "Rest driver for Snap";

13624 license = stdenv.lib.licenses.bsd3;

13625 }) {};

13626 "rest-stringmap" = callPackage

13627 ({ mkDerivation, aeson, base, containers, hashable, hxt

13628 , json-schema, tagged, text, tostring, unordered-containers

13629 }:

13630 mkDerivation {

13631 pname = "rest-stringmap";

13632 version = "0.2.0.3";

13633 sha256 = "1xy3nnq5ryk78kbcidxk8gqwmnrlvzs1gzpbfm28xyv9awgahk6m";

13634 configureFlags = [

13635 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13636 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13637 "-fsplitbase" "-f-test-hlint"

13638 ];

13639 libraryHaskellDepends = [

13640 aeson base containers hashable hxt json-schema tagged text tostring

13641 unordered-containers

13642 ];

13643 description = "Maps with stringy keys that can be transcoded to JSON and XML";

13644 license = stdenv.lib.licenses.bsd3;

13645 }) {};

13646 "rest-types" = callPackage

13647 ({ mkDerivation, aeson, base, generic-aeson, hxt, json-schema, mtl

13648 , regular, regular-xmlpickler, rest-stringmap, text, uuid

13649 }:

13650 mkDerivation {

13651 pname = "rest-types";

13652 version = "1.11.1.1";

13653 sha256 = "0xr9h1bivw3miyg4xill0jwn95lybsbqgrnw2323pwxlbbnaa25a";

13654 configureFlags = [

13655 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13656 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13657 "-fsplitbase" "-f-test-hlint"

13658 ];

13659 libraryHaskellDepends = [

13660 aeson base generic-aeson hxt json-schema mtl regular

13661 regular-xmlpickler rest-stringmap text uuid

13662 ];

13663 description = "Silk Rest Framework Types";

13664 license = stdenv.lib.licenses.bsd3;

13665 }) {};

13666 "rest-wai" = callPackage

13667 ({ mkDerivation, base, bytestring, case-insensitive, containers

13668 , http-types, mime-types, mtl, rest-core, text

13669 , unordered-containers, utf8-string, wai

13670 }:

13671 mkDerivation {

13672 pname = "rest-wai";

13673 version = "0.1.0.4";

13674 sha256 = "1pxjf0fmsfiywr81zl5xbl6si0x74a7zmz6d5vqv5pvxmpgwgcbg";

13675 configureFlags = [

13676 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13677 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13678 "-fsplitbase" "-f-test-hlint"

13679 ];

13680 libraryHaskellDepends = [

13681 base bytestring case-insensitive containers http-types mime-types

13682 mtl rest-core text unordered-containers utf8-string wai

13683 ];

13684 description = "Rest driver for WAI applications";

13685 license = stdenv.lib.licenses.bsd3;

13686 }) {};

13687 "rev-state" = callPackage

13688 ({ mkDerivation, base, mtl }:

13689 mkDerivation {

13690 pname = "rev-state";

13691 version = "0.1";

13692 sha256 = "1lsq7b225v86rwm2rnrnhn28asjh6r3zwbvdm5vl4sp46cr5i4cf";

13693 configureFlags = [

13694 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13695 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13696 "-fsplitbase" "-f-test-hlint"

13697 ];

13698 libraryHaskellDepends = [ base mtl ];

13699 homepage = "https://github.com/DanBurton/rev-state#readme";

13700 description = "Reverse State monad transformer";

13701 license = stdenv.lib.licenses.bsd3;

13702 }) {};

13703 "rfc5051" = callPackage

13704 ({ mkDerivation, base, bytestring, containers }:

13705 mkDerivation {

13706 pname = "rfc5051";

13707 version = "0.1.0.3";

13708 sha256 = "0av4c3qvwbkbzrjrrg601ay9pds7wscqqp2lc2z78mv2lllap3g3";

13709 configureFlags = [

13710 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13711 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13712 "-fsplitbase" "-f-test-hlint"

13713 ];

13714 isLibrary = true;

13715 isExecutable = true;

13716 libraryHaskellDepends = [ base bytestring containers ];

13717 executableHaskellDepends = [ base bytestring containers ];

13718 description = "Simple unicode collation as per RFC5051";

13719 license = stdenv.lib.licenses.bsd3;

13720 }) {};

13721 "runmemo" = callPackage

13722 ({ mkDerivation, base, data-memocombinators, time }:

13723 mkDerivation {

13724 pname = "runmemo";

13725 version = "1.0.0.1";

13726 sha256 = "12fn0lsil0rj0pj0ixzppsdw2fmj0cnzci4fh11z9rcggwbz6pms";

13727 configureFlags = [

13728 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13729 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13730 "-fsplitbase" "-f-test-hlint"

13731 ];

13732 testHaskellDepends = [ base data-memocombinators time ];

13733 homepage = "https://github.com/DanBurton/runmemo";

13734 description = "A simple memoization helper library";

13735 license = stdenv.lib.licenses.bsd3;

13736 }) {};

13737 "rvar" = callPackage

13738 ({ mkDerivation, base, MonadPrompt, mtl, random-source

13739 , transformers

13740 }:

13741 mkDerivation {

13742 pname = "rvar";

13743 version = "0.2.0.2";

13744 sha256 = "1n24fl27mrm7cndp8b646b9c5hjm3hf5m12y9ni0f850dd739jm4";

13745 configureFlags = [

13746 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13747 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13748 "-fsplitbase" "-f-test-hlint"

13749 ];

13750 libraryHaskellDepends = [

13751 base MonadPrompt mtl random-source transformers

13752 ];

13753 homepage = "https://github.com/mokus0/random-fu";

13754 description = "Random Variables";

13755 license = stdenv.lib.licenses.publicDomain;

13756 }) {};

13757 "safe" = callPackage

13758 ({ mkDerivation, base }:

13759 mkDerivation {

13760 pname = "safe";

13761 version = "0.3.8";

13762 sha256 = "0k5lk85z2y8kgk7dx7km32g8vi55vnwln8ys2gs174ljd136cjdf";

13763 configureFlags = [

13764 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13765 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13766 "-fsplitbase" "-f-test-hlint"

13767 ];

13768 libraryHaskellDepends = [ base ];

13769 homepage = "http://community.haskell.org/~ndm/safe/";

13770 description = "Library of safe (exception free) functions";

13771 license = stdenv.lib.licenses.bsd3;

13772 }) {};

13773 "safecopy" = callPackage

13774 ({ mkDerivation, array, base, bytestring, cereal, containers

13775 , old-time, template-haskell, text, time, vector

13776 }:

13777 mkDerivation {

13778 pname = "safecopy";

13779 version = "0.8.4";

13780 sha256 = "0zwgbaigvysxf5zqdzkfsf0rqdwjq76hp207lchqgvx5rv8wda8h";

13781 revision = "3";

13782 editedCabalFile = "0jxm6avhglkz7slbzfpv1rdddq2jxybvvd4jas3mx3vpg6p5bqim";

13783 configureFlags = [

13784 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13785 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13786 "-fsplitbase" "-f-test-hlint"

13787 ];

13788 libraryHaskellDepends = [

13789 array base bytestring cereal containers old-time template-haskell

13790 text time vector

13791 ];

13792 doCheck = false;

13793 homepage = "http://acid-state.seize.it/safecopy";

13794 description = "Binary serialization with version control";

13795 license = stdenv.lib.licenses.publicDomain;

13796 }) {};

13797 "scientific" = callPackage

13798 ({ mkDerivation, array, base, bytestring, criterion, deepseq

13799 , ghc-prim, hashable, integer-gmp, QuickCheck, smallcheck, tasty

13800 , tasty-ant-xml, tasty-hunit, tasty-quickcheck, tasty-smallcheck

13801 , text

13802 }:

13803 mkDerivation {

13804 pname = "scientific";

13805 version = "0.3.3.8";

13806 sha256 = "0k6f9g3jpwhm52af4zayhdby8xibarn60mpxbb8xxgm78hmdw373";

13807 configureFlags = [

13808 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13809 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13810 "-fsplitbase" "-f-test-hlint"

13811 ];

13812 libraryHaskellDepends = [

13813 array base bytestring deepseq ghc-prim hashable integer-gmp text

13814 ];

13815 testHaskellDepends = [

13816 base bytestring QuickCheck smallcheck tasty tasty-ant-xml

13817 tasty-hunit tasty-quickcheck tasty-smallcheck text

13818 ];

13819 benchmarkHaskellDepends = [

13820 array base bytestring criterion deepseq ghc-prim hashable

13821 integer-gmp text

13822 ];

13823 homepage = "https://github.com/basvandijk/scientific";

13824 description = "Numbers represented using scientific notation";

13825 license = stdenv.lib.licenses.bsd3;

13826 }) {};

13827 "scotty" = callPackage

13828 ({ mkDerivation, aeson, base, blaze-builder, bytestring

13829 , case-insensitive, data-default, hspec-wai, hspec2, http-types

13830 , lifted-base, monad-control, mtl, regex-compat, text, transformers

13831 , transformers-base, wai, wai-extra, warp

13832 }:

13833 mkDerivation {

13834 pname = "scotty";

13835 version = "0.9.0";

13836 sha256 = "0gx00k5w4cs68bh3ciplkwhzh2412y6wqg0qdsslnnsb41l5kb1d";

13837 revision = "2";

13838 editedCabalFile = "0zl0gyc0vp6zjcmw6bz4djqh8dpccbb2aql1sd17pa22v8k7qbpw";

13839 configureFlags = [

13840 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13841 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13842 "-fsplitbase" "-f-test-hlint"

13843 ];

13844 libraryHaskellDepends = [

13845 aeson base blaze-builder bytestring case-insensitive data-default

13846 http-types monad-control mtl regex-compat text transformers

13847 transformers-base wai wai-extra warp

13848 ];

13849 testHaskellDepends = [

13850 base bytestring hspec-wai hspec2 http-types lifted-base text wai

13851 ];

13852 homepage = "https://github.com/scotty-web/scotty";

13853 description = "Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp";

13854 license = stdenv.lib.licenses.bsd3;

13855 }) {};

13856 "scrobble" = callPackage

13857 ({ mkDerivation, base, containers, curl, MissingH, network

13858 , network-uri, old-locale, pureMD5, time, url

13859 }:

13860 mkDerivation {

13861 pname = "scrobble";

13862 version = "0.2.1.1";

13863 sha256 = "161l75bni4fxmh35dfz8r2vgllmmf0s55j9y2xpyskqfj3xc85a7";

13864 configureFlags = [

13865 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13866 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13867 "-fsplitbase" "-f-test-hlint"

13868 ];

13869 isLibrary = true;

13870 isExecutable = true;

13871 libraryHaskellDepends = [

13872 base containers curl MissingH network network-uri old-locale

13873 pureMD5 time url

13874 ];

13875 executableHaskellDepends = [

13876 base containers curl MissingH network network-uri old-locale time

13877 url

13878 ];

13879 description = "Scrobbling server";

13880 license = stdenv.lib.licenses.bsd3;

13881 }) {};

13882 "securemem" = callPackage

13883 ({ mkDerivation, base, byteable, bytestring, ghc-prim }:

13884 mkDerivation {

13885 pname = "securemem";

13886 version = "0.1.7";

13887 sha256 = "14mmis2y9xf3jzmf6s6g7g8ixgbrx99x0b422zv4ix3vpx2lj57r";

13888 configureFlags = [

13889 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13890 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13891 "-fsplitbase" "-f-test-hlint"

13892 ];

13893 libraryHaskellDepends = [ base byteable bytestring ghc-prim ];

13894 homepage = "http://github.com/vincenthz/hs-securemem";

13895 description = "abstraction to an auto scrubbing and const time eq, memory chunk";

13896 license = stdenv.lib.licenses.bsd3;

13897 }) {};

13898 "semigroupoid-extras" = callPackage

13899 ({ mkDerivation, base, semigroupoids }:

13900 mkDerivation {

13901 pname = "semigroupoid-extras";

13902 version = "4.0";

13903 sha256 = "07aa7z4nywcrp9msq83b1pcmryl25yxha89sn5vwlgq40cibcm3g";

13904 configureFlags = [

13905 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13906 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13907 "-fsplitbase" "-f-test-hlint"

13908 ];

13909 libraryHaskellDepends = [ base semigroupoids ];

13910 doHaddock = false;

13911 homepage = "http://github.com/ekmett/semigroupoid-extras";

13912 description = "This package has been absorbed into semigroupoids 4.0";

13913 license = stdenv.lib.licenses.bsd3;

13914 }) {};

13915 "semigroupoids" = callPackage

13916 ({ mkDerivation, base, base-orphans, comonad, containers

13917 , contravariant, distributive, semigroups, transformers

13918 }:

13919 mkDerivation {

13920 pname = "semigroupoids";

13921 version = "4.2";

13922 sha256 = "18zip518f2l2ccmg3hjzy5mq2b8r98crzm10kr77yc4m64w5vac8";

13923 revision = "3";

13924 editedCabalFile = "1nzj1k9g6rfvgpj51hlsl3463hqsl4ckrzy4l3058jqhdx05hd96";

13925 configureFlags = [

13926 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13927 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13928 "-fsplitbase" "-f-test-hlint"

13929 ];

13930 libraryHaskellDepends = [

13931 base base-orphans comonad containers contravariant distributive

13932 semigroups transformers

13933 ];

13934 homepage = "http://github.com/ekmett/semigroupoids";

13935 description = "Semigroupoids: Category sans id";

13936 license = stdenv.lib.licenses.bsd3;

13937 }) {base-orphans = null;};

13938 "semigroups" = callPackage

13939 ({ mkDerivation, base, bytestring, containers, deepseq, hashable

13940 , nats, text, unordered-containers

13941 }:

13942 mkDerivation {

13943 pname = "semigroups";

13944 version = "0.16.2.2";

13945 sha256 = "0mzdv05yhrvnib62mwfwwj66fmyzs3axm0y5sn374ig2r113wzni";

13946 revision = "1";

13947 editedCabalFile = "186lkgxp10h0rncc2fx01lw0cf9pkvrk66rlf2r591ybgiprqz3d";

13948 configureFlags = [

13949 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13950 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13951 "-fsplitbase" "-f-test-hlint"

13952 ];

13953 libraryHaskellDepends = [

13954 base bytestring containers deepseq hashable nats text

13955 unordered-containers

13956 ];

13957 homepage = "http://github.com/ekmett/semigroups/";

13958 description = "Anything that associates";

13959 license = stdenv.lib.licenses.bsd3;

13960 }) {};

13961 "sendfile" = callPackage

13962 ({ mkDerivation, base, bytestring, network }:

13963 mkDerivation {

13964 pname = "sendfile";

13965 version = "0.7.9";

13966 sha256 = "0hnw1ym81cff49dwww19kgbs4s0kpandbvn6h5cml3y0p1nxybqh";

13967 configureFlags = [

13968 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13969 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13970 "-fsplitbase" "-f-test-hlint"

13971 ];

13972 libraryHaskellDepends = [ base bytestring network ];

13973 homepage = "http://hub.darcs.net/stepcut/sendfile";

13974 description = "A portable sendfile library";

13975 license = stdenv.lib.licenses.bsd3;

13976 }) {};

13977 "seqloc" = callPackage

13978 ({ mkDerivation, attoparsec, base, biocore, bytestring, hashable

13979 , QuickCheck, random, unordered-containers, vector

13980 }:

13981 mkDerivation {

13982 pname = "seqloc";

13983 version = "0.6.1.1";

13984 sha256 = "1hsm9y6q0g7ixnqj562a33lmyka4k7f778fndcmn25v4m1myfda4";

13985 configureFlags = [

13986 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

13987 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

13988 "-fsplitbase" "-f-test-hlint"

13989 ];

13990 libraryHaskellDepends = [

13991 attoparsec base biocore bytestring hashable unordered-containers

13992 vector

13993 ];

13994 testHaskellDepends = [

13995 attoparsec base biocore bytestring hashable QuickCheck random

13996 unordered-containers vector

13997 ];

13998 homepage = "http://www.ingolia-lab.org/seqloc-tutorial.html";

13999 description = "Handle sequence locations for bioinformatics";

14000 license = stdenv.lib.licenses.mit;

14001 }) {};

14002 "setenv" = callPackage

14003 ({ mkDerivation, base, unix }:

14004 mkDerivation {

14005 pname = "setenv";

14006 version = "0.1.1.3";

14007 sha256 = "0cnbgrvb9byyahb37zlqrj05rj25v190crgcw8wmlgf0mwwxyn73";

14008 revision = "1";

14009 editedCabalFile = "0ny4g3kjys0hqg41mnwrsymy1bwhl8l169kis4y4fa58sb06m4f5";

14010 configureFlags = [

14011 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14012 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14013 "-fsplitbase" "-f-test-hlint"

14014 ];

14015 libraryHaskellDepends = [ base unix ];

14016 doCheck = false;

14017 description = "A cross-platform library for setting environment variables";

14018 license = stdenv.lib.licenses.mit;

14019 }) {};

14020 "shake" = callPackage

14021 ({ mkDerivation, base, binary, bytestring, deepseq, directory

14022 , extra, filepath, hashable, js-flot, js-jquery, old-time, process

14023 , QuickCheck, random, time, transformers, unix

14024 , unordered-containers, utf8-string

14025 }:

14026 mkDerivation {

14027 pname = "shake";

14028 version = "0.14.3";

14029 sha256 = "1s5xm205k3pvndn21vd0y9mnggrm91psf64mw445r08xasi658vl";

14030 revision = "1";

14031 editedCabalFile = "008fs9qh27jwxnqcp30xxcn8nhab1bv5mni912q6rqlc4avcg5vq";

14032 configureFlags = [

14033 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14034 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14035 "-fsplitbase" "-f-test-hlint"

14036 ];

14037 isLibrary = true;

14038 isExecutable = true;

14039 enableSeparateDataOutput = true;

14040 libraryHaskellDepends = [

14041 base binary bytestring deepseq directory extra filepath hashable

14042 js-flot js-jquery old-time process random time transformers unix

14043 unordered-containers utf8-string

14044 ];

14045 executableHaskellDepends = [

14046 base binary bytestring deepseq directory extra filepath hashable

14047 js-flot js-jquery old-time process random time transformers unix

14048 unordered-containers utf8-string

14049 ];

14050 testHaskellDepends = [

14051 base binary bytestring deepseq directory extra filepath hashable

14052 js-flot js-jquery old-time process QuickCheck random time

14053 transformers unix unordered-containers utf8-string

14054 ];

14055 doCheck = false;

14056 homepage = "http://www.shakebuild.com/";

14057 description = "Build system library, like Make, but more accurate dependencies";

14058 license = stdenv.lib.licenses.bsd3;

14059 }) {};

14060 "shake-language-c" = callPackage

14061 ({ mkDerivation, base, data-default-class, directory, doctest

14062 , fclabels, hspec, process, shake, split, unordered-containers

14063 }:

14064 mkDerivation {

14065 pname = "shake-language-c";

14066 version = "0.6.4";

14067 sha256 = "1wn491jcx78v748dyis7wg3jlg0kff0iv605a6f2ig3j7sxka1yz";

14068 configureFlags = [

14069 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14070 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14071 "-fsplitbase" "-f-test-hlint"

14072 ];

14073 libraryHaskellDepends = [

14074 base data-default-class fclabels process shake split

14075 unordered-containers

14076 ];

14077 testHaskellDepends = [ base directory doctest hspec shake ];

14078 homepage = "https://github.com/samplecount/shake-language-c";

14079 description = "Utilities for cross-compiling with Shake";

14080 license = stdenv.lib.licenses.asl20;

14081 }) {};

14082 "shakespeare" = callPackage

14083 ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring

14084 , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec

14085 , process, system-fileio, system-filepath, template-haskell, text

14086 , time, transformers

14087 }:

14088 mkDerivation {

14089 pname = "shakespeare";

14090 version = "2.0.4.1";

14091 sha256 = "0z3aw13kjknrb0r15jffvc4b2aj89r1zl83ighs2cv318dd89qzi";

14092 revision = "1";

14093 editedCabalFile = "1fflcfxjnb12m8r3hyhy6bhh6g97pjsqjgac0ik11nrsik7ilav6";

14094 configureFlags = [

14095 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14096 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14097 "-fsplitbase" "-f-test-hlint"

14098 ];

14099 libraryHaskellDepends = [

14100 aeson base blaze-html blaze-markup bytestring containers directory

14101 exceptions ghc-prim parsec process system-fileio system-filepath

14102 template-haskell text time transformers

14103 ];

14104 testHaskellDepends = [

14105 aeson base blaze-html blaze-markup bytestring containers directory

14106 exceptions ghc-prim hspec HUnit parsec process system-fileio

14107 system-filepath template-haskell text time transformers

14108 ];

14109 homepage = "http://www.yesodweb.com/book/shakespearean-templates";

14110 description = "A toolkit for making compile-time interpolated templates";

14111 license = stdenv.lib.licenses.mit;

14112 }) {};

14113 "shakespeare-i18n" = callPackage

14114 ({ mkDerivation, base, shakespeare }:

14115 mkDerivation {

14116 pname = "shakespeare-i18n";

14117 version = "1.1.0";

14118 sha256 = "0ahhg9r7d8kdxn0x33bp5p8wmwkh1yvdqhw05yjwif0ky5y9h625";

14119 configureFlags = [

14120 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14121 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14122 "-fsplitbase" "-f-test-hlint"

14123 ];

14124 libraryHaskellDepends = [ base shakespeare ];

14125 doHaddock = false;

14126 homepage = "http://www.yesodweb.com/book/shakespearean-templates";

14127 description = "A type-based approach to internationalization. (deprecated)";

14128 license = stdenv.lib.licenses.mit;

14129 }) {};

14130 "shakespeare-text" = callPackage

14131 ({ mkDerivation, base, shakespeare }:

14132 mkDerivation {

14133 pname = "shakespeare-text";

14134 version = "1.1.0";

14135 sha256 = "18ixixb9aqn630s9wblxcki1gggm4i0fj9752c55p3b42q8h86rc";

14136 configureFlags = [

14137 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14138 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14139 "-fsplitbase" "-f-test-hlint"

14140 ];

14141 libraryHaskellDepends = [ base shakespeare ];

14142 doHaddock = false;

14143 homepage = "http://www.yesodweb.com/book/shakespearean-templates";

14144 description = "Interpolation with quasi-quotation: put variables strings (deprecated)";

14145 license = stdenv.lib.licenses.mit;

14146 }) {};

14147 "shell-conduit" = callPackage

14148 ({ mkDerivation, async, base, bytestring, conduit, conduit-extra

14149 , control-monad-loop, directory, filepath, monad-control, monads-tf

14150 , process, resourcet, semigroups, split, template-haskell, text

14151 , transformers, transformers-base, unix

14152 }:

14153 mkDerivation {

14154 pname = "shell-conduit";

14155 version = "4.5.2";

14156 sha256 = "04kc9gzlqbw3d2pj6qn13pnmmrlmx8nmmj5bvxn7zdmh25nw6ys2";

14157 configureFlags = [

14158 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14159 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14160 "-fsplitbase" "-f-test-hlint"

14161 ];

14162 libraryHaskellDepends = [

14163 async base bytestring conduit conduit-extra control-monad-loop

14164 directory filepath monad-control monads-tf process resourcet

14165 semigroups split template-haskell text transformers

14166 transformers-base unix

14167 ];

14168 homepage = "https://github.com/chrisdone/shell-conduit";

14169 description = "Write shell scripts with Conduit";

14170 license = stdenv.lib.licenses.bsd3;

14171 }) {};

14172 "shelly" = callPackage

14173 ({ mkDerivation, async, base, bytestring, containers, directory

14174 , enclosed-exceptions, exceptions, lifted-async, lifted-base

14175 , monad-control, mtl, process, system-fileio, system-filepath, text

14176 , time, transformers, transformers-base, unix-compat

14177 }:

14178 mkDerivation {

14179 pname = "shelly";

14180 version = "1.5.7";

14181 sha256 = "11ffp8rynyzmsll1izpc3kdzlyy0sx1m7syxn992rzpf7n970ivn";

14182 configureFlags = [

14183 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14184 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14185 "-fsplitbase" "-f-test-hlint"

14186 ];

14187 libraryHaskellDepends = [

14188 async base bytestring containers directory enclosed-exceptions

14189 exceptions lifted-async lifted-base monad-control mtl process

14190 system-fileio system-filepath text time transformers

14191 transformers-base unix-compat

14192 ];

14193 homepage = "https://github.com/yesodweb/Shelly.hs";

14194 description = "shell-like (systems) programming in Haskell";

14195 license = stdenv.lib.licenses.bsd3;

14196 }) {};

14197 "silently" = callPackage

14198 ({ mkDerivation, base, deepseq, directory, nanospec }:

14199 mkDerivation {

14200 pname = "silently";

14201 version = "1.2.4.1";

14202 sha256 = "035dw3zg680ykyz5rqkkrjn51wkznbc4jb45a8l2gh3vgqzgbf52";

14203 configureFlags = [

14204 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14205 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14206 "-fsplitbase" "-f-test-hlint"

14207 ];

14208 libraryHaskellDepends = [ base deepseq directory ];

14209 testHaskellDepends = [ base deepseq directory nanospec ];

14210 homepage = "https://github.com/trystan/silently";

14211 description = "Prevent or capture writing to stdout and other handles";

14212 license = stdenv.lib.licenses.bsd3;

14213 }) {};

14214 "simple-reflect" = callPackage

14215 ({ mkDerivation, base }:

14216 mkDerivation {

14217 pname = "simple-reflect";

14218 version = "0.3.2";

14219 sha256 = "1dpcf6w3cf1sfl9bnlsx04x7aghw029glj5d05qzrsnms2rlw8iq";

14220 configureFlags = [

14221 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14222 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14223 "-fsplitbase" "-f-test-hlint"

14224 ];

14225 libraryHaskellDepends = [ base ];

14226 homepage = "http://twanvl.nl/blog/haskell/simple-reflection-of-expressions";

14227 description = "Simple reflection of expressions containing variables";

14228 license = stdenv.lib.licenses.bsd3;

14229 }) {};

14230 "simple-sendfile" = callPackage

14231 ({ mkDerivation, base, bytestring, conduit, conduit-extra

14232 , directory, hspec, HUnit, network, process, resourcet, unix

14233 }:

14234 mkDerivation {

14235 pname = "simple-sendfile";

14236 version = "0.2.18";

14237 sha256 = "1dc7c4bkcwzfhbm982svi9j6dzxxf0z6pjkdrs23m9bc9g8aly49";

14238 configureFlags = [

14239 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14240 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14241 "-fsplitbase" "-f-test-hlint"

14242 ];

14243 libraryHaskellDepends = [ base bytestring network unix ];

14244 testHaskellDepends = [

14245 base bytestring conduit conduit-extra directory hspec HUnit network

14246 process resourcet unix

14247 ];

14248 doCheck = false;

14249 description = "Cross platform library for the sendfile system call";

14250 license = stdenv.lib.licenses.bsd3;

14251 }) {};

14252 "singletons" = callPackage

14253 ({ mkDerivation, base, Cabal, constraints, containers, filepath

14254 , mtl, process, tasty, tasty-golden, template-haskell, th-desugar

14255 }:

14256 mkDerivation {

14257 pname = "singletons";

14258 version = "1.0";

14259 sha256 = "1rd1728wghhqlg2djd7az8i01rf4i3wwwcnz2v43a39jjvhlklkg";

14260 revision = "1";

14261 editedCabalFile = "03w3qrxgkcnsi5lqyxgd0vizng8l5h02l1nmsh7ywvpik9jpjvm1";

14262 configureFlags = [

14263 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14264 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14265 "-fsplitbase" "-f-test-hlint"

14266 ];

14267 libraryHaskellDepends = [

14268 base containers mtl template-haskell th-desugar

14269 ];

14270 testHaskellDepends = [

14271 base Cabal constraints filepath process tasty tasty-golden

14272 ];

14273 doCheck = false;

14274 homepage = "http://www.cis.upenn.edu/~eir/packages/singletons";

14275 description = "A framework for generating singleton types";

14276 license = stdenv.lib.licenses.bsd3;

14277 }) {};

14278 "siphash" = callPackage

14279 ({ mkDerivation, base, bytestring, cpu, QuickCheck, test-framework

14280 , test-framework-quickcheck2

14281 }:

14282 mkDerivation {

14283 pname = "siphash";

14284 version = "1.0.3";

14285 sha256 = "1wq5dan30ggjgmravy92ylqjvjv1q7mxrmddr7zc8h6aqr0wx0fg";

14286 revision = "1";

14287 editedCabalFile = "1q2dy0ywngm9iv7k6d9gnf860m9hpf62q5qvdzmxw5s629gk4afn";

14288 configureFlags = [

14289 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14290 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14291 "-fsplitbase" "-f-test-hlint"

14292 ];

14293 enableSeparateDataOutput = true;

14294 libraryHaskellDepends = [ base bytestring cpu ];

14295 testHaskellDepends = [

14296 base bytestring QuickCheck test-framework

14297 test-framework-quickcheck2

14298 ];

14299 homepage = "http://github.com/vincenthz/hs-siphash";

14300 description = "siphash: a fast short input PRF";

14301 license = stdenv.lib.licenses.bsd3;

14302 }) {};

14303 "skein" = callPackage

14304 ({ mkDerivation, base, bytestring, cereal, crypto-api, filepath

14305 , hspec, tagged

14306 }:

14307 mkDerivation {

14308 pname = "skein";

14309 version = "1.0.9.2";

14310 sha256 = "1j8bhqm25r9vd4qb4v12g32r0dv6xyhk48cq287wfbzjraayi1gw";

14311 revision = "1";

14312 editedCabalFile = "1awrn0zzz3xk4nh25rw3jkxnjsa8ds4gwmpy217629xg5b73hil2";

14313 configureFlags = [

14314 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14315 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14316 "-fsplitbase" "-f-test-hlint"

14317 ];

14318 libraryHaskellDepends = [

14319 base bytestring cereal crypto-api tagged

14320 ];

14321 testHaskellDepends = [

14322 base bytestring cereal crypto-api filepath hspec tagged

14323 ];

14324 homepage = "https://github.com/meteficha/skein";

14325 description = "Skein, a family of cryptographic hash functions. Includes Skein-MAC as well.";

14326 license = stdenv.lib.licenses.bsd3;

14327 }) {};

14328 "slave-thread" = callPackage

14329 ({ mkDerivation, base, base-prelude, list-t, mmorph

14330 , partial-handler, stm-containers, transformers

14331 }:

14332 mkDerivation {

14333 pname = "slave-thread";

14334 version = "0.1.5";

14335 sha256 = "0qw4c6406hbdnv6i55sh8ps8739szm7rnqjzk6ynm7dfbf3vxhw4";

14336 configureFlags = [

14337 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14338 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14339 "-fsplitbase" "-f-test-hlint"

14340 ];

14341 libraryHaskellDepends = [

14342 base base-prelude list-t mmorph partial-handler stm-containers

14343 transformers

14344 ];

14345 doCheck = false;

14346 homepage = "https://github.com/nikita-volkov/slave-thread";

14347 description = "A principal solution to ghost threads and silent exceptions";

14348 license = stdenv.lib.licenses.mit;

14349 }) {};

14350 "smallcheck" = callPackage

14351 ({ mkDerivation, base, ghc-prim, logict, mtl, pretty }:

14352 mkDerivation {

14353 pname = "smallcheck";

14354 version = "1.1.1";

14355 sha256 = "1ygrabxh40bym3grnzqyfqn96lirnxspb8cmwkkr213239y605sd";

14356 revision = "1";

14357 editedCabalFile = "1ykq0hqs1alw86p0ssa6dhsb1a8d4m6bqwibkhvzcd6c28dq975i";

14358 configureFlags = [

14359 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14360 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14361 "-fsplitbase" "-f-test-hlint"

14362 ];

14363 libraryHaskellDepends = [ base ghc-prim logict mtl pretty ];

14364 homepage = "https://github.com/feuerbach/smallcheck";

14365 description = "A property-based testing library";

14366 license = stdenv.lib.licenses.bsd3;

14367 }) {};

14368 "smtLib" = callPackage

14369 ({ mkDerivation, base, pretty }:

14370 mkDerivation {

14371 pname = "smtLib";

14372 version = "1.0.7";

14373 sha256 = "1jn2790x7g7n6jm5cfgd692n3l6iafyv0zyz40hx8ykcs4jh2rkf";

14374 revision = "1";

14375 editedCabalFile = "13j4kp8cjx20zi6xy55bjdbr39p223s299wgad0xpgch1qz7q7bs";

14376 configureFlags = [

14377 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14378 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14379 "-fsplitbase" "-f-test-hlint"

14380 ];

14381 libraryHaskellDepends = [ base pretty ];

14382 description = "A library for working with the SMTLIB format";

14383 license = stdenv.lib.licenses.bsd3;

14384 }) {};

14385 "snap" = callPackage

14386 ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal

14387 , clientsession, comonad, configurator, containers, directory

14388 , directory-tree, dlist, errors, filepath, hashable, heist, lens

14389 , logict, MonadCatchIO-transformers, mtl, mwc-random, old-time

14390 , pwstore-fast, regex-posix, snap-core, snap-server, stm, syb

14391 , template-haskell, text, time, transformers, unordered-containers

14392 , vector, vector-algorithms, xmlhtml

14393 }:

14394 mkDerivation {

14395 pname = "snap";

14396 version = "0.13.3.2";

14397 sha256 = "1k6sd2ww8zqkbfv4v5ryqwgicx6yprfil8cd5rgdvygyjs88fcrp";

14398 revision = "3";

14399 editedCabalFile = "13r9q0cmfkysvgg3xs64k4ar3wdbpp25hzccphclimfnwvivdzig";

14400 configureFlags = [

14401 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14402 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14403 "-fsplitbase" "-f-test-hlint"

14404 ];

14405 isLibrary = true;

14406 isExecutable = true;

14407 libraryHaskellDepends = [

14408 aeson attoparsec base bytestring cereal clientsession comonad

14409 configurator containers directory directory-tree dlist errors

14410 filepath hashable heist lens logict MonadCatchIO-transformers mtl

14411 mwc-random pwstore-fast regex-posix snap-core snap-server stm syb

14412 text time transformers unordered-containers vector

14413 vector-algorithms xmlhtml

14414 ];

14415 executableHaskellDepends = [

14416 base bytestring containers directory directory-tree filepath

14417 hashable old-time snap-server template-haskell text

14418 ];

14419 homepage = "http://snapframework.com/";

14420 description = "Top-level package for the Snap Web Framework";

14421 license = stdenv.lib.licenses.bsd3;

14422 }) {};

14423 "snap-core" = callPackage

14424 ({ mkDerivation, attoparsec, attoparsec-enumerator, base

14425 , blaze-builder, blaze-builder-enumerator, bytestring

14426 , bytestring-mmap, case-insensitive, containers, deepseq, directory

14427 , enumerator, filepath, hashable, HUnit, MonadCatchIO-transformers

14428 , mtl, random, regex-posix, text, time, unix, unix-compat

14429 , unordered-containers, vector, zlib-enum

14430 }:

14431 mkDerivation {

14432 pname = "snap-core";

14433 version = "0.9.6.4";

14434 sha256 = "0azg5xyiclcir8mlf0aar05jijb0dycp3srzignd192x789y9lvi";

14435 configureFlags = [

14436 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14437 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14438 "-fsplitbase" "-f-test-hlint"

14439 ];

14440 libraryHaskellDepends = [

14441 attoparsec attoparsec-enumerator base blaze-builder

14442 blaze-builder-enumerator bytestring bytestring-mmap

14443 case-insensitive containers deepseq directory enumerator filepath

14444 hashable HUnit MonadCatchIO-transformers mtl random regex-posix

14445 text time unix unix-compat unordered-containers vector zlib-enum

14446 ];

14447 homepage = "http://snapframework.com/";

14448 description = "Snap: A Haskell Web Framework (core interfaces and types)";

14449 license = stdenv.lib.licenses.bsd3;

14450 }) {};

14451 "snap-server" = callPackage

14452 ({ mkDerivation, attoparsec, attoparsec-enumerator, base

14453 , blaze-builder, blaze-builder-enumerator, bytestring

14454 , case-insensitive, containers, enumerator

14455 , MonadCatchIO-transformers, mtl, network, old-locale, snap-core

14456 , text, time, unix, unix-compat

14457 }:

14458 mkDerivation {

14459 pname = "snap-server";

14460 version = "0.9.4.6";

14461 sha256 = "01qfqc63qwq604s5vy0sln7l9zhqndyqbb1y1xf397rrn97xhrpp";

14462 revision = "1";

14463 editedCabalFile = "1gw8apl1bzwbxg3mdapjnh62l0wjnnfdf6x5nkmwliz0ca5kii1j";

14464 configureFlags = [

14465 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14466 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14467 "-fsplitbase" "-f-test-hlint"

14468 ];

14469 libraryHaskellDepends = [

14470 attoparsec attoparsec-enumerator base blaze-builder

14471 blaze-builder-enumerator bytestring case-insensitive containers

14472 enumerator MonadCatchIO-transformers mtl network old-locale

14473 snap-core text time unix unix-compat

14474 ];

14475 homepage = "http://snapframework.com/";

14476 description = "A fast, iteratee-based, epoll-enabled web server for the Snap Framework";

14477 license = stdenv.lib.licenses.bsd3;

14478 }) {};

14479 "snaplet-fay" = callPackage

14480 ({ mkDerivation, aeson, base, bytestring, configurator, directory

14481 , fay, filepath, mtl, snap, snap-core, transformers

14482 }:

14483 mkDerivation {

14484 pname = "snaplet-fay";

14485 version = "0.3.3.11";

14486 sha256 = "18g61qivc49g37zmb4qv2piwlgs572fmngdpsjdhjmrgqn049fjr";

14487 revision = "2";

14488 editedCabalFile = "179y00d47b3rapck7bwkrsmwlw79yk505251bkayx30mmp26llvb";

14489 configureFlags = [

14490 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14491 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14492 "-fsplitbase" "-f-test-hlint"

14493 ];

14494 enableSeparateDataOutput = true;

14495 libraryHaskellDepends = [

14496 aeson base bytestring configurator directory fay filepath mtl snap

14497 snap-core transformers

14498 ];

14499 homepage = "https://github.com/faylang/snaplet-fay";

14500 description = "Fay integration for Snap with request- and pre-compilation";

14501 license = stdenv.lib.licenses.bsd3;

14502 }) {};

14503 "socks" = callPackage

14504 ({ mkDerivation, base, bytestring, cereal, network }:

14505 mkDerivation {

14506 pname = "socks";

14507 version = "0.5.4";

14508 sha256 = "1nmldlwxqasmg359i2aa3a903gi3lmnlspvf12xk49jrg3mf3dg9";

14509 configureFlags = [

14510 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14511 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14512 "-fsplitbase" "-f-test-hlint"

14513 ];

14514 enableSeparateDataOutput = true;

14515 libraryHaskellDepends = [ base bytestring cereal network ];

14516 homepage = "http://github.com/vincenthz/hs-socks";

14517 description = "Socks proxy (version 5) implementation";

14518 license = stdenv.lib.licenses.bsd3;

14519 }) {};

14520 "sodium" = callPackage

14521 ({ mkDerivation, base, containers, mtl }:

14522 mkDerivation {

14523 pname = "sodium";

14524 version = "0.11.0.3";

14525 sha256 = "00qs1calial08a185ma5hm17lmmzig0yjf3710d5ikq1bmrgcqga";

14526 configureFlags = [

14527 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14528 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14529 "-fsplitbase" "-f-test-hlint"

14530 ];

14531 libraryHaskellDepends = [ base containers mtl ];

14532 description = "Sodium Reactive Programming (FRP) System";

14533 license = stdenv.lib.licenses.bsd3;

14534 }) {};

14535 "sourcemap" = callPackage

14536 ({ mkDerivation, aeson, attoparsec, base, bytestring, process, text

14537 , unordered-containers, utf8-string

14538 }:

14539 mkDerivation {

14540 pname = "sourcemap";

14541 version = "0.1.3.0";

14542 sha256 = "1flfsjs2z2zjzqwvmc2vcibvxh19s89ah4s560xr2s5mhdqwbkk5";

14543 revision = "1";

14544 editedCabalFile = "0lr0rb1xln9ya1hycbnby7wl2hmlh4sav4d3l0nn8c3gvd6ng2xa";

14545 configureFlags = [

14546 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14547 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14548 "-fsplitbase" "-f-test-hlint"

14549 ];

14550 libraryHaskellDepends = [

14551 aeson attoparsec base bytestring process text unordered-containers

14552 utf8-string

14553 ];

14554 description = "Implementation of source maps as proposed by Google and Mozilla";

14555 license = stdenv.lib.licenses.bsd3;

14556 }) {};

14557 "speculation" = callPackage

14558 ({ mkDerivation, base, ghc-prim, stm, transformers }:

14559 mkDerivation {

14560 pname = "speculation";

14561 version = "1.5.0.2";

14562 sha256 = "11d4v3x9phayx29lxl4na0b940ax27rjd867f7l9jb284p1rvhp5";

14563 configureFlags = [

14564 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14565 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14566 "-fsplitbase" "-f-test-hlint"

14567 ];

14568 libraryHaskellDepends = [ base ghc-prim stm transformers ];

14569 homepage = "http://github.com/ekmett/speculation";

14570 description = "A framework for safe, programmable, speculative parallelism";

14571 license = stdenv.lib.licenses.bsd3;

14572 }) {};

14573 "sphinx" = callPackage

14574 ({ mkDerivation, base, binary, bytestring, data-binary-ieee754

14575 , network, text, text-icu, xml

14576 }:

14577 mkDerivation {

14578 pname = "sphinx";

14579 version = "0.6.0.1";

14580 sha256 = "1pcm4y9k5lc00805ddv519cx4j3qld2v1dnbckg38n9dyp96wj98";

14581 configureFlags = [

14582 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14583 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14584 "-fsplitbase" "-f-test-hlint"

14585 ];

14586 libraryHaskellDepends = [

14587 base binary bytestring data-binary-ieee754 network text text-icu

14588 xml

14589 ];

14590 homepage = "https://github.com/gregwebs/haskell-sphinx-client";

14591 description = "Haskell bindings to the Sphinx full-text searching daemon";

14592 license = stdenv.lib.licenses.bsd3;

14593 }) {};

14594 "split" = callPackage

14595 ({ mkDerivation, base, QuickCheck }:

14596 mkDerivation {

14597 pname = "split";

14598 version = "0.2.2";

14599 sha256 = "0xa3j0gwr6k5vizxybnzk5fgb3pppgspi6mysnp2gwjp2dbrxkzr";

14600 revision = "2";

14601 editedCabalFile = "1hcmy8npnn0jb3frmkc2is97v55q15vmb1y1mgrjf1l8l6238sq6";

14602 configureFlags = [

14603 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14604 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14605 "-fsplitbase" "-f-test-hlint"

14606 ];

14607 libraryHaskellDepends = [ base ];

14608 testHaskellDepends = [ base QuickCheck ];

14609 description = "Combinator library for splitting lists";

14610 license = stdenv.lib.licenses.bsd3;

14611 }) {};

14612 "spoon" = callPackage

14613 ({ mkDerivation, base, deepseq }:

14614 mkDerivation {

14615 pname = "spoon";

14616 version = "0.3.1";

14617 sha256 = "1m41k0mfy6fpfrv2ym4m5jsjaj9xdfl2iqpppd3c4d0fffv51cxr";

14618 revision = "1";

14619 editedCabalFile = "09s5jjcsg4g4qxchq9g2l4i9d5zh3rixpkbiysqcgl69kj8mwv74";

14620 configureFlags = [

14621 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14622 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14623 "-fsplitbase" "-f-test-hlint"

14624 ];

14625 libraryHaskellDepends = [ base deepseq ];

14626 description = "Catch errors thrown from pure computations";

14627 license = stdenv.lib.licenses.bsd3;

14628 }) {};

14629 "sqlite-simple" = callPackage

14630 ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder

14631 , blaze-textual, bytestring, containers, direct-sqlite, HUnit, text

14632 , time, transformers

14633 }:

14634 mkDerivation {

14635 pname = "sqlite-simple";

14636 version = "0.4.8.0";

14637 sha256 = "098d1s80wlvsp307422f79bm3a9knvgw5ni6jap62fl4rpa7fsmz";

14638 configureFlags = [

14639 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14640 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14641 "-fsplitbase" "-f-test-hlint"

14642 ];

14643 libraryHaskellDepends = [

14644 attoparsec base blaze-builder blaze-textual bytestring containers

14645 direct-sqlite text time transformers

14646 ];

14647 testHaskellDepends = [

14648 base base16-bytestring bytestring direct-sqlite HUnit text time

14649 ];

14650 homepage = "http://github.com/nurpax/sqlite-simple";

14651 description = "Mid-Level SQLite client library";

14652 license = stdenv.lib.licenses.bsd3;

14653 }) {};

14654 "stackage" = callPackage

14655 ({ mkDerivation, aeson, async, base, bytestring, Cabal

14656 , classy-prelude-conduit, conduit-extra, containers

14657 , data-default-class, directory, filepath, hspec, http-client

14658 , http-client-tls, mono-traversable, mtl, old-locale, process

14659 , QuickCheck, semigroups, stm, streaming-commons, system-fileio

14660 , system-filepath, tar, temporary, text, time, transformers

14661 , unix-compat, utf8-string, xml-conduit, yaml, zlib

14662 }:

14663 mkDerivation {

14664 pname = "stackage";

14665 version = "0.3.1";

14666 sha256 = "1x4618asx2pwzk5g3alcjg535qybq3632a6w68wjkfwpl3dfcn91";

14667 configureFlags = [

14668 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14669 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14670 "-fsplitbase" "-f-test-hlint"

14671 ];

14672 isLibrary = true;

14673 isExecutable = true;

14674 libraryHaskellDepends = [

14675 aeson async base bytestring Cabal classy-prelude-conduit

14676 conduit-extra containers data-default-class directory filepath

14677 http-client http-client-tls mono-traversable mtl old-locale process

14678 semigroups stm streaming-commons system-fileio system-filepath tar

14679 temporary text time transformers unix-compat utf8-string

14680 xml-conduit yaml zlib

14681 ];

14682 executableHaskellDepends = [ base ];

14683 testHaskellDepends = [

14684 base Cabal classy-prelude-conduit containers hspec http-client

14685 http-client-tls QuickCheck text yaml

14686 ];

14687 doCheck = false;

14688 homepage = "https://github.com/fpco/stackage";

14689 description = "\"Stable Hackage,\" tools for creating a vetted set of packages from Hackage";

14690 license = stdenv.lib.licenses.mit;

14691 }) {};

14692 "stateref" = callPackage

14693 ({ mkDerivation, base, mtl, stm }:

14694 mkDerivation {

14695 pname = "stateref";

14696 version = "0.3";

14697 sha256 = "0hdpw6g255lj7jjvgqwhjdpzmka546vda5qjvry8gjj6nfm91lvx";

14698 configureFlags = [

14699 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14700 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14701 "-fsplitbase" "-f-test-hlint"

14702 ];

14703 libraryHaskellDepends = [ base mtl stm ];

14704 homepage = "http://code.haskell.org/~mokus/stateref/";

14705 description = "Abstraction for things that work like IORef";

14706 license = stdenv.lib.licenses.publicDomain;

14707 }) {};

14708 "statestack" = callPackage

14709 ({ mkDerivation, base, mtl, transformers }:

14710 mkDerivation {

14711 pname = "statestack";

14712 version = "0.2.0.3";

14713 sha256 = "0w5vw8jmnwbfyma4a3ggdm9jvxf3c18kpwbvcmvr5szifaqv9sgx";

14714 configureFlags = [

14715 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14716 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14717 "-fsplitbase" "-f-test-hlint"

14718 ];

14719 libraryHaskellDepends = [ base mtl transformers ];

14720 description = "Simple State-like monad transformer with saveable and restorable state";

14721 license = stdenv.lib.licenses.bsd3;

14722 }) {};

14723 "statistics" = callPackage

14724 ({ mkDerivation, aeson, base, binary, deepseq, erf, HUnit, ieee754

14725 , math-functions, monad-par, mwc-random, primitive, QuickCheck

14726 , test-framework, test-framework-hunit, test-framework-quickcheck2

14727 , vector, vector-algorithms, vector-binary-instances

14728 }:

14729 mkDerivation {

14730 pname = "statistics";

14731 version = "0.13.2.3";

14732 sha256 = "1gbghzbacfrm7vn24ssx7wz9sycafxk9b306zm6cdlsr954v296n";

14733 configureFlags = [

14734 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14735 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14736 "-fsplitbase" "-f-test-hlint"

14737 ];

14738 libraryHaskellDepends = [

14739 aeson base binary deepseq erf math-functions monad-par mwc-random

14740 primitive vector vector-algorithms vector-binary-instances

14741 ];

14742 testHaskellDepends = [

14743 base binary erf HUnit ieee754 math-functions mwc-random primitive

14744 QuickCheck test-framework test-framework-hunit

14745 test-framework-quickcheck2 vector vector-algorithms

14746 ];

14747 doCheck = false;

14748 homepage = "https://github.com/bos/statistics";

14749 description = "A library of statistical types, data, and functions";

14750 license = stdenv.lib.licenses.bsd3;

14751 }) {};

14752 "statistics-linreg" = callPackage

14753 ({ mkDerivation, base, MonadRandom, random, random-shuffle, safe

14754 , statistics, vector

14755 }:

14756 mkDerivation {

14757 pname = "statistics-linreg";

14758 version = "0.3";

14759 sha256 = "02c9xrd3b8iy7bwgsf1r06smi88k3sgpqv2ivr782wl0dcbc4wv2";

14760 configureFlags = [

14761 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14762 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14763 "-fsplitbase" "-f-test-hlint"

14764 ];

14765 libraryHaskellDepends = [

14766 base MonadRandom random random-shuffle safe statistics vector

14767 ];

14768 homepage = "http://github.com/alpmestan/statistics-linreg";

14769 description = "Linear regression between two samples, based on the 'statistics' package";

14770 license = stdenv.lib.licenses.mit;

14771 }) {};

14772 "stm" = callPackage

14773 ({ mkDerivation, array, base }:

14774 mkDerivation {

14775 pname = "stm";

14776 version = "2.4.4";

14777 sha256 = "0gc8zvdijp3rwmidkpxv76b4i0dc8dw6nbd92rxl4vxl0655iysx";

14778 configureFlags = [

14779 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14780 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14781 "-fsplitbase" "-f-test-hlint"

14782 ];

14783 libraryHaskellDepends = [ array base ];

14784 description = "Software Transactional Memory";

14785 license = stdenv.lib.licenses.bsd3;

14786 }) {};

14787 "stm-chans" = callPackage

14788 ({ mkDerivation, base, stm }:

14789 mkDerivation {

14790 pname = "stm-chans";

14791 version = "3.0.0.2";

14792 sha256 = "1zsa092yjxsdq8nm2yqagdfpip3i3ff3xdwvys99ns7ridxbyynh";

14793 configureFlags = [

14794 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14795 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14796 "-fsplitbase" "-f-test-hlint"

14797 ];

14798 libraryHaskellDepends = [ base stm ];

14799 homepage = "http://code.haskell.org/~wren/";

14800 description = "Additional types of channels for STM";

14801 license = stdenv.lib.licenses.bsd3;

14802 }) {};

14803 "stm-conduit" = callPackage

14804 ({ mkDerivation, async, base, cereal, cereal-conduit, conduit

14805 , conduit-extra, directory, HUnit, lifted-async, lifted-base

14806 , monad-control, monad-loops, QuickCheck, resourcet, stm, stm-chans

14807 , test-framework, test-framework-hunit, test-framework-quickcheck2

14808 , transformers

14809 }:

14810 mkDerivation {

14811 pname = "stm-conduit";

14812 version = "2.5.4";

14813 sha256 = "1pwsv9724b6g80l53wwziv2sajaxc2mwl3mxldpzd0v48zaajflk";

14814 configureFlags = [

14815 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14816 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14817 "-fsplitbase" "-f-test-hlint"

14818 ];

14819 libraryHaskellDepends = [

14820 async base cereal cereal-conduit conduit conduit-extra directory

14821 lifted-async lifted-base monad-control monad-loops resourcet stm

14822 stm-chans transformers

14823 ];

14824 testHaskellDepends = [

14825 base conduit directory HUnit QuickCheck resourcet stm stm-chans

14826 test-framework test-framework-hunit test-framework-quickcheck2

14827 transformers

14828 ];

14829 homepage = "https://github.com/wowus/stm-conduit";

14830 description = "Introduces conduits to channels, and promotes using conduits concurrently";

14831 license = stdenv.lib.licenses.bsd3;

14832 }) {};

14833 "stm-containers" = callPackage

14834 ({ mkDerivation, base-prelude, focus, hashable, list-t, loch-th

14835 , placeholders, primitive, transformers

14836 }:

14837 mkDerivation {

14838 pname = "stm-containers";

14839 version = "0.2.8";

14840 sha256 = "0dqnhi99bq093zb815q8l0yhkvm0r27h230hcjmvcp01934xga0x";

14841 configureFlags = [

14842 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14843 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14844 "-fsplitbase" "-f-test-hlint"

14845 ];

14846 libraryHaskellDepends = [

14847 base-prelude focus hashable list-t loch-th placeholders primitive

14848 transformers

14849 ];

14850 doCheck = false;

14851 homepage = "https://github.com/nikita-volkov/stm-containers";

14852 description = "Containers for STM";

14853 license = stdenv.lib.licenses.mit;

14854 }) {};

14855 "stm-stats" = callPackage

14856 ({ mkDerivation, base, containers, stm, template-haskell, time }:

14857 mkDerivation {

14858 pname = "stm-stats";

14859 version = "0.2.0.0";

14860 sha256 = "0i8ky2l8lvh7nymxglvbifp0ylbyjw20p75avzb51zpzx6qkjkqa";

14861 configureFlags = [

14862 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14863 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14864 "-fsplitbase" "-f-test-hlint"

14865 ];

14866 libraryHaskellDepends = [

14867 base containers stm template-haskell time

14868 ];

14869 description = "retry statistics for STM transactions";

14870 license = stdenv.lib.licenses.bsd3;

14871 }) {};

14872 "storable-complex" = callPackage

14873 ({ mkDerivation, base }:

14874 mkDerivation {

14875 pname = "storable-complex";

14876 version = "0.2.2";

14877 sha256 = "01kwwkpbfjrv26vj83cd92px5qbq1bpgxj0r45534aksqhany1xb";

14878 configureFlags = [

14879 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14880 "-f-instanceinbase" "-fnetwork-uri" "-fnew-base" "-fold-locale"

14881 "-fsmall_base" "-fsplitbase" "-f-test-hlint"

14882 ];

14883 libraryHaskellDepends = [ base ];

14884 homepage = "https://github.com/cartazio/storable-complex";

14885 description = "Storable instance for Complex";

14886 license = stdenv.lib.licenses.bsd3;

14887 }) {};

14888 "storable-endian" = callPackage

14889 ({ mkDerivation, base, byteorder }:

14890 mkDerivation {

14891 pname = "storable-endian";

14892 version = "0.2.5";

14893 sha256 = "04j1nk0wga4dqrqvhm8yd9h9194db1n3yrnhg8s3gsc0jk7yw1p2";

14894 configureFlags = [

14895 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14896 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14897 "-fsplitbase" "-f-test-hlint"

14898 ];

14899 libraryHaskellDepends = [ base byteorder ];

14900 description = "Storable instances with endianness";

14901 license = stdenv.lib.licenses.bsd3;

14902 }) {};

14903 "streaming-commons" = callPackage

14904 ({ mkDerivation, array, async, base, blaze-builder, bytestring

14905 , criterion, deepseq, directory, hspec, network, process

14906 , QuickCheck, random, stm, text, transformers, unix, zlib

14907 }:

14908 mkDerivation {

14909 pname = "streaming-commons";

14910 version = "0.1.10.0";

14911 sha256 = "15bsjprj3xr7bcqskgjs9c1pgy1yq56579qj4r4wk1ccg3kqfw8q";

14912 configureFlags = [

14913 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14914 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14915 "-fsplitbase" "-f-test-hlint"

14916 ];

14917 libraryHaskellDepends = [

14918 array base blaze-builder bytestring directory network process

14919 random stm text transformers unix zlib

14920 ];

14921 testHaskellDepends = [

14922 array async base blaze-builder bytestring deepseq hspec network

14923 QuickCheck text unix zlib

14924 ];

14925 benchmarkHaskellDepends = [

14926 base blaze-builder bytestring criterion deepseq text

14927 ];

14928 homepage = "https://github.com/fpco/streaming-commons";

14929 description = "Common lower-level functions needed by various streaming data libraries";

14930 license = stdenv.lib.licenses.mit;

14931 }) {};

14932 "streams" = callPackage

14933 ({ mkDerivation, adjunctions, base, comonad, distributive

14934 , semigroupoids, semigroups

14935 }:

14936 mkDerivation {

14937 pname = "streams";

14938 version = "3.2";

14939 sha256 = "1pms4wiispnpzysq44fcvspdxmbwk47rfcpcyshnnhpw7c7qngni";

14940 revision = "1";

14941 editedCabalFile = "0lrdskf575kdlm7rh99g49yyj3ynkg9gzdcdfwf4pjy7gm49sj5g";

14942 configureFlags = [

14943 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14944 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14945 "-fsplitbase" "-f-test-hlint"

14946 ];

14947 libraryHaskellDepends = [

14948 adjunctions base comonad distributive semigroupoids semigroups

14949 ];

14950 homepage = "http://github.com/ekmett/streams/issues";

14951 description = "Various Haskell 2010 stream comonads";

14952 license = stdenv.lib.licenses.bsd3;

14953 }) {};

14954 "strict" = callPackage

14955 ({ mkDerivation, array, base }:

14956 mkDerivation {

14957 pname = "strict";

14958 version = "0.3.2";

14959 sha256 = "08cjajqz9h47fkq98mlf3rc8n5ghbmnmgn8pfsl3bdldjdkmmlrc";

14960 configureFlags = [

14961 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14962 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14963 "-fsplitbase" "-f-test-hlint"

14964 ];

14965 libraryHaskellDepends = [ array base ];

14966 homepage = "http://www.cse.unsw.edu.au/~rl/code/strict.html";

14967 description = "Strict data types and String IO";

14968 license = stdenv.lib.licenses.bsd3;

14969 }) {};

14970 "stringable" = callPackage

14971 ({ mkDerivation, base, bytestring, system-filepath, text }:

14972 mkDerivation {

14973 pname = "stringable";

14974 version = "0.1.3";

14975 sha256 = "10jsvbiqbmnbipv1566k5mqkpgfyrzbk8m7b18rqjb5m3qg9dbz7";

14976 configureFlags = [

14977 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14978 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14979 "-fsplitbase" "-f-test-hlint"

14980 ];

14981 libraryHaskellDepends = [ base bytestring system-filepath text ];

14982 description = "A Stringable type class, in the spirit of Foldable and Traversable";

14983 license = stdenv.lib.licenses.mit;

14984 }) {};

14985 "stringbuilder" = callPackage

14986 ({ mkDerivation, base, hspec, QuickCheck }:

14987 mkDerivation {

14988 pname = "stringbuilder";

14989 version = "0.5.0";

14990 sha256 = "1ap95xphqnrhv64c2a137wqslkdmb2jjd9ldb17gs1pw48k8hrl9";

14991 configureFlags = [

14992 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

14993 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

14994 "-fsplitbase" "-f-test-hlint"

14995 ];

14996 libraryHaskellDepends = [ base ];

14997 testHaskellDepends = [ base hspec QuickCheck ];

14998 description = "A writer monad for multi-line string literals";

14999 license = stdenv.lib.licenses.mit;

15000 }) {};

15001 "stringprep" = callPackage

15002 ({ mkDerivation, base, containers, QuickCheck, tasty

15003 , tasty-quickcheck, tasty-th, text, text-icu

15004 }:

15005 mkDerivation {

15006 pname = "stringprep";

15007 version = "1.0.0";

15008 sha256 = "0ha4cvzdppd514xh9315v3nvrn1q4xd74gifdqpszw98hj2mw0b0";

15009 configureFlags = [

15010 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15011 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15012 "-fsplitbase" "-f-test-hlint"

15013 ];

15014 libraryHaskellDepends = [ base containers text text-icu ];

15015 testHaskellDepends = [

15016 base containers QuickCheck tasty tasty-quickcheck tasty-th text

15017 text-icu

15018 ];

15019 description = "Implements the \"StringPrep\" algorithm";

15020 license = stdenv.lib.licenses.bsd3;

15021 }) {};

15022 "stringsearch" = callPackage

15023 ({ mkDerivation, array, base, bytestring, containers }:

15024 mkDerivation {

15025 pname = "stringsearch";

15026 version = "0.3.6.6";

15027 sha256 = "0jpy9xjcjdbpi3wk6mg7xwd7wfi2mma70p97v1ij5i8bj9qijpr9";

15028 configureFlags = [

15029 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15030 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15031 "-fsplitbase" "-f-test-hlint"

15032 ];

15033 libraryHaskellDepends = [ array base bytestring containers ];

15034 homepage = "https://bitbucket.org/dafis/stringsearch";

15035 description = "Fast searching, splitting and replacing of ByteStrings";

15036 license = stdenv.lib.licenses.bsd3;

15037 }) {};

15038 "stylish-haskell" = callPackage

15039 ({ mkDerivation, aeson, base, bytestring, cmdargs, containers

15040 , directory, filepath, haskell-src-exts, HUnit, mtl, strict, syb

15041 , test-framework, test-framework-hunit, yaml

15042 }:

15043 mkDerivation {

15044 pname = "stylish-haskell";

15045 version = "0.5.11.2";

15046 sha256 = "1rbr1vkrlbvqijhrqq3f1dq8vn0q12832rlkbynmnknn6a682n8x";

15047 configureFlags = [

15048 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15049 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15050 "-fsplitbase" "-f-test-hlint"

15051 ];

15052 isLibrary = true;

15053 isExecutable = true;

15054 enableSeparateDataOutput = true;

15055 libraryHaskellDepends = [

15056 aeson base bytestring containers directory filepath

15057 haskell-src-exts mtl syb yaml

15058 ];

15059 executableHaskellDepends = [

15060 aeson base bytestring cmdargs containers directory filepath

15061 haskell-src-exts mtl strict syb yaml

15062 ];

15063 testHaskellDepends = [

15064 aeson base bytestring cmdargs containers directory filepath

15065 haskell-src-exts HUnit mtl syb test-framework test-framework-hunit

15066 yaml

15067 ];

15068 homepage = "https://github.com/jaspervdj/stylish-haskell";

15069 description = "Haskell code prettifier";

15070 license = stdenv.lib.licenses.bsd3;

15071 }) {};

15072 "syb" = callPackage

15073 ({ mkDerivation, base, containers, HUnit, mtl }:

15074 mkDerivation {

15075 pname = "syb";

15076 version = "0.4.4";

15077 sha256 = "11sc9kmfvcn9bfxf227fgmny502z2h9xs3z0m9ak66lk0dw6f406";

15078 revision = "1";

15079 editedCabalFile = "11ibrl8n03gf6fhsnjk51csyd1l8qphwhr8sr73pa8qcz8zycrj0";

15080 configureFlags = [

15081 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15082 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15083 "-fsplitbase" "-f-test-hlint"

15084 ];

15085 libraryHaskellDepends = [ base ];

15086 testHaskellDepends = [ base containers HUnit mtl ];

15087 homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB";

15088 description = "Scrap Your Boilerplate";

15089 license = stdenv.lib.licenses.bsd3;

15090 }) {};

15091 "syb-with-class" = callPackage

15092 ({ mkDerivation, array, base, bytestring, containers

15093 , template-haskell

15094 }:

15095 mkDerivation {

15096 pname = "syb-with-class";

15097 version = "0.6.1.5";

15098 sha256 = "1gn4p92jabgvbk7bg1nzjimyfzznl800bi9hw4ssvc7jqqnyw5zn";

15099 configureFlags = [

15100 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15101 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15102 "-fsplitbase" "-f-test-hlint"

15103 ];

15104 libraryHaskellDepends = [

15105 array base bytestring containers template-haskell

15106 ];

15107 description = "Scrap Your Boilerplate With Class";

15108 license = stdenv.lib.licenses.bsd3;

15109 }) {};

15110 "system-canonicalpath" = callPackage

15111 ({ mkDerivation, base, basic-prelude, directory, system-filepath

15112 , text

15113 }:

15114 mkDerivation {

15115 pname = "system-canonicalpath";

15116 version = "0.2.3.0";

15117 sha256 = "02gvybjd9ka0pks2jlv5m1h46wibkqswf7ifr5bkipv284ma2ycz";

15118 configureFlags = [

15119 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15120 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15121 "-fsplitbase" "-f-test-hlint"

15122 ];

15123 libraryHaskellDepends = [

15124 base basic-prelude directory system-filepath text

15125 ];

15126 homepage = "https://github.com/d12frosted/CanonicalPath";

15127 description = "Abstract data type for canonical paths with pretty operations";

15128 license = stdenv.lib.licenses.mit;

15129 }) {};

15130 "system-fileio" = callPackage

15131 ({ mkDerivation, base, bytestring, chell, system-filepath

15132 , temporary, text, time, transformers, unix

15133 }:

15134 mkDerivation {

15135 pname = "system-fileio";

15136 version = "0.3.16.2";

15137 sha256 = "17mk1crlgrh9c9lfng6a2fdk49m2mbkkdlq5iysl1rzwkn12mmkd";

15138 configureFlags = [

15139 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15140 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15141 "-fsplitbase" "-f-test-hlint"

15142 ];

15143 libraryHaskellDepends = [

15144 base bytestring system-filepath text time unix

15145 ];

15146 testHaskellDepends = [

15147 base bytestring chell system-filepath temporary text time

15148 transformers unix

15149 ];

15150 homepage = "https://github.com/fpco/haskell-filesystem";

15151 description = "Consistent filesystem interaction across GHC versions";

15152 license = stdenv.lib.licenses.mit;

15153 }) {};

15154 "system-filepath" = callPackage

15155 ({ mkDerivation, base, bytestring, chell, chell-quickcheck, deepseq

15156 , QuickCheck, text

15157 }:

15158 mkDerivation {

15159 pname = "system-filepath";

15160 version = "0.4.13.2";

15161 sha256 = "0nmzahybk7mijq6dxcp2hr5mh5hlmz3q1dg1d31b5saazfnsicsj";

15162 configureFlags = [

15163 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15164 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15165 "-fsplitbase" "-f-test-hlint"

15166 ];

15167 libraryHaskellDepends = [ base bytestring deepseq text ];

15168 testHaskellDepends = [

15169 base bytestring chell chell-quickcheck QuickCheck text

15170 ];

15171 doCheck = false;

15172 homepage = "https://github.com/fpco/haskell-filesystem";

15173 description = "High-level, byte-based file and directory path manipulations";

15174 license = stdenv.lib.licenses.mit;

15175 }) {};

15176 "system-posix-redirect" = callPackage

15177 ({ mkDerivation, base, bytestring, unix }:

15178 mkDerivation {

15179 pname = "system-posix-redirect";

15180 version = "1.1.0.1";

15181 sha256 = "1wkfz898d3607xnx779l1k1qc8i2k63ixg47542r45scwq8m0lsk";

15182 configureFlags = [

15183 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15184 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15185 "-fsplitbase" "-f-test-hlint"

15186 ];

15187 libraryHaskellDepends = [ base bytestring unix ];

15188 description = "A toy module to temporarily redirect a program's stdout";

15189 license = stdenv.lib.licenses.bsd3;

15190 }) {};

15191 "tabular" = callPackage

15192 ({ mkDerivation, base, csv, html, mtl }:

15193 mkDerivation {

15194 pname = "tabular";

15195 version = "0.2.2.7";

15196 sha256 = "1ysgq7rrks7f98nnvxil8xz1q27hxdgz4szbjhqwzbwd209dmy0k";

15197 configureFlags = [

15198 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15199 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15200 "-fsplitbase" "-f-test-hlint"

15201 ];

15202 libraryHaskellDepends = [ base csv html mtl ];

15203 homepage = "http://hub.darcs.net/kowey/tabular";

15204 description = "Two-dimensional data tables with rendering functions";

15205 license = stdenv.lib.licenses.bsd3;

15206 }) {};

15207 "tagged" = callPackage

15208 ({ mkDerivation, base }:

15209 mkDerivation {

15210 pname = "tagged";

15211 version = "0.7.3";

15212 sha256 = "016bzws7w09xhyyqiz56ahlf7zhagihn370ga0083fgv172lym7b";

15213 configureFlags = [

15214 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15215 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15216 "-fsplitbase" "-f-test-hlint"

15217 ];

15218 libraryHaskellDepends = [ base ];

15219 homepage = "http://github.com/ekmett/tagged";

15220 description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments";

15221 license = stdenv.lib.licenses.bsd3;

15222 }) {};

15223 "tagshare" = callPackage

15224 ({ mkDerivation, base, containers, mtl }:

15225 mkDerivation {

15226 pname = "tagshare";

15227 version = "0.0";

15228 sha256 = "1q3chp1rmwmxa8rxv7548wsvbqbng6grrnv1587p08385sp4ncfj";

15229 configureFlags = [

15230 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15231 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15232 "-fsplitbase" "-f-test-hlint"

15233 ];

15234 libraryHaskellDepends = [ base containers mtl ];

15235 description = "TagShare - explicit sharing with tags";

15236 license = stdenv.lib.licenses.bsd3;

15237 }) {};

15238 "tagsoup" = callPackage

15239 ({ mkDerivation, base, bytestring, containers, text }:

15240 mkDerivation {

15241 pname = "tagsoup";

15242 version = "0.13.3";

15243 sha256 = "13b6zy6346r3cxhaivys84fnxarg8wbv7r2znazfjdkqil8n5a1j";

15244 configureFlags = [

15245 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15246 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15247 "-fsplitbase" "-f-test-hlint"

15248 ];

15249 isLibrary = true;

15250 isExecutable = true;

15251 libraryHaskellDepends = [ base bytestring containers text ];

15252 homepage = "http://community.haskell.org/~ndm/tagsoup/";

15253 description = "Parsing and extracting information from (possibly malformed) HTML/XML documents";

15254 license = stdenv.lib.licenses.bsd3;

15255 }) {};

15256 "tagstream-conduit" = callPackage

15257 ({ mkDerivation, attoparsec, base, blaze-builder, bytestring

15258 , case-insensitive, conduit, conduit-extra, data-default, hspec

15259 , HUnit, QuickCheck, resourcet, text, transformers, xml-conduit

15260 }:

15261 mkDerivation {

15262 pname = "tagstream-conduit";

15263 version = "0.5.5.3";

15264 sha256 = "1arlf7qil9bzcqykda8yyrnncm29jsfjvz5kbcdrbbhqpbqfi5mj";

15265 configureFlags = [

15266 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15267 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15268 "-fsplitbase" "-f-test-hlint"

15269 ];

15270 libraryHaskellDepends = [

15271 attoparsec base blaze-builder bytestring case-insensitive conduit

15272 conduit-extra data-default resourcet text transformers xml-conduit

15273 ];

15274 testHaskellDepends = [

15275 base bytestring conduit hspec HUnit QuickCheck resourcet text

15276 ];

15277 homepage = "http://github.com/yihuang/tagstream-conduit";

15278 description = "streamlined html tag parser";

15279 license = stdenv.lib.licenses.bsd3;

15280 }) {};

15281 "tar" = callPackage

15282 ({ mkDerivation, base, bytestring, directory, filepath, time }:

15283 mkDerivation {

15284 pname = "tar";

15285 version = "0.4.1.0";

15286 sha256 = "05875pc5ns1fsbl9qgr8sqh29xl4mhvj0pwsa9z4afxv6h6328bm";

15287 configureFlags = [

15288 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15289 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-f-old-time"

15290 "-fsmall_base" "-fsplitbase" "-f-test-hlint"

15291 ];

15292 libraryHaskellDepends = [

15293 base bytestring directory filepath time

15294 ];

15295 description = "Reading, writing and manipulating \".tar\" archive files.";

15296 license = stdenv.lib.licenses.bsd3;

15297 }) {};

15298 "tardis" = callPackage

15299 ({ mkDerivation, base, mtl }:

15300 mkDerivation {

15301 pname = "tardis";

15302 version = "0.3.0.0";

15303 sha256 = "15f88b5qg4v1ah60y0jxkww9n6z7gvnkslx4inckh6m6c7yvj8k6";

15304 configureFlags = [

15305 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15306 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15307 "-fsplitbase" "-f-test-hlint"

15308 ];

15309 libraryHaskellDepends = [ base mtl ];

15310 homepage = "https://github.com/DanBurton/tardis";

15311 description = "Bidirectional state monad transformer";

15312 license = stdenv.lib.licenses.bsd3;

15313 }) {};

15314 "tasty" = callPackage

15315 ({ mkDerivation, ansi-terminal, async, base, containers, deepseq

15316 , mtl, optparse-applicative, regex-tdfa-rc, stm, tagged, time

15317 , unbounded-delays

15318 }:

15319 mkDerivation {

15320 pname = "tasty";

15321 version = "0.10.1";

15322 sha256 = "1l8ah7018f3m8css56h59fcly1jhanm5wd0hbgm8mg6pn7rrjml5";

15323 revision = "2";

15324 editedCabalFile = "0xi507m5w8dbg8hvsaiy0fzsm96l2j5b30kw860la7lkjb2h69wd";

15325 configureFlags = [

15326 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15327 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15328 "-fsplitbase" "-f-test-hlint"

15329 ];

15330 libraryHaskellDepends = [

15331 ansi-terminal async base containers deepseq mtl

15332 optparse-applicative regex-tdfa-rc stm tagged time unbounded-delays

15333 ];

15334 homepage = "http://documentup.com/feuerbach/tasty";

15335 description = "Modern and extensible testing framework";

15336 license = stdenv.lib.licenses.mit;

15337 }) {};

15338 "tasty-ant-xml" = callPackage

15339 ({ mkDerivation, base, containers, generic-deriving, ghc-prim, mtl

15340 , stm, tagged, tasty, transformers, xml

15341 }:

15342 mkDerivation {

15343 pname = "tasty-ant-xml";

15344 version = "1.0.1";

15345 sha256 = "1wb9lm9rbk46g9cm2lpcrzh59zpcy270p824agg61bj1xb9jymsc";

15346 configureFlags = [

15347 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15348 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15349 "-fsplitbase" "-f-test-hlint"

15350 ];

15351 libraryHaskellDepends = [

15352 base containers generic-deriving ghc-prim mtl stm tagged tasty

15353 transformers xml

15354 ];

15355 homepage = "http://github.com/ocharles/tasty-ant-xml";

15356 description = "Render tasty output to XML for Jenkins";

15357 license = stdenv.lib.licenses.bsd3;

15358 }) {};

15359 "tasty-golden" = callPackage

15360 ({ mkDerivation, async, base, bytestring, containers, deepseq

15361 , directory, filepath, mtl, optparse-applicative, process, tagged

15362 , tasty, tasty-hunit, temporary-rc

15363 }:

15364 mkDerivation {

15365 pname = "tasty-golden";

15366 version = "2.2.2.4";

15367 sha256 = "096c4h306r4z7wq8nm94mwmdndm0mwd6hhiqf77iilpdndasrl1c";

15368 revision = "1";

15369 editedCabalFile = "0s59gkp12p7wkkd5dk5k1bg3k8b7q98lxsjknw1bi8a22gx055n2";

15370 configureFlags = [

15371 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15372 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15373 "-fsplitbase" "-f-test-hlint"

15374 ];

15375 libraryHaskellDepends = [

15376 async base bytestring containers deepseq directory filepath mtl

15377 optparse-applicative process tagged tasty temporary-rc

15378 ];

15379 testHaskellDepends = [

15380 base directory filepath process tasty tasty-hunit temporary-rc

15381 ];

15382 homepage = "https://github.com/feuerbach/tasty-golden";

15383 description = "Golden tests support for tasty";

15384 license = stdenv.lib.licenses.mit;

15385 }) {};

15386 "tasty-hunit" = callPackage

15387 ({ mkDerivation, base, tasty }:

15388 mkDerivation {

15389 pname = "tasty-hunit";

15390 version = "0.9.2";

15391 sha256 = "08qnxaw34wfnzi9irs1jd4d0zczqm3k5ffkd4zwhkz0dflmgq7mf";

15392 configureFlags = [

15393 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15394 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15395 "-fsplitbase" "-f-test-hlint"

15396 ];

15397 libraryHaskellDepends = [ base tasty ];

15398 homepage = "http://documentup.com/feuerbach/tasty";

15399 description = "HUnit support for the Tasty test framework";

15400 license = stdenv.lib.licenses.mit;

15401 }) {};

15402 "tasty-kat" = callPackage

15403 ({ mkDerivation, base, bytestring, mtl, tasty, tasty-hunit

15404 , tasty-quickcheck

15405 }:

15406 mkDerivation {

15407 pname = "tasty-kat";

15408 version = "0.0.3";

15409 sha256 = "14yvlpli6cv6bn3kh8mlfp4x1l6ns4fvmfv6hmj75cvxyzq029d7";

15410 libraryHaskellDepends = [ base bytestring tasty ];

15411 testHaskellDepends = [

15412 base bytestring mtl tasty tasty-hunit tasty-quickcheck

15413 ];

15414 doCheck = false;

15415 homepage = "https://github.com/vincenthz/tasty-kat";

15416 description = "Known Answer Tests (KAT) framework for tasty";

15417 license = stdenv.lib.licenses.mit;

15418 }) {};

15419 "tasty-quickcheck" = callPackage

15420 ({ mkDerivation, base, pcre-light, QuickCheck, tagged, tasty

15421 , tasty-hunit

15422 }:

15423 mkDerivation {

15424 pname = "tasty-quickcheck";

15425 version = "0.8.3.2";

15426 sha256 = "1q1fghmsjrdl6jkcnajmsvw4d893m6cyhzpai9vvrhxy9vdy0l1v";

15427 configureFlags = [

15428 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15429 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15430 "-fsplitbase" "-f-test-hlint"

15431 ];

15432 libraryHaskellDepends = [ base QuickCheck tagged tasty ];

15433 testHaskellDepends = [ base pcre-light tasty tasty-hunit ];

15434 homepage = "http://documentup.com/feuerbach/tasty";

15435 description = "QuickCheck support for the Tasty test framework";

15436 license = stdenv.lib.licenses.mit;

15437 }) {};

15438 "tasty-smallcheck" = callPackage

15439 ({ mkDerivation, async, base, smallcheck, tagged, tasty }:

15440 mkDerivation {

15441 pname = "tasty-smallcheck";

15442 version = "0.8.0.1";

15443 sha256 = "0yckfbz8na8ccyw2911i3a4hd3fdncclk3ng5343hs5cylw6y4sm";

15444 configureFlags = [

15445 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15446 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15447 "-fsplitbase" "-f-test-hlint"

15448 ];

15449 libraryHaskellDepends = [ async base smallcheck tagged tasty ];

15450 homepage = "http://documentup.com/feuerbach/tasty";

15451 description = "SmallCheck support for the Tasty test framework";

15452 license = stdenv.lib.licenses.bsd3;

15453 }) {};

15454 "tasty-th" = callPackage

15455 ({ mkDerivation, base, language-haskell-extract, tasty

15456 , template-haskell

15457 }:

15458 mkDerivation {

15459 pname = "tasty-th";

15460 version = "0.1.3";

15461 sha256 = "1fl5pagm9bdqvp7v54ilkr91m667rxw1jifwfdhrikr938aqrzx3";

15462 configureFlags = [

15463 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15464 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15465 "-fsplitbase" "-f-test-hlint"

15466 ];

15467 libraryHaskellDepends = [

15468 base language-haskell-extract tasty template-haskell

15469 ];

15470 homepage = "http://github.com/bennofs/tasty-th";

15471 description = "Automagically generate the HUnit- and Quickcheck-bulk-code using Template Haskell";

15472 license = stdenv.lib.licenses.bsd3;

15473 }) {};

15474 "temporary" = callPackage

15475 ({ mkDerivation, base, directory, exceptions, filepath

15476 , transformers, unix

15477 }:

15478 mkDerivation {

15479 pname = "temporary";

15480 version = "1.2.0.3";

15481 sha256 = "0is67bmsjmbbw6wymhis8wyq9gax3sszm573p5719fx2c9z9r24a";

15482 configureFlags = [

15483 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15484 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15485 "-fsplitbase" "-f-test-hlint"

15486 ];

15487 libraryHaskellDepends = [

15488 base directory exceptions filepath transformers unix

15489 ];

15490 homepage = "http://www.github.com/batterseapower/temporary";

15491 description = "Portable temporary file and directory support for Windows and Unix, based on code from Cabal";

15492 license = stdenv.lib.licenses.bsd3;

15493 }) {};

15494 "temporary-rc" = callPackage

15495 ({ mkDerivation, base, directory, exceptions, filepath

15496 , transformers, unix

15497 }:

15498 mkDerivation {

15499 pname = "temporary-rc";

15500 version = "1.2.0.3";

15501 sha256 = "1nqih0qks439k3pr5kmbbc8rjdw730slrxlflqb27fbxbzb8skqs";

15502 configureFlags = [

15503 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15504 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15505 "-fsplitbase" "-f-test-hlint"

15506 ];

15507 libraryHaskellDepends = [

15508 base directory exceptions filepath transformers unix

15509 ];

15510 homepage = "http://www.github.com/feuerbach/temporary";

15511 description = "Portable temporary file and directory support for Windows and Unix, based on code from Cabal";

15512 license = stdenv.lib.licenses.bsd3;

15513 }) {};

15514 "terminal-progress-bar" = callPackage

15515 ({ mkDerivation, base, base-unicode-symbols, HUnit, stm, stm-chans

15516 , test-framework, test-framework-hunit

15517 }:

15518 mkDerivation {

15519 pname = "terminal-progress-bar";

15520 version = "0.0.1.4";

15521 sha256 = "0ldvii23ks446xrd27aklh8s8pn1yi3dzhhzl05gipjqbhq3lsx3";

15522 configureFlags = [

15523 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15524 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15525 "-fsplitbase" "-f-test-hlint"

15526 ];

15527 libraryHaskellDepends = [

15528 base base-unicode-symbols stm stm-chans

15529 ];

15530 testHaskellDepends = [

15531 base base-unicode-symbols HUnit test-framework test-framework-hunit

15532 ];

15533 homepage = "https://github.com/roelvandijk/terminal-progress-bar";

15534 description = "A simple progress bar in the terminal";

15535 license = stdenv.lib.licenses.bsd3;

15536 }) {};

15537 "terminal-size" = callPackage

15538 ({ mkDerivation, base }:

15539 mkDerivation {

15540 pname = "terminal-size";

15541 version = "0.3.0";

15542 sha256 = "0g8v08d20hlfsah9dlgv2v2pzj0m4dva0zp6zi4jrkxjhg6vi7bw";

15543 configureFlags = [

15544 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15545 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15546 "-fsplitbase" "-f-test-hlint"

15547 ];

15548 libraryHaskellDepends = [ base ];

15549 description = "Get terminal window height and width";

15550 license = stdenv.lib.licenses.bsd3;

15551 }) {};

15552 "test-framework" = callPackage

15553 ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, containers

15554 , hostname, old-locale, random, regex-posix, time, xml

15555 }:

15556 mkDerivation {

15557 pname = "test-framework";

15558 version = "0.8.1.1";

15559 sha256 = "0wxjgdvb1c4ykazw774zlx86550848wbsvgjgcrdzcgbb9m650vq";

15560 revision = "3";

15561 editedCabalFile = "1b6pi4j1dpcbiyx1bpfks29x293j02z7ashs2sdc8fhzbwsr9lxj";

15562 configureFlags = [

15563 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15564 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15565 "-fsplitbase" "-f-test-hlint"

15566 ];

15567 isLibrary = true;

15568 isExecutable = true;

15569 libraryHaskellDepends = [

15570 ansi-terminal ansi-wl-pprint base containers hostname old-locale

15571 random regex-posix time xml

15572 ];

15573 homepage = "https://batterseapower.github.io/test-framework/";

15574 description = "Framework for running and organising tests, with HUnit and QuickCheck support";

15575 license = stdenv.lib.licenses.bsd3;

15576 }) {};

15577 "test-framework-hunit" = callPackage

15578 ({ mkDerivation, base, extensible-exceptions, HUnit, test-framework

15579 }:

15580 mkDerivation {

15581 pname = "test-framework-hunit";

15582 version = "0.3.0.1";

15583 sha256 = "1h0h55kf6ff25nbfx1mhliwyknc0glwv3zi78wpzllbjbs7gvyfk";

15584 revision = "1";

15585 editedCabalFile = "0aabb5lksl75yc75rfscgsv2aiazkz3hyx6j9mpis8nwcykmaqgg";

15586 configureFlags = [

15587 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15588 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15589 "-fsplitbase" "-f-test-hlint"

15590 ];

15591 libraryHaskellDepends = [

15592 base extensible-exceptions HUnit test-framework

15593 ];

15594 homepage = "https://batterseapower.github.io/test-framework/";

15595 description = "HUnit support for the test-framework package";

15596 license = stdenv.lib.licenses.bsd3;

15597 }) {};

15598 "test-framework-quickcheck2" = callPackage

15599 ({ mkDerivation, base, extensible-exceptions, QuickCheck, random

15600 , test-framework

15601 }:

15602 mkDerivation {

15603 pname = "test-framework-quickcheck2";

15604 version = "0.3.0.3";

15605 sha256 = "12p1zwrsz35r3j5gzbvixz9z1h5643rhihf5gqznmc991krwd5nc";

15606 revision = "4";

15607 editedCabalFile = "1j1lk0xpbdfvp42h6c34yq1snhl1mk6sf393raxvakfl0l7nybqd";

15608 configureFlags = [

15609 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15610 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15611 "-fsplitbase" "-f-test-hlint"

15612 ];

15613 libraryHaskellDepends = [

15614 base extensible-exceptions QuickCheck random test-framework

15615 ];

15616 homepage = "https://batterseapower.github.io/test-framework/";

15617 description = "QuickCheck2 support for the test-framework package";

15618 license = stdenv.lib.licenses.bsd3;

15619 }) {};

15620 "test-framework-th" = callPackage

15621 ({ mkDerivation, base, haskell-src-exts, language-haskell-extract

15622 , regex-posix, template-haskell, test-framework

15623 }:

15624 mkDerivation {

15625 pname = "test-framework-th";

15626 version = "0.2.4";

15627 sha256 = "12lw7yj02jb9s0i7rb98jjam43j2h0gzmnbj9zi933fx7sg0sy4b";

15628 configureFlags = [

15629 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15630 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15631 "-fsplitbase" "-f-test-hlint"

15632 ];

15633 libraryHaskellDepends = [

15634 base haskell-src-exts language-haskell-extract regex-posix

15635 template-haskell test-framework

15636 ];

15637 homepage = "http://github.com/finnsson/test-generator";

15638 description = "Automagically generate the HUnit- and Quickcheck-bulk-code using Template Haskell";

15639 license = stdenv.lib.licenses.bsd3;

15640 }) {};

15641 "testing-feat" = callPackage

15642 ({ mkDerivation, base, mtl, QuickCheck, tagshare, template-haskell

15643 }:

15644 mkDerivation {

15645 pname = "testing-feat";

15646 version = "0.4.0.2";

15647 sha256 = "15gi6w7p4alnih9grklhhr8338y1aal07admbz4n2f724hnhyb2j";

15648 revision = "1";

15649 editedCabalFile = "0gyxqh0g30ldzc7hdkadkvjwbdyjqnk14g53h0gpl3mcx7hxss01";

15650 configureFlags = [

15651 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15652 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15653 "-fsplitbase" "-f-test-hlint"

15654 ];

15655 libraryHaskellDepends = [

15656 base mtl QuickCheck tagshare template-haskell

15657 ];

15658 description = "Functional Enumeration of Algebraic Types";

15659 license = stdenv.lib.licenses.bsd3;

15660 }) {};

15661 "testpack" = callPackage

15662 ({ mkDerivation, base, containers, HUnit, mtl, QuickCheck, random

15663 }:

15664 mkDerivation {

15665 pname = "testpack";

15666 version = "2.1.3.0";

15667 sha256 = "1rq5d64d7j3gpgbfxmfr4xmzizjy0ricw5ghrakv8gzvxmi2bn4p";

15668 revision = "1";

15669 editedCabalFile = "0fdgxw04gx1ai31bk0cyck9qfqpn10yfgjaazc15r2ngjpbbqqy7";

15670 configureFlags = [

15671 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15672 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15673 "-fsplitbase" "-f-test-hlint"

15674 ];

15675 libraryHaskellDepends = [

15676 base containers HUnit mtl QuickCheck random

15677 ];

15678 homepage = "https://github.com/jgoerzen/testpack";

15679 description = "Test Utililty Pack for HUnit and QuickCheck (unmaintained)";

15680 license = "LGPL";

15681 }) {};

15682 "texmath" = callPackage

15683 ({ mkDerivation, base, bytestring, containers, directory, filepath

15684 , mtl, network-uri, pandoc-types, parsec, process, split, syb

15685 , temporary, text, utf8-string, xml

15686 }:

15687 mkDerivation {

15688 pname = "texmath";

15689 version = "0.8.0.2";

15690 sha256 = "11hzqfik99zydvsnwy4ihpgqvsiq398pxnw777bcaqzdrvyw7fa7";

15691 configureFlags = [

15692 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15693 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15694 "-fsplitbase" "-f-test-hlint"

15695 ];

15696 isLibrary = true;

15697 isExecutable = true;

15698 libraryHaskellDepends = [

15699 base containers mtl pandoc-types parsec syb xml

15700 ];

15701 executableHaskellDepends = [ network-uri ];

15702 testHaskellDepends = [

15703 base bytestring directory filepath process split temporary text

15704 utf8-string xml

15705 ];

15706 homepage = "http://github.com/jgm/texmath";

15707 description = "Conversion between formats used to represent mathematics";

15708 license = "GPL";

15709 }) {};

15710 "text" = callPackage

15711 ({ mkDerivation, array, base, bytestring, deepseq, directory

15712 , ghc-prim, HUnit, integer-gmp, QuickCheck, quickcheck-unicode

15713 , random, test-framework, test-framework-hunit

15714 , test-framework-quickcheck2

15715 }:

15716 mkDerivation {

15717 pname = "text";

15718 version = "1.2.0.4";

15719 sha256 = "004p1c74crs8wmjafwsmw3mmycspq1j8fpm1lvfpq6acha7bnpc6";

15720 revision = "1";

15721 editedCabalFile = "02qg44zzr1q47v9bd9hzrhdmyxism698v7hblfg0ykwqd8a5wq7f";

15722 configureFlags = [

15723 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15724 "-f-integer-simple" "-fnetwork-uri" "-fnew-base" "-fold-locale"

15725 "-fsmall_base" "-fsplitbase" "-f-test-hlint"

15726 ];

15727 libraryHaskellDepends = [

15728 array base bytestring deepseq ghc-prim integer-gmp

15729 ];

15730 testHaskellDepends = [

15731 array base bytestring deepseq directory ghc-prim HUnit integer-gmp

15732 QuickCheck quickcheck-unicode random test-framework

15733 test-framework-hunit test-framework-quickcheck2

15734 ];

15735 doCheck = false;

15736 homepage = "https://github.com/bos/text";

15737 description = "An efficient packed Unicode text type";

15738 license = stdenv.lib.licenses.bsd3;

15739 }) {};

15740 "text-binary" = callPackage

15741 ({ mkDerivation, base, binary, text }:

15742 mkDerivation {

15743 pname = "text-binary";

15744 version = "0.1.0";

15745 sha256 = "0wc501j8hqspnhf4d1hyb18f1wgc4kl2qx1b5s4bkxv0dfbwrk6z";

15746 revision = "2";

15747 editedCabalFile = "06aig24xj1n7jvbajnk0xjdimpb1wx84nv6bdv3mbpxk4rzj091m";

15748 configureFlags = [

15749 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15750 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15751 "-fsplitbase" "-f-test-hlint"

15752 ];

15753 libraryHaskellDepends = [ base binary text ];

15754 homepage = "https://github.com/kawu/text-binary";

15755 description = "Binary instances for text types";

15756 license = stdenv.lib.licenses.bsd3;

15757 }) {};

15758 "text-format" = callPackage

15759 ({ mkDerivation, array, base, double-conversion, ghc-prim

15760 , integer-gmp, old-locale, text, time, transformers

15761 }:

15762 mkDerivation {

15763 pname = "text-format";

15764 version = "0.3.1.1";

15765 sha256 = "02zfgzfjvkaxbma1h2gr95h10c8q9gyaadag41q579j68iv15qbd";

15766 configureFlags = [

15767 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15768 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15769 "-fsplitbase" "-f-test-hlint"

15770 ];

15771 libraryHaskellDepends = [

15772 array base double-conversion ghc-prim integer-gmp old-locale text

15773 time transformers

15774 ];

15775 homepage = "https://github.com/bos/text-format";

15776 description = "Text formatting";

15777 license = stdenv.lib.licenses.bsd3;

15778 }) {};

15779 "text-icu" = callPackage

15780 ({ mkDerivation, array, base, bytestring, deepseq, directory

15781 , ghc-prim, HUnit, icu, QuickCheck, random, test-framework

15782 , test-framework-hunit, test-framework-quickcheck2, text

15783 }:

15784 mkDerivation {

15785 pname = "text-icu";

15786 version = "0.7.0.1";

15787 sha256 = "0y3z5jda7v2iyll2148ivxfd2yhp27d3ryxrspp0cdq394klqxp2";

15788 configureFlags = [

15789 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15790 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15791 "-fsplitbase" "-f-test-hlint"

15792 ];

15793 libraryHaskellDepends = [ base bytestring deepseq text ];

15794 librarySystemDepends = [ icu ];

15795 testHaskellDepends = [

15796 array base bytestring deepseq directory ghc-prim HUnit QuickCheck

15797 random test-framework test-framework-hunit

15798 test-framework-quickcheck2 text

15799 ];

15800 homepage = "https://github.com/bos/text-icu";

15801 description = "Bindings to the ICU library";

15802 license = stdenv.lib.licenses.bsd3;

15803 }) {inherit (pkgs) icu;};

15804 "tf-random" = callPackage

15805 ({ mkDerivation, base, primitive, random, time }:

15806 mkDerivation {

15807 pname = "tf-random";

15808 version = "0.5";

15809 sha256 = "0445r2nns6009fmq0xbfpyv7jpzwv0snccjdg7hwj4xk4z0cwc1f";

15810 configureFlags = [

15811 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15812 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15813 "-fsplitbase" "-f-test-hlint"

15814 ];

15815 libraryHaskellDepends = [ base primitive random time ];

15816 description = "High-quality splittable pseudorandom number generator";

15817 license = stdenv.lib.licenses.bsd3;

15818 }) {};

15819 "th-desugar" = callPackage

15820 ({ mkDerivation, base, containers, hspec, HUnit, mtl, syb

15821 , template-haskell

15822 }:

15823 mkDerivation {

15824 pname = "th-desugar";

15825 version = "1.4.2.1";

15826 sha256 = "1ys7j1hvvsl3pb8rrp336jw3q2cf0zfx12v8n4mz0wbg0xm7pwjr";

15827 revision = "1";

15828 editedCabalFile = "1m9bwk6a9sy45ssxkpxajk9pj840w78721smcql15z7a3qd69qy7";

15829 configureFlags = [

15830 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15831 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15832 "-fsplitbase" "-f-test-hlint"

15833 ];

15834 libraryHaskellDepends = [

15835 base containers mtl syb template-haskell

15836 ];

15837 testHaskellDepends = [

15838 base containers hspec HUnit mtl syb template-haskell

15839 ];

15840 doCheck = false;

15841 homepage = "http://www.cis.upenn.edu/~eir/packages/th-desugar";

15842 description = "Functions to desugar Template Haskell";

15843 license = stdenv.lib.licenses.bsd3;

15844 }) {};

15845 "th-expand-syns" = callPackage

15846 ({ mkDerivation, base, containers, syb, template-haskell }:

15847 mkDerivation {

15848 pname = "th-expand-syns";

15849 version = "0.3.0.6";

15850 sha256 = "03qv93pyqk8all39knsf0mzmbfdck5x61kqnyn8rbisw5c1ymx6j";

15851 configureFlags = [

15852 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15853 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15854 "-fsplitbase" "-f-test-hlint"

15855 ];

15856 libraryHaskellDepends = [ base containers syb template-haskell ];

15857 testHaskellDepends = [ base template-haskell ];

15858 description = "Expands type synonyms in Template Haskell ASTs";

15859 license = stdenv.lib.licenses.bsd3;

15860 }) {};

15861 "th-extras" = callPackage

15862 ({ mkDerivation, base, syb, template-haskell }:

15863 mkDerivation {

15864 pname = "th-extras";

15865 version = "0.0.0.2";

15866 sha256 = "15sqf2jjnqcssq8hp80fk0ysgwqykjjc31gvvmzg4sypskpjs8cl";

15867 revision = "1";

15868 editedCabalFile = "0ryzvqav51wdwfagmg71kq1ljgfqs9a3zr4pzmc2fcc8vapbvpyr";

15869 configureFlags = [

15870 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15871 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15872 "-fsplitbase" "-f-test-hlint"

15873 ];

15874 libraryHaskellDepends = [ base syb template-haskell ];

15875 homepage = "https://github.com/mokus0/th-extras";

15876 description = "A grab bag of functions for use with Template Haskell";

15877 license = stdenv.lib.licenses.publicDomain;

15878 }) {};

15879 "th-lift" = callPackage

15880 ({ mkDerivation, base, template-haskell }:

15881 mkDerivation {

15882 pname = "th-lift";

15883 version = "0.7.2";

15884 sha256 = "0jl2x09mh9frsx5bccw8m4m3h72bncjaix9ylyfpvizisivj8p3m";

15885 configureFlags = [

15886 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15887 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15888 "-fsplitbase" "-f-test-hlint"

15889 ];

15890 libraryHaskellDepends = [ base template-haskell ];

15891 testHaskellDepends = [ base template-haskell ];

15892 homepage = "http://github.com/mboes/th-lift";

15893 description = "Derive Template Haskell's Lift class for datatypes";

15894 license = stdenv.lib.licenses.bsd3;

15895 }) {};

15896 "th-orphans" = callPackage

15897 ({ mkDerivation, base, template-haskell, th-lift, th-reify-many }:

15898 mkDerivation {

15899 pname = "th-orphans";

15900 version = "0.8.3";

15901 sha256 = "1ia6qg6fh90glg86kc248mch3qim1x09zbccfh1drcqk4c54lhnx";

15902 configureFlags = [

15903 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15904 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15905 "-fsplitbase" "-f-test-hlint"

15906 ];

15907 libraryHaskellDepends = [

15908 base template-haskell th-lift th-reify-many

15909 ];

15910 description = "Orphan instances for TH datatypes";

15911 license = stdenv.lib.licenses.bsd3;

15912 }) {};

15913 "th-reify-many" = callPackage

15914 ({ mkDerivation, base, containers, mtl, safe, template-haskell

15915 , th-expand-syns

15916 }:

15917 mkDerivation {

15918 pname = "th-reify-many";

15919 version = "0.1.3";

15920 sha256 = "00hryljcs434wcv1vaamfdbjk857f46djxv7mlwplkl3zsmfhlfx";

15921 configureFlags = [

15922 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15923 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15924 "-fsplitbase" "-f-test-hlint"

15925 ];

15926 libraryHaskellDepends = [

15927 base containers mtl safe template-haskell th-expand-syns

15928 ];

15929 testHaskellDepends = [ base template-haskell ];

15930 homepage = "http://github.com/mgsloan/th-reify-many";

15931 description = "Recurseively reify template haskell datatype info";

15932 license = stdenv.lib.licenses.bsd3;

15933 }) {};

15934 "threads" = callPackage

15935 ({ mkDerivation, base, concurrent-extra, HUnit, stm, test-framework

15936 , test-framework-hunit

15937 }:

15938 mkDerivation {

15939 pname = "threads";

15940 version = "0.5.1.3";

15941 sha256 = "04b4hjwv38iv48hdaxrw8ngrid6pgia32h6vci80szgpjxslrg82";

15942 configureFlags = [

15943 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15944 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15945 "-fsplitbase" "-f-test-hlint"

15946 ];

15947 libraryHaskellDepends = [ base stm ];

15948 testHaskellDepends = [

15949 base concurrent-extra HUnit stm test-framework test-framework-hunit

15950 ];

15951 doCheck = false;

15952 homepage = "https://github.com/basvandijk/threads";

15953 description = "Fork threads and wait for their result";

15954 license = stdenv.lib.licenses.bsd3;

15955 }) {};

15956 "thyme" = callPackage

15957 ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal

15958 , containers, cpphs, criterion, deepseq, directory, filepath, mtl

15959 , old-locale, profunctors, QuickCheck, random

15960 , system-posix-redirect, text, time, vector, vector-space

15961 , vector-th-unbox

15962 }:

15963 mkDerivation {

15964 pname = "thyme";

15965 version = "0.3.5.5";

15966 sha256 = "0v3rbjl92bqggsdra72zdq6rxzb2qf1268424p94225lnwgp1il4";

15967 configureFlags = [

15968 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

15969 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

15970 "-fsplitbase" "-f-test-hlint"

15971 ];

15972 libraryHaskellDepends = [

15973 aeson attoparsec base bytestring containers deepseq mtl old-locale

15974 profunctors QuickCheck random text time vector vector-space

15975 vector-th-unbox

15976 ];

15977 libraryToolDepends = [ cpphs ];

15978 testHaskellDepends = [

15979 attoparsec base bytestring Cabal containers directory filepath mtl

15980 old-locale profunctors QuickCheck random system-posix-redirect text

15981 time vector-space

15982 ];

15983 benchmarkHaskellDepends = [

15984 base criterion mtl old-locale profunctors QuickCheck random time

15985 vector vector-space

15986 ];

15987 doCheck = false;

15988 homepage = "https://github.com/liyang/thyme";

15989 description = "A faster time library";

15990 license = stdenv.lib.licenses.bsd3;

15991 }) {};

15992 "time-compat" = callPackage

15993 ({ mkDerivation, base, old-time, time }:

15994 mkDerivation {

15995 pname = "time-compat";

15996 version = "0.1.0.3";

15997 sha256 = "0zqgzr8yjn36rn6gflwh5s0c92vl44xzxiw0jz8d5h0h8lhi21sr";

15998 configureFlags = [

15999 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16000 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16001 "-fsplitbase" "-f-test-hlint"

16002 ];

16003 libraryHaskellDepends = [ base old-time time ];

16004 homepage = "http://hub.darcs.net/dag/time-compat";

16005 description = "Compatibility with old-time for the time package";

16006 license = stdenv.lib.licenses.bsd3;

16007 }) {};

16008 "time-lens" = callPackage

16009 ({ mkDerivation, base, data-lens-light, time }:

16010 mkDerivation {

16011 pname = "time-lens";

16012 version = "0.4.0.1";

16013 sha256 = "0916qfan93aq91icf87ifvskrq6s6s75rhkajvl8pxp74j28hlwz";

16014 configureFlags = [

16015 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16016 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16017 "-fsplitbase" "-f-test-hlint"

16018 ];

16019 libraryHaskellDepends = [ base data-lens-light time ];

16020 description = "Lens-based interface to Data.Time data structures";

16021 license = stdenv.lib.licenses.bsd3;

16022 }) {};

16023 "time-locale-compat" = callPackage

16024 ({ mkDerivation, base, old-locale, time }:

16025 mkDerivation {

16026 pname = "time-locale-compat";

16027 version = "0.1.0.1";

16028 sha256 = "0q5d134cvcy7hlr473fanqqixqnqpqvz9ka2r45m59l6kzrws95c";

16029 libraryHaskellDepends = [ base old-locale time ];

16030 homepage = "http://twitter.com/khibino/";

16031 description = "Compatibility of TimeLocale between old-locale and time-1.5";

16032 license = stdenv.lib.licenses.bsd3;

16033 }) {};

16034 "timezone-olson" = callPackage

16035 ({ mkDerivation, base, binary, bytestring, extensible-exceptions

16036 , time, timezone-series

16037 }:

16038 mkDerivation {

16039 pname = "timezone-olson";

16040 version = "0.1.6";

16041 sha256 = "0gg1fq85km5d48966a267q6z0wwl1dz88xq88v0l1jlkwd9jsb0z";

16042 configureFlags = [

16043 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16044 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16045 "-fsplitbase" "-f-test-hlint"

16046 ];

16047 libraryHaskellDepends = [

16048 base binary bytestring extensible-exceptions time timezone-series

16049 ];

16050 homepage = "http://projects.haskell.org/time-ng/";

16051 description = "A pure Haskell parser and renderer for binary Olson timezone files";

16052 license = stdenv.lib.licenses.bsd3;

16053 }) {};

16054 "timezone-series" = callPackage

16055 ({ mkDerivation, base, time }:

16056 mkDerivation {

16057 pname = "timezone-series";

16058 version = "0.1.4";

16059 sha256 = "06p5v0dimhwmra100gwkhkz3ll492i2bvafw0qx2qzcxx4yxff40";

16060 configureFlags = [

16061 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16062 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16063 "-fsplitbase" "-f-test-hlint"

16064 ];

16065 libraryHaskellDepends = [ base time ];

16066 homepage = "http://projects.haskell.org/time-ng/";

16067 description = "Enhanced timezone handling for Data.Time";

16068 license = stdenv.lib.licenses.bsd3;

16069 }) {};

16070 "tls" = callPackage

16071 ({ mkDerivation, asn1-encoding, asn1-types, async, base, byteable

16072 , bytestring, cereal, cipher-aes, cipher-des, cipher-rc4, cprng-aes

16073 , criterion, crypto-cipher-types, crypto-numbers, crypto-pubkey

16074 , crypto-pubkey-types, crypto-random, cryptohash

16075 , data-default-class, hourglass, mtl, network, QuickCheck, tasty

16076 , tasty-quickcheck, transformers, x509, x509-store, x509-validation

16077 }:

16078 mkDerivation {

16079 pname = "tls";

16080 version = "1.2.16";

16081 sha256 = "0z5w8bj6acr7517y25dkqi3scjn08kzq2hjkhrc1rs6cafn8cl20";

16082 configureFlags = [

16083 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16084 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16085 "-fsplitbase" "-f-test-hlint"

16086 ];

16087 libraryHaskellDepends = [

16088 asn1-encoding asn1-types async base byteable bytestring cereal

16089 cipher-aes cipher-des cipher-rc4 crypto-cipher-types crypto-numbers

16090 crypto-pubkey crypto-pubkey-types crypto-random cryptohash

16091 data-default-class mtl network transformers x509 x509-store

16092 x509-validation

16093 ];

16094 testHaskellDepends = [

16095 base bytestring cereal cprng-aes crypto-pubkey crypto-random

16096 data-default-class hourglass mtl QuickCheck tasty tasty-quickcheck

16097 x509 x509-validation

16098 ];

16099 benchmarkHaskellDepends = [

16100 base bytestring cprng-aes criterion crypto-pubkey crypto-random

16101 data-default-class hourglass mtl QuickCheck x509 x509-validation

16102 ];

16103 homepage = "http://github.com/vincenthz/hs-tls";

16104 description = "TLS/SSL protocol native implementation (Server and Client)";

16105 license = stdenv.lib.licenses.bsd3;

16106 }) {};

16107 "tls-debug" = callPackage

16108 ({ mkDerivation, base, bytestring, cprng-aes, crypto-pubkey

16109 , data-default-class, network, pem, time, tls, x509, x509-system

16110 , x509-validation

16111 }:

16112 mkDerivation {

16113 pname = "tls-debug";

16114 version = "0.3.4";

16115 sha256 = "08bxcl0lf07fx3xfajd99090glvgnpn5s4826g2hirr75b9a5b93";

16116 configureFlags = [

16117 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16118 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16119 "-fsplitbase" "-f-test-hlint"

16120 ];

16121 isLibrary = false;

16122 isExecutable = true;

16123 executableHaskellDepends = [

16124 base bytestring cprng-aes crypto-pubkey data-default-class network

16125 pem time tls x509 x509-system x509-validation

16126 ];

16127 doHaddock = false;

16128 homepage = "http://github.com/vincenthz/hs-tls";

16129 description = "Set of programs for TLS testing and debugging";

16130 license = stdenv.lib.licenses.bsd3;

16131 }) {};

16132 "tostring" = callPackage

16133 ({ mkDerivation, base, case-insensitive, text, utf8-string }:

16134 mkDerivation {

16135 pname = "tostring";

16136 version = "0.2.1.1";

16137 sha256 = "0c95a1vjnnn3bwdz8v5hv7q2sbzn23ban3hcwqmwhmzc9ba019zg";

16138 configureFlags = [

16139 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16140 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16141 "-fsplitbase" "-f-test-hlint"

16142 ];

16143 libraryHaskellDepends = [ base case-insensitive text utf8-string ];

16144 description = "The ToString class";

16145 license = stdenv.lib.licenses.bsd3;

16146 }) {};

16147 "transformers-base" = callPackage

16148 ({ mkDerivation, base, stm, transformers, transformers-compat }:

16149 mkDerivation {

16150 pname = "transformers-base";

16151 version = "0.4.4";

16152 sha256 = "11r3slgpgpra6zi2kjg3g60gvv17b1fh6qxipcpk8n86qx7lk8va";

16153 revision = "1";

16154 editedCabalFile = "196pr3a4lhgklyw6nq6rv1j9djwzmvx7xrpp58carxnb55gk06pv";

16155 configureFlags = [

16156 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16157 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16158 "-fsplitbase" "-f-test-hlint"

16159 ];

16160 libraryHaskellDepends = [

16161 base stm transformers transformers-compat

16162 ];

16163 homepage = "https://github.com/mvv/transformers-base";

16164 description = "Lift computations from the bottom of a transformer stack";

16165 license = stdenv.lib.licenses.bsd3;

16166 }) {};

16167 "transformers-compat" = callPackage

16168 ({ mkDerivation, base, transformers }:

16169 mkDerivation {

16170 pname = "transformers-compat";

16171 version = "0.3.3.3";

16172 sha256 = "18cqghf0gc97j9qnlfnwwhvfm8j4sk99rm0xv3bf6ml8slk7njx7";

16173 configureFlags = [

16174 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16175 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16176 "-fsplitbase" "-f-test-hlint"

16177 ];

16178 libraryHaskellDepends = [ base transformers ];

16179 homepage = "http://github.com/ekmett/transformers-compat/";

16180 description = "A small compatibility shim exposing the new types from transformers 0.3 and 0.4 to older Haskell platforms.";

16181 license = stdenv.lib.licenses.bsd3;

16182 }) {};

16183 "traverse-with-class" = callPackage

16184 ({ mkDerivation, base, template-haskell, transformers }:

16185 mkDerivation {

16186 pname = "traverse-with-class";

16187 version = "0.2.0.3";

16188 sha256 = "0snms19w3n9ni1wmf4ikwpp298nc6qk6phrjxi5g023ihqqdvr6g";

16189 configureFlags = [

16190 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16191 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16192 "-fsplitbase" "-f-test-hlint"

16193 ];

16194 libraryHaskellDepends = [ base template-haskell transformers ];

16195 description = "Generic applicative traversals";

16196 license = stdenv.lib.licenses.mit;

16197 }) {};

16198 "tree-view" = callPackage

16199 ({ mkDerivation, base, containers, mtl }:

16200 mkDerivation {

16201 pname = "tree-view";

16202 version = "0.4";

16203 sha256 = "0mzywp6nipc6zs98dy4ny2s3r9d745lqpjazfnj5y4hx8swyckgn";

16204 configureFlags = [

16205 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16206 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16207 "-fsplitbase" "-f-test-hlint"

16208 ];

16209 libraryHaskellDepends = [ base containers mtl ];

16210 description = "Render trees as foldable HTML and Unicode art";

16211 license = stdenv.lib.licenses.bsd3;

16212 }) {};

16213 "tuple" = callPackage

16214 ({ mkDerivation, base, OneTuple }:

16215 mkDerivation {

16216 pname = "tuple";

16217 version = "0.3.0.2";

16218 sha256 = "094nx29aahyrvbcn7yca9zs2a5rxz1is7510w1q43rpvza7hdjrg";

16219 configureFlags = [

16220 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16221 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16222 "-fsplitbase" "-f-test-hlint"

16223 ];

16224 libraryHaskellDepends = [ base OneTuple ];

16225 description = "Various functions on tuples";

16226 license = stdenv.lib.licenses.bsd3;

16227 }) {};

16228 "type-eq" = callPackage

16229 ({ mkDerivation, base, cpphs }:

16230 mkDerivation {

16231 pname = "type-eq";

16232 version = "0.4.2";

16233 sha256 = "0nyx3lqgrnlz0l3p615ln2dglqd39jwlk91ybz7blzhq1gpgayar";

16234 configureFlags = [

16235 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16236 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16237 "-fsplitbase" "-f-test-hlint"

16238 ];

16239 libraryHaskellDepends = [ base ];

16240 libraryToolDepends = [ cpphs ];

16241 homepage = "http://github.com/glaebhoerl/type-eq";

16242 description = "Type equality evidence you can carry around";

16243 license = stdenv.lib.licenses.bsd3;

16244 }) {};

16245 "type-list" = callPackage

16246 ({ mkDerivation, base, singletons }:

16247 mkDerivation {

16248 pname = "type-list";

16249 version = "0.0.0.1";

16250 sha256 = "1mbgwin1rcf1fkm3cq6h2dqv157xwgjca3019fxi759cxg9j70d2";

16251 configureFlags = [

16252 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16253 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16254 "-fsplitbase" "-f-test-hlint"

16255 ];

16256 libraryHaskellDepends = [ base singletons ];

16257 description = "Operations on type-level lists and tuples";

16258 license = stdenv.lib.licenses.bsd3;

16259 }) {};

16260 "udbus" = callPackage

16261 ({ mkDerivation, base, binary, bytestring, cereal, containers

16262 , ghc-prim, mtl, network, unix, utf8-string

16263 }:

16264 mkDerivation {

16265 pname = "udbus";

16266 version = "0.2.1";

16267 sha256 = "0a7kksh99nll91q41z4xgrcwc8pnfm0p71bxw6yymcd7yb0v09fk";

16268 configureFlags = [

16269 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16270 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16271 "-fsplitbase" "-f-test-hlint"

16272 ];

16273 isLibrary = true;

16274 isExecutable = true;

16275 enableSeparateDataOutput = true;

16276 libraryHaskellDepends = [

16277 base binary bytestring cereal containers ghc-prim mtl network unix

16278 utf8-string

16279 ];

16280 homepage = "http://github.com/vincenthz/hs-udbus";

16281 description = "Small DBus implementation";

16282 license = stdenv.lib.licenses.bsd3;

16283 }) {};

16284 "unbounded-delays" = callPackage

16285 ({ mkDerivation, base }:

16286 mkDerivation {

16287 pname = "unbounded-delays";

16288 version = "0.1.0.9";

16289 sha256 = "1f4h87503m3smhip432q027wj3zih18pmz2rnafh60589ifcl420";

16290 configureFlags = [

16291 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16292 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16293 "-fsplitbase" "-f-test-hlint"

16294 ];

16295 libraryHaskellDepends = [ base ];

16296 homepage = "https://github.com/basvandijk/unbounded-delays";

16297 description = "Unbounded thread delays and timeouts";

16298 license = stdenv.lib.licenses.bsd3;

16299 }) {};

16300 "union-find" = callPackage

16301 ({ mkDerivation, base, containers, transformers }:

16302 mkDerivation {

16303 pname = "union-find";

16304 version = "0.2";

16305 sha256 = "1v7hj42j9w6jlzi56jg8rh4p58gfs1c5dx30wd1qqvn0p0mnihp6";

16306 revision = "1";

16307 editedCabalFile = "13cwjh03n82sgshbk4fdlvhc0pb3v979sdcdrpvnpjdqmvcprs92";

16308 configureFlags = [

16309 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16310 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16311 "-fsplitbase" "-f-test-hlint"

16312 ];

16313 libraryHaskellDepends = [ base containers transformers ];

16314 homepage = "http://github.com/nominolo/union-find";

16315 description = "Efficient union and equivalence testing of sets";

16316 license = stdenv.lib.licenses.bsd3;

16317 }) {};

16318 "uniplate" = callPackage

16319 ({ mkDerivation, base, containers, hashable, syb

16320 , unordered-containers

16321 }:

16322 mkDerivation {

16323 pname = "uniplate";

16324 version = "1.6.12";

16325 sha256 = "1dx8f9aw27fz8kw0ad1nm6355w5rdl7bjvb427v2bsgnng30pipw";

16326 configureFlags = [

16327 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16328 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16329 "-fsplitbase" "-f-test-hlint"

16330 ];

16331 libraryHaskellDepends = [

16332 base containers hashable syb unordered-containers

16333 ];

16334 homepage = "http://community.haskell.org/~ndm/uniplate/";

16335 description = "Help writing simple, concise and fast generic operations";

16336 license = stdenv.lib.licenses.bsd3;

16337 }) {};

16338 "unix-compat" = callPackage

16339 ({ mkDerivation, base, unix }:

16340 mkDerivation {

16341 pname = "unix-compat";

16342 version = "0.4.1.4";

16343 sha256 = "0jxk7j5pz2kgfpqr4hznndjg31pqj5xg2qfc5308fcn9xyg1myps";

16344 revision = "2";

16345 editedCabalFile = "170j8a6dp825iwmk4v34pgi7c6pmkcjcrip5vznkxvdsjxagp71c";

16346 configureFlags = [

16347 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16348 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16349 "-fsplitbase" "-f-test-hlint"

16350 ];

16351 libraryHaskellDepends = [ base unix ];

16352 homepage = "http://github.com/jystic/unix-compat";

16353 description = "Portable POSIX-compatibility layer";

16354 license = stdenv.lib.licenses.bsd3;

16355 }) {};

16356 "unix-time" = callPackage

16357 ({ mkDerivation, base, binary, bytestring, doctest, hspec

16358 , old-locale, old-time, QuickCheck, time

16359 }:

16360 mkDerivation {

16361 pname = "unix-time";

16362 version = "0.3.5";

16363 sha256 = "0pk7046lmvl7dw6g7508xsixwi3gpiq5dw0a0lfwpfr80g6mh73z";

16364 configureFlags = [

16365 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16366 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16367 "-fsplitbase" "-f-test-hlint"

16368 ];

16369 libraryHaskellDepends = [ base binary bytestring old-time ];

16370 testHaskellDepends = [

16371 base bytestring doctest hspec old-locale old-time QuickCheck time

16372 ];

16373 description = "Unix time parser/formatter and utilities";

16374 license = stdenv.lib.licenses.bsd3;

16375 }) {};

16376 "unordered-containers" = callPackage

16377 ({ mkDerivation, base, bytestring, ChasingBottoms, containers

16378 , criterion, deepseq, hashable, hashmap, HUnit, mtl, QuickCheck

16379 , random, test-framework, test-framework-hunit

16380 , test-framework-quickcheck2

16381 }:

16382 mkDerivation {

16383 pname = "unordered-containers";

16384 version = "0.2.5.1";

16385 sha256 = "06l1xv7vhpxly75saxdrbc6p2zlgz1az278arfkz4rgawfnphn3f";

16386 revision = "1";

16387 editedCabalFile = "0kbd4c2vfv10w8biqfhf4n5gljjy6y23x4qi84gnrpp6riaqhfsp";

16388 configureFlags = [

16389 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16390 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16391 "-fsplitbase" "-f-test-hlint"

16392 ];

16393 libraryHaskellDepends = [ base deepseq hashable ];

16394 testHaskellDepends = [

16395 base ChasingBottoms containers hashable HUnit QuickCheck

16396 test-framework test-framework-hunit test-framework-quickcheck2

16397 ];

16398 benchmarkHaskellDepends = [

16399 base bytestring containers criterion deepseq hashable hashmap mtl

16400 random

16401 ];

16402 homepage = "https://github.com/tibbe/unordered-containers";

16403 description = "Efficient hashing-based container types";

16404 license = stdenv.lib.licenses.bsd3;

16405 }) {};

16406 "uri-encode" = callPackage

16407 ({ mkDerivation, base, bytestring, network-uri, text, utf8-string

16408 }:

16409 mkDerivation {

16410 pname = "uri-encode";

16411 version = "1.5.0.4";

16412 sha256 = "10pmg48h1az474qsr951inyvkm5y9xqwrdzyvxf83k53i07kijpp";

16413 configureFlags = [

16414 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16415 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16416 "-fsplitbase" "-f-test-hlint"

16417 ];

16418 isLibrary = true;

16419 isExecutable = true;

16420 libraryHaskellDepends = [

16421 base bytestring network-uri text utf8-string

16422 ];

16423 description = "Unicode aware uri-encoding";

16424 license = "unknown";

16425 }) {};

16426 "url" = callPackage

16427 ({ mkDerivation, base, utf8-string }:

16428 mkDerivation {

16429 pname = "url";

16430 version = "2.1.3";

16431 sha256 = "0qag18wbrq9jjk1444mjigz1xl7xl03fz66b1lnya9qaihzpxwjs";

16432 configureFlags = [

16433 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16434 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16435 "-fsplitbase" "-f-test-hlint"

16436 ];

16437 libraryHaskellDepends = [ base utf8-string ];

16438 homepage = "http://www.haskell.org/haskellwiki/Url";

16439 description = "A library for working with URLs";

16440 license = stdenv.lib.licenses.bsd3;

16441 }) {};

16442 "utf8-light" = callPackage

16443 ({ mkDerivation, base, bytestring, ghc-prim }:

16444 mkDerivation {

16445 pname = "utf8-light";

16446 version = "0.4.2";

16447 sha256 = "0rwyc5z331yfnm4hpx0sph6i1zvkd1z10vvglhnp0vc9wy644k0q";

16448 configureFlags = [

16449 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16450 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16451 "-fsplitbase" "-f-test-hlint"

16452 ];

16453 libraryHaskellDepends = [ base bytestring ghc-prim ];

16454 description = "Unicode";

16455 license = stdenv.lib.licenses.bsd3;

16456 }) {};

16457 "utf8-string" = callPackage

16458 ({ mkDerivation, base, bytestring }:

16459 mkDerivation {

16460 pname = "utf8-string";

16461 version = "0.3.8";

16462 sha256 = "1h29dn0scsfkhmkg14ywq9178lw40ah1r36w249zfzqr02y7qxc0";

16463 revision = "2";

16464 editedCabalFile = "1zwrnnyay7nxsi0v8v9cdy5qa06kzy8h6l6w5cs6bzvg08hdfm85";

16465 configureFlags = [

16466 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16467 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16468 "-fsplitbase" "-f-test-hlint"

16469 ];

16470 libraryHaskellDepends = [ base bytestring ];

16471 homepage = "http://github.com/glguy/utf8-string/";

16472 description = "Support for reading and writing UTF8 Strings";

16473 license = stdenv.lib.licenses.bsd3;

16474 }) {};

16475 "uuid" = callPackage

16476 ({ mkDerivation, base, binary, bytestring, cryptohash, HUnit

16477 , network-info, QuickCheck, random, test-framework

16478 , test-framework-hunit, test-framework-quickcheck2, time

16479 , uuid-types

16480 }:

16481 mkDerivation {

16482 pname = "uuid";

16483 version = "1.3.9";

16484 sha256 = "1ngajcmg0sxj67qq9h4lfcvgazx1bbzq3y8zhqb6vb3vw6vwmcny";

16485 configureFlags = [

16486 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16487 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16488 "-fsplitbase" "-f-test-hlint"

16489 ];

16490 libraryHaskellDepends = [

16491 base binary bytestring cryptohash network-info random time

16492 uuid-types

16493 ];

16494 testHaskellDepends = [

16495 base bytestring HUnit QuickCheck random test-framework

16496 test-framework-hunit test-framework-quickcheck2

16497 ];

16498 homepage = "https://github.com/aslatter/uuid";

16499 description = "For creating, comparing, parsing and printing Universally Unique Identifiers";

16500 license = stdenv.lib.licenses.bsd3;

16501 }) {};

16502 "uuid-types" = callPackage

16503 ({ mkDerivation, base, binary, bytestring, deepseq, hashable, HUnit

16504 , QuickCheck, random, test-framework, test-framework-hunit

16505 , test-framework-quickcheck2

16506 }:

16507 mkDerivation {

16508 pname = "uuid-types";

16509 version = "1.0.0";

16510 sha256 = "09djqdbfd7a5fqarw38r4rrm9bq51f5a664g8hvk9190bwlsyvlq";

16511 libraryHaskellDepends = [

16512 base binary bytestring deepseq hashable random

16513 ];

16514 testHaskellDepends = [

16515 base bytestring HUnit QuickCheck test-framework

16516 test-framework-hunit test-framework-quickcheck2

16517 ];

16518 homepage = "https://github.com/aslatter/uuid";

16519 description = "Type definitions for Universally Unique Identifiers";

16520 license = stdenv.lib.licenses.bsd3;

16521 }) {};

16522 "vault" = callPackage

16523 ({ mkDerivation, base, containers, hashable, unordered-containers

16524 }:

16525 mkDerivation {

16526 pname = "vault";

16527 version = "0.3.0.4";

16528 sha256 = "0ah6qrg71krc87f4vjy4b4shdd0mgyil8fikb3j6fl4kfwlg67jn";

16529 configureFlags = [

16530 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16531 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16532 "-fsplitbase" "-f-test-hlint"

16533 ];

16534 libraryHaskellDepends = [

16535 base containers hashable unordered-containers

16536 ];

16537 homepage = "https://github.com/HeinrichApfelmus/vault";

16538 description = "a persistent store for values of arbitrary types";

16539 license = stdenv.lib.licenses.bsd3;

16540 }) {};

16541 "vector" = callPackage

16542 ({ mkDerivation, base, deepseq, ghc-prim, primitive, QuickCheck

16543 , random, template-haskell, test-framework

16544 , test-framework-quickcheck2, transformers

16545 }:

16546 mkDerivation {

16547 pname = "vector";

16548 version = "0.10.12.3";

16549 sha256 = "16p8i0gvc9d4n9mxlhlnvrl2s0gmgd7kcsk5czdzz2cd4gh5qxhg";

16550 revision = "1";

16551 editedCabalFile = "05lwb4zsgzfnb07bm7j1zp8y4y1wx9kapy8l5x693cgz3lsf1mnl";

16552 configureFlags = [

16553 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16554 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16555 "-fsplitbase" "-f-test-hlint"

16556 ];

16557 libraryHaskellDepends = [ base deepseq ghc-prim primitive ];

16558 testHaskellDepends = [

16559 base QuickCheck random template-haskell test-framework

16560 test-framework-quickcheck2 transformers

16561 ];

16562 homepage = "https://github.com/haskell/vector";

16563 description = "Efficient Arrays";

16564 license = stdenv.lib.licenses.bsd3;

16565 }) {};

16566 "vector-algorithms" = callPackage

16567 ({ mkDerivation, base, bytestring, containers, mtl, mwc-random

16568 , primitive, QuickCheck, vector

16569 }:

16570 mkDerivation {

16571 pname = "vector-algorithms";

16572 version = "0.6.0.3";

16573 sha256 = "1kz4b41y7swad6mbx0g3adc8lqma8pl3rnzah71cfdvb87gssbn4";

16574 configureFlags = [

16575 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16576 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16577 "-fsplitbase" "-f-test-hlint"

16578 ];

16579 isLibrary = true;

16580 isExecutable = true;

16581 libraryHaskellDepends = [ base bytestring primitive vector ];

16582 executableHaskellDepends = [ base mtl mwc-random vector ];

16583 testHaskellDepends = [

16584 base bytestring containers QuickCheck vector

16585 ];

16586 homepage = "http://code.haskell.org/~dolio/";

16587 description = "Efficient algorithms for vector arrays";

16588 license = stdenv.lib.licenses.bsd3;

16589 }) {};

16590 "vector-binary-instances" = callPackage

16591 ({ mkDerivation, base, binary, cereal, vector }:

16592 mkDerivation {

16593 pname = "vector-binary-instances";

16594 version = "0.2.1.0";

16595 sha256 = "028rsf2w193rhs1gic5yvvrwidw9sblczcn10aw64npfc6502l4l";

16596 configureFlags = [

16597 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16598 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16599 "-fsplitbase" "-f-test-hlint"

16600 ];

16601 libraryHaskellDepends = [ base binary cereal vector ];

16602 homepage = "https://github.com/bos/vector-binary-instances";

16603 description = "Instances of Data.Binary and Data.Serialize for vector";

16604 license = stdenv.lib.licenses.bsd3;

16605 }) {};

16606 "vector-instances" = callPackage

16607 ({ mkDerivation, base, comonad, keys, pointed, semigroupoids

16608 , semigroups, vector

16609 }:

16610 mkDerivation {

16611 pname = "vector-instances";

16612 version = "3.3.0.1";

16613 sha256 = "1npgvnv8pw5xcax57cam9n5j9ra9phm4b5jj26hbpzwnlh0rkcc4";

16614 configureFlags = [

16615 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16616 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16617 "-fsplitbase" "-f-test-hlint"

16618 ];

16619 libraryHaskellDepends = [

16620 base comonad keys pointed semigroupoids semigroups vector

16621 ];

16622 homepage = "http://github.com/ekmett/vector-instances";

16623 description = "Orphan Instances for 'Data.Vector'";

16624 license = stdenv.lib.licenses.bsd3;

16625 }) {};

16626 "vector-space" = callPackage

16627 ({ mkDerivation, base, Boolean, MemoTrie, NumInstances }:

16628 mkDerivation {

16629 pname = "vector-space";

16630 version = "0.8.7";

16631 sha256 = "1i3c34b3ngksmw4blhldap8fiw1jddm2h1qyr92csn3cllj6j1vm";

16632 configureFlags = [

16633 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16634 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16635 "-fsplitbase" "-f-test-hlint"

16636 ];

16637 libraryHaskellDepends = [ base Boolean MemoTrie NumInstances ];

16638 description = "Vector & affine spaces, linear maps, and derivatives";

16639 license = stdenv.lib.licenses.bsd3;

16640 }) {};

16641 "vector-space-points" = callPackage

16642 ({ mkDerivation, base, vector-space }:

16643 mkDerivation {

16644 pname = "vector-space-points";

16645 version = "0.2.1";

16646 sha256 = "061gpayzqz0shn2s6fx4ss0dfgxcq717dycmkxjhrx3hy0dczv34";

16647 configureFlags = [

16648 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16649 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16650 "-fsplitbase" "-f-test-hlint"

16651 ];

16652 libraryHaskellDepends = [ base vector-space ];

16653 description = "A type for points, as distinct from vectors";

16654 license = stdenv.lib.licenses.bsd3;

16655 }) {};

16656 "vector-th-unbox" = callPackage

16657 ({ mkDerivation, base, data-default, template-haskell, vector }:

16658 mkDerivation {

16659 pname = "vector-th-unbox";

16660 version = "0.2.1.2";

16661 sha256 = "01admr0akldwwmzmc465f5dbqmq03ldvma67kibanjs25m39dxhd";

16662 revision = "2";

16663 editedCabalFile = "0vglamdjyx1xlfi6glvxgy5s3vp4fl6fj5iljsv746xvqy5wf648";

16664 configureFlags = [

16665 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16666 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16667 "-fsplitbase" "-f-test-hlint"

16668 ];

16669 libraryHaskellDepends = [ base template-haskell vector ];

16670 testHaskellDepends = [ base data-default vector ];

16671 description = "Deriver for Data.Vector.Unboxed using Template Haskell";

16672 license = stdenv.lib.licenses.bsd3;

16673 }) {};

16674 "vhd" = callPackage

16675 ({ mkDerivation, base, byteable, bytestring, cereal, cipher-aes

16676 , cryptohash, directory, filepath, mmap, QuickCheck, random

16677 , storable-endian, test-framework, test-framework-quickcheck2, text

16678 , time

16679 }:

16680 mkDerivation {

16681 pname = "vhd";

16682 version = "0.2.2";

16683 sha256 = "0z7a17j0rd06kvn3v4qr0fhxg0xw6n3579477y2lvx4mcc3qyrvw";

16684 configureFlags = [

16685 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16686 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16687 "-fsplitbase" "-f-test-hlint"

16688 ];

16689 isLibrary = true;

16690 isExecutable = true;

16691 enableSeparateDataOutput = true;

16692 libraryHaskellDepends = [

16693 base byteable bytestring cereal cipher-aes cryptohash directory

16694 filepath mmap random storable-endian text time

16695 ];

16696 testHaskellDepends = [

16697 base byteable bytestring cereal cryptohash filepath mmap QuickCheck

16698 random test-framework test-framework-quickcheck2 text time

16699 ];

16700 homepage = "https://github.com/vincenthz/hs-vhd";

16701 description = "Provides functions to inspect and manipulate virtual hard disk (VHD) files";

16702 license = stdenv.lib.licenses.bsd3;

16703 }) {};

16704 "void" = callPackage

16705 ({ mkDerivation, base, ghc-prim, hashable, semigroups }:

16706 mkDerivation {

16707 pname = "void";

16708 version = "0.7";

16709 sha256 = "0ivgr4minxb5v56v4kbd045iwqk1c2w89c830731l75mkg8qa6wq";

16710 revision = "1";

16711 editedCabalFile = "1bgll5awf4j5766w63bnj9vl00irfdiyhhv903q3vw9s90zcjrhv";

16712 configureFlags = [

16713 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16714 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16715 "-fsplitbase" "-f-test-hlint"

16716 ];

16717 libraryHaskellDepends = [ base ghc-prim hashable semigroups ];

16718 homepage = "http://github.com/ekmett/void";

16719 description = "A Haskell 98 logically uninhabited data type";

16720 license = stdenv.lib.licenses.bsd3;

16721 }) {};

16722 "wai" = callPackage

16723 ({ mkDerivation, base, blaze-builder, bytestring, hspec, http-types

16724 , network, text, vault

16725 }:

16726 mkDerivation {

16727 pname = "wai";

16728 version = "3.0.2.3";

16729 sha256 = "1mrry121xjgd2h69m35khgsiicrwhg7ysa7mzm6bw3ac41xc08ns";

16730 configureFlags = [

16731 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16732 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16733 "-fsplitbase" "-f-test-hlint"

16734 ];

16735 libraryHaskellDepends = [

16736 base blaze-builder bytestring http-types network text vault

16737 ];

16738 testHaskellDepends = [ base blaze-builder bytestring hspec ];

16739 homepage = "https://github.com/yesodweb/wai";

16740 description = "Web Application Interface";

16741 license = stdenv.lib.licenses.mit;

16742 }) {};

16743 "wai-app-static" = callPackage

16744 ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html

16745 , blaze-markup, byteable, bytestring, containers, cryptohash

16746 , cryptohash-conduit, directory, file-embed, filepath, hspec

16747 , http-date, http-types, mime-types, network, old-locale

16748 , optparse-applicative, system-fileio, system-filepath

16749 , template-haskell, text, time, transformers, unix-compat

16750 , unordered-containers, wai, wai-extra, warp, zlib

16751 }:

16752 mkDerivation {

16753 pname = "wai-app-static";

16754 version = "3.0.0.6";

16755 sha256 = "0ilwlawffvib1p98q5jcc5m2i93n7iwmszwlbkb3ihlh1wz5q2b8";

16756 revision = "1";

16757 editedCabalFile = "0i4q7kyga3kq6n24zd80m8w7m0avffrrx48iyfwgw4356c9ky6p5";

16758 configureFlags = [

16759 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16760 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16761 "-fsplitbase" "-f-test-hlint"

16762 ];

16763 isLibrary = true;

16764 isExecutable = true;

16765 libraryHaskellDepends = [

16766 base base64-bytestring blaze-builder blaze-html blaze-markup

16767 byteable bytestring containers cryptohash cryptohash-conduit

16768 directory file-embed filepath http-date http-types mime-types

16769 old-locale optparse-applicative system-fileio system-filepath

16770 template-haskell text time transformers unix-compat

16771 unordered-containers wai wai-extra warp zlib

16772 ];

16773 executableHaskellDepends = [

16774 base bytestring containers directory mime-types text

16775 ];

16776 testHaskellDepends = [

16777 base bytestring hspec http-date http-types mime-types network

16778 old-locale text time transformers unix-compat wai wai-extra zlib

16779 ];

16780 homepage = "http://www.yesodweb.com/book/web-application-interface";

16781 description = "WAI application for static serving";

16782 license = stdenv.lib.licenses.mit;

16783 }) {};

16784 "wai-conduit" = callPackage

16785 ({ mkDerivation, base, blaze-builder, bytestring, conduit

16786 , http-types, transformers, wai

16787 }:

16788 mkDerivation {

16789 pname = "wai-conduit";

16790 version = "3.0.0.2";

16791 sha256 = "1wqn8biq0ghz7ikmlq7x7vpdq2yc7mk9rnz9vlng7vcm7wpqilj7";

16792 configureFlags = [

16793 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16794 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16795 "-fsplitbase" "-f-test-hlint"

16796 ];

16797 libraryHaskellDepends = [

16798 base blaze-builder bytestring conduit http-types transformers wai

16799 ];

16800 homepage = "https://github.com/yesodweb/wai";

16801 description = "conduit wrappers for WAI";

16802 license = stdenv.lib.licenses.mit;

16803 }) {};

16804 "wai-eventsource" = callPackage

16805 ({ mkDerivation, wai }:

16806 mkDerivation {

16807 pname = "wai-eventsource";

16808 version = "3.0.0";

16809 sha256 = "1h5zlqky7ldqbmiaixizhk1s8ghf5i3ha1xfz8flxgzr7gr0al3q";

16810 configureFlags = [

16811 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16812 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16813 "-fsplitbase" "-f-test-hlint"

16814 ];

16815 libraryHaskellDepends = [ wai ];

16816 doHaddock = false;

16817 homepage = "http://www.yesodweb.com/book/web-application-interface";

16818 description = "WAI support for server-sent events (deprecated)";

16819 license = stdenv.lib.licenses.mit;

16820 }) {};

16821 "wai-extra" = callPackage

16822 ({ mkDerivation, ansi-terminal, base, base64-bytestring

16823 , blaze-builder, bytestring, case-insensitive, containers

16824 , data-default-class, deepseq, directory, fast-logger, hspec

16825 , http-types, HUnit, lifted-base, network, old-locale, resourcet

16826 , streaming-commons, stringsearch, text, time, transformers, unix

16827 , unix-compat, void, wai, wai-logger, word8, zlib

16828 }:

16829 mkDerivation {

16830 pname = "wai-extra";

16831 version = "3.0.5";

16832 sha256 = "1z4ifsldm1j6kf7jnbq8j4pk39f5d51yrygaxfs1m3mnnvr8xl52";

16833 configureFlags = [

16834 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16835 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16836 "-fsplitbase" "-f-test-hlint"

16837 ];

16838 libraryHaskellDepends = [

16839 ansi-terminal base base64-bytestring blaze-builder bytestring

16840 case-insensitive containers data-default-class deepseq directory

16841 fast-logger http-types lifted-base network old-locale resourcet

16842 streaming-commons stringsearch text time transformers unix

16843 unix-compat void wai wai-logger word8

16844 ];

16845 testHaskellDepends = [

16846 base bytestring fast-logger hspec http-types HUnit resourcet text

16847 transformers wai zlib

16848 ];

16849 homepage = "http://github.com/yesodweb/wai";

16850 description = "Provides some basic WAI handlers and middleware";

16851 license = stdenv.lib.licenses.mit;

16852 }) {};

16853 "wai-logger" = callPackage

16854 ({ mkDerivation, auto-update, base, blaze-builder, byteorder

16855 , bytestring, case-insensitive, doctest, easy-file, fast-logger

16856 , http-types, network, unix, unix-time, wai

16857 }:

16858 mkDerivation {

16859 pname = "wai-logger";

16860 version = "2.2.4";

16861 sha256 = "0l7jd3fczn1hp5d7bbhkk0qflw320sr2yw9gb10jvsv42rs1kdbv";

16862 configureFlags = [

16863 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16864 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16865 "-fsplitbase" "-f-test-hlint"

16866 ];

16867 libraryHaskellDepends = [

16868 auto-update base blaze-builder byteorder bytestring

16869 case-insensitive easy-file fast-logger http-types network unix

16870 unix-time wai

16871 ];

16872 testHaskellDepends = [ base doctest ];

16873 doCheck = false;

16874 description = "A logging system for WAI";

16875 license = stdenv.lib.licenses.bsd3;

16876 }) {};

16877 "wai-middleware-static" = callPackage

16878 ({ mkDerivation, base, bytestring, containers, directory, filepath

16879 , http-types, mtl, text, wai

16880 }:

16881 mkDerivation {

16882 pname = "wai-middleware-static";

16883 version = "0.6.0.1";

16884 sha256 = "1ylf2nm535d3dw0ksa9dfz1b4b78mqzkdrpdfd5pxswcqbgs266d";

16885 configureFlags = [

16886 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16887 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16888 "-fsplitbase" "-f-test-hlint"

16889 ];

16890 libraryHaskellDepends = [

16891 base bytestring containers directory filepath http-types mtl text

16892 wai

16893 ];

16894 homepage = "https://github.com/scotty-web/wai-middleware-static";

16895 description = "WAI middleware that serves requests to static files";

16896 license = stdenv.lib.licenses.bsd3;

16897 }) {};

16898 "wai-websockets" = callPackage

16899 ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive

16900 , file-embed, http-types, network, text, transformers, wai

16901 , wai-app-static, warp, websockets

16902 }:

16903 mkDerivation {

16904 pname = "wai-websockets";

16905 version = "3.0.0.5";

16906 sha256 = "1gqivkjdvln6xpkhcr6k75gk2qvjp6mr691902w3m6xpcdv1q5z0";

16907 configureFlags = [

16908 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16909 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16910 "-fsplitbase" "-f-test-hlint"

16911 ];

16912 isLibrary = true;

16913 isExecutable = true;

16914 libraryHaskellDepends = [

16915 base blaze-builder bytestring case-insensitive http-types network

16916 transformers wai websockets

16917 ];

16918 executableHaskellDepends = [

16919 base blaze-builder bytestring case-insensitive file-embed

16920 http-types network text transformers wai wai-app-static warp

16921 websockets

16922 ];

16923 homepage = "http://github.com/yesodweb/wai";

16924 description = "Provide a bridge betweeen WAI and the websockets package";

16925 license = stdenv.lib.licenses.mit;

16926 }) {};

16927 "warp" = callPackage

16928 ({ mkDerivation, array, async, auto-update, base, blaze-builder

16929 , bytestring, case-insensitive, criterion, doctest, ghc-prim

16930 , hashable, hspec, HTTP, http-date, http-types, HUnit, iproute

16931 , lifted-base, network, old-locale, QuickCheck, simple-sendfile

16932 , streaming-commons, text, time, transformers, unix, unix-compat

16933 , vault, void, wai

16934 }:

16935 mkDerivation {

16936 pname = "warp";

16937 version = "3.0.10.1";

16938 sha256 = "1v3fffc12psj22p3b98ax1q7gx4v3z75sl68g9b7gj5hgnb2jaxh";

16939 revision = "1";

16940 editedCabalFile = "15xxzzqbkig8zidzk8hbyqwpcic2ifd8wqnz452f0jvaxdq3q1di";

16941 configureFlags = [

16942 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16943 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16944 "-fsplitbase" "-f-test-hlint"

16945 ];

16946 libraryHaskellDepends = [

16947 array auto-update base blaze-builder bytestring case-insensitive

16948 ghc-prim hashable http-date http-types iproute network

16949 simple-sendfile streaming-commons text unix unix-compat vault void

16950 wai

16951 ];

16952 testHaskellDepends = [

16953 array async auto-update base blaze-builder bytestring

16954 case-insensitive doctest ghc-prim hashable hspec HTTP http-date

16955 http-types HUnit iproute lifted-base network old-locale QuickCheck

16956 simple-sendfile streaming-commons text time transformers unix

16957 unix-compat vault void wai

16958 ];

16959 benchmarkHaskellDepends = [

16960 base bytestring criterion http-types network

16961 ];

16962 doCheck = false;

16963 homepage = "http://github.com/yesodweb/wai";

16964 description = "A fast, light-weight web server for WAI applications";

16965 license = stdenv.lib.licenses.mit;

16966 }) {};

16967 "warp-tls" = callPackage

16968 ({ mkDerivation, base, bytestring, cprng-aes, data-default-class

16969 , network, streaming-commons, tls, wai, warp

16970 }:

16971 mkDerivation {

16972 pname = "warp-tls";

16973 version = "3.0.3";

16974 sha256 = "1ngprhmf58i80fkw2z750pxavyv05g3sr8j7hd24h47msmghq9mm";

16975 revision = "1";

16976 editedCabalFile = "19l8cixai5cds70hjqqmq41cc9wm49wgfz2gsbi9h9q9fbk1dnaz";

16977 configureFlags = [

16978 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

16979 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

16980 "-fsplitbase" "-f-test-hlint"

16981 ];

16982 libraryHaskellDepends = [

16983 base bytestring cprng-aes data-default-class network

16984 streaming-commons tls wai warp

16985 ];

16986 homepage = "http://github.com/yesodweb/wai";

16987 description = "HTTP over SSL/TLS support for Warp via the TLS package";

16988 license = stdenv.lib.licenses.mit;

16989 }) {};

16990 "web-fpco" = callPackage

16991 ({ mkDerivation, base, happstack-server, safe, snap, snap-core

16992 , snap-server

16993 }:

16994 mkDerivation {

16995 pname = "web-fpco";

16996 version = "0.1.1.0";

16997 sha256 = "1iizmg1syjywd5hs9swcqxxzmix04hwa86p8c246xybwcklf667n";

16998 configureFlags = [

16999 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17000 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17001 "-fsplitbase" "-f-test-hlint"

17002 ];

17003 libraryHaskellDepends = [

17004 base happstack-server safe snap snap-core snap-server

17005 ];

17006 homepage = "https://github.com/fpco/web-fpco";

17007 description = "Wrappers for web frameworks to ease usage with the FP Complete environment";

17008 license = stdenv.lib.licenses.mit;

17009 }) {};

17010 "webdriver" = callPackage

17011 ({ mkDerivation, aeson, attoparsec, base, base64-bytestring

17012 , bytestring, cond, data-default, directory, directory-tree

17013 , exceptions, filepath, http-client, http-types, lifted-base

17014 , monad-control, mtl, network, network-uri, parallel, scientific

17015 , temporary, text, time, transformers, transformers-base

17016 , unordered-containers, vector, zip-archive

17017 }:

17018 mkDerivation {

17019 pname = "webdriver";

17020 version = "0.6.1";

17021 sha256 = "1464i2hzriimhykgi0sinndyz3r7vajkzpwyp80fc75piq6vr7wi";

17022 configureFlags = [

17023 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17024 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17025 "-fsplitbase" "-f-test-hlint"

17026 ];

17027 libraryHaskellDepends = [

17028 aeson attoparsec base base64-bytestring bytestring cond

17029 data-default directory directory-tree exceptions filepath

17030 http-client http-types lifted-base monad-control mtl network

17031 network-uri scientific temporary text time transformers

17032 transformers-base unordered-containers vector zip-archive

17033 ];

17034 testHaskellDepends = [ base parallel text ];

17035 doCheck = false;

17036 homepage = "https://github.com/kallisti-dev/hs-webdriver";

17037 description = "a Haskell client for the Selenium WebDriver protocol";

17038 license = stdenv.lib.licenses.bsd3;

17039 }) {};

17040 "websockets" = callPackage

17041 ({ mkDerivation, attoparsec, base, base64-bytestring, binary

17042 , blaze-builder, bytestring, case-insensitive, containers, entropy

17043 , HUnit, mtl, network, QuickCheck, random, SHA, test-framework

17044 , test-framework-hunit, test-framework-quickcheck2, text

17045 }:

17046 mkDerivation {

17047 pname = "websockets";

17048 version = "0.9.3.1";

17049 sha256 = "0yqq2jj22a17n0cqcd54f0a7vjwwak2zr3wybbh1iq6gz0p5qf76";

17050 revision = "1";

17051 editedCabalFile = "08h149clmqgry4pvsbmqpnm85msxvi70jil8sh138ca56anjk15h";

17052 configureFlags = [

17053 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17054 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17055 "-fsplitbase" "-f-test-hlint"

17056 ];

17057 libraryHaskellDepends = [

17058 attoparsec base base64-bytestring binary blaze-builder bytestring

17059 case-insensitive containers entropy mtl network random SHA text

17060 ];

17061 testHaskellDepends = [

17062 attoparsec base base64-bytestring binary blaze-builder bytestring

17063 case-insensitive containers entropy HUnit mtl network QuickCheck

17064 random SHA test-framework test-framework-hunit

17065 test-framework-quickcheck2 text

17066 ];

17067 homepage = "http://jaspervdj.be/websockets";

17068 description = "A sensible and clean way to write WebSocket-capable servers in Haskell";

17069 license = stdenv.lib.licenses.bsd3;

17070 }) {};

17071 "wizards" = callPackage

17072 ({ mkDerivation, base, containers, control-monad-free, haskeline

17073 , mtl, transformers

17074 }:

17075 mkDerivation {

17076 pname = "wizards";

17077 version = "1.0.2";

17078 sha256 = "02yk9d01d39c3hpvlh2c6v35fzyf3nm92f6vff0qns30dmr2r8ab";

17079 revision = "1";

17080 editedCabalFile = "15vwynd5v6xm92dxkxf125grd8sv599n5bnj92qqmhlc89psxhxk";

17081 configureFlags = [

17082 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17083 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17084 "-fsplitbase" "-f-test-hlint"

17085 ];

17086 libraryHaskellDepends = [

17087 base containers control-monad-free haskeline mtl transformers

17088 ];

17089 description = "High level, generic library for interrogative user interfaces";

17090 license = stdenv.lib.licenses.bsd3;

17091 }) {};

17092 "wl-pprint" = callPackage

17093 ({ mkDerivation, base }:

17094 mkDerivation {

17095 pname = "wl-pprint";

17096 version = "1.1";

17097 sha256 = "16kp3fkh0x9kgzk6fdqrm8m0v7b5cgbv0m3x63ybbp5vxbhand06";

17098 revision = "1";

17099 editedCabalFile = "1vbagi930lj362vjvq95jq1gc9d9vvk6p5kx1ybwyxrv98vb9wgs";

17100 configureFlags = [

17101 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17102 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17103 "-fsplitbase" "-f-test-hlint"

17104 ];

17105 libraryHaskellDepends = [ base ];

17106 description = "The Wadler/Leijen Pretty Printer";

17107 license = stdenv.lib.licenses.bsd3;

17108 }) {};

17109 "wl-pprint-extras" = callPackage

17110 ({ mkDerivation, base, containers, HUnit, nats, semigroupoids

17111 , semigroups, test-framework, test-framework-hunit, text

17112 , utf8-string

17113 }:

17114 mkDerivation {

17115 pname = "wl-pprint-extras";

17116 version = "3.5.0.4";

17117 sha256 = "0mvg5vff574xvrdbdwnyy71kxv0cp0q5vv8fb12fbgydnvsy3mbl";

17118 configureFlags = [

17119 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17120 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17121 "-fsplitbase" "-f-test-hlint"

17122 ];

17123 libraryHaskellDepends = [

17124 base containers nats semigroupoids semigroups text utf8-string

17125 ];

17126 testHaskellDepends = [

17127 base HUnit test-framework test-framework-hunit

17128 ];

17129 homepage = "http://github.com/ekmett/wl-pprint-extras/";

17130 description = "A free monad based on the Wadler/Leijen pretty printer";

17131 license = stdenv.lib.licenses.bsd3;

17132 }) {};

17133 "wl-pprint-terminfo" = callPackage

17134 ({ mkDerivation, base, bytestring, containers, nats, semigroups

17135 , terminfo, text, transformers, wl-pprint-extras

17136 }:

17137 mkDerivation {

17138 pname = "wl-pprint-terminfo";

17139 version = "3.7.1.3";

17140 sha256 = "19z5cr1wqc3xcy39dswx78b6fpxhb41798zkiwkmb97nnvzwbdmv";

17141 configureFlags = [

17142 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17143 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17144 "-fsplitbase" "-f-test-hlint"

17145 ];

17146 enableSeparateDataOutput = true;

17147 libraryHaskellDepends = [

17148 base bytestring containers nats semigroups terminfo text

17149 transformers wl-pprint-extras

17150 ];

17151 homepage = "http://github.com/ekmett/wl-pprint-terminfo/";

17152 description = "A color pretty printer with terminfo support";

17153 license = stdenv.lib.licenses.bsd3;

17154 }) {};

17155 "wl-pprint-text" = callPackage

17156 ({ mkDerivation, base, text }:

17157 mkDerivation {

17158 pname = "wl-pprint-text";

17159 version = "1.1.0.3";

17160 sha256 = "1ghrkqdfsdkn71mpipbxiaar2gd8mdyd3dxbsz68awwnlpapy4f3";

17161 configureFlags = [

17162 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17163 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17164 "-fsplitbase" "-f-test-hlint"

17165 ];

17166 libraryHaskellDepends = [ base text ];

17167 description = "A Wadler/Leijen Pretty Printer for Text values";

17168 license = stdenv.lib.licenses.bsd3;

17169 }) {};

17170 "word8" = callPackage

17171 ({ mkDerivation, base, bytestring, criterion, hspec }:

17172 mkDerivation {

17173 pname = "word8";

17174 version = "0.1.2";

17175 sha256 = "1pbn8ra3qhwvw07p375cdmp7jzlg07hgdcr4cpscz3h7b9sy7fiw";

17176 configureFlags = [

17177 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17178 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17179 "-fsplitbase" "-f-test-hlint"

17180 ];

17181 libraryHaskellDepends = [ base ];

17182 testHaskellDepends = [ base hspec ];

17183 benchmarkHaskellDepends = [ base bytestring criterion ];

17184 description = "Word8 library";

17185 license = stdenv.lib.licenses.bsd3;

17186 }) {};

17187 "wordpass" = callPackage

17188 ({ mkDerivation, base, containers, deepseq, directory, filepath

17189 , hflags, random-fu, random-source, text, unix-compat, vector

17190 }:

17191 mkDerivation {

17192 pname = "wordpass";

17193 version = "1.0.0.3";

17194 sha256 = "1nbgzrc3g3kcc8462sqskdywk0n1m54810r0jsw8ip2xllvkxx9b";

17195 configureFlags = [

17196 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17197 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17198 "-fsplitbase" "-f-test-hlint"

17199 ];

17200 isLibrary = true;

17201 isExecutable = true;

17202 libraryHaskellDepends = [

17203 base containers deepseq directory filepath random-fu random-source

17204 text unix-compat vector

17205 ];

17206 executableHaskellDepends = [

17207 base containers deepseq directory filepath hflags random-fu

17208 random-source text unix-compat vector

17209 ];

17210 homepage = "https://github.com/mgajda/wordpass";

17211 description = "Dictionary-based password generator";

17212 license = stdenv.lib.licenses.bsd3;

17213 }) {};

17214 "x509" = callPackage

17215 ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, base

17216 , bytestring, containers, crypto-pubkey-types, cryptohash

17217 , directory, filepath, hourglass, mtl, pem, process, tasty

17218 , tasty-quickcheck

17219 }:

17220 mkDerivation {

17221 pname = "x509";

17222 version = "1.5.0.1";

17223 sha256 = "03gj4190f0ql1ghn2mri8901xdydhhnwijyfn8lmpjyn7pgpl3ba";

17224 revision = "1";

17225 editedCabalFile = "0z8mhdvpxv71iacnry4g56wnrn7k039sn55h655z5sqalkdic6i6";

17226 configureFlags = [

17227 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17228 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17229 "-fsplitbase" "-f-test-hlint"

17230 ];

17231 libraryHaskellDepends = [

17232 asn1-encoding asn1-parse asn1-types base bytestring containers

17233 crypto-pubkey-types cryptohash directory filepath hourglass mtl pem

17234 process

17235 ];

17236 testHaskellDepends = [

17237 asn1-types base bytestring crypto-pubkey-types hourglass mtl tasty

17238 tasty-quickcheck

17239 ];

17240 homepage = "http://github.com/vincenthz/hs-certificate";

17241 description = "X509 reader and writer";

17242 license = stdenv.lib.licenses.bsd3;

17243 }) {};

17244 "x509-store" = callPackage

17245 ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring

17246 , containers, crypto-pubkey-types, directory, filepath, mtl, pem

17247 , process, x509

17248 }:

17249 mkDerivation {

17250 pname = "x509-store";

17251 version = "1.5.0";

17252 sha256 = "1w9sqb007s4avjzvrdwq13a4c528h7h2lg3m8cl31syrgznc9ny5";

17253 configureFlags = [

17254 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17255 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17256 "-fsplitbase" "-f-test-hlint"

17257 ];

17258 libraryHaskellDepends = [

17259 asn1-encoding asn1-types base bytestring containers

17260 crypto-pubkey-types directory filepath mtl pem process x509

17261 ];

17262 homepage = "http://github.com/vincenthz/hs-certificate";

17263 description = "X.509 collection accessing and storing methods";

17264 license = stdenv.lib.licenses.bsd3;

17265 }) {};

17266 "x509-system" = callPackage

17267 ({ mkDerivation, base, bytestring, containers, directory, filepath

17268 , mtl, pem, process, x509, x509-store

17269 }:

17270 mkDerivation {

17271 pname = "x509-system";

17272 version = "1.5.0";

17273 sha256 = "159zwg35nq42j1rl0p4x00hdf3iy48hd7kavz0rnpwd2p7ljamr3";

17274 configureFlags = [

17275 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17276 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17277 "-fsplitbase" "-f-test-hlint"

17278 ];

17279 libraryHaskellDepends = [

17280 base bytestring containers directory filepath mtl pem process x509

17281 x509-store

17282 ];

17283 homepage = "http://github.com/vincenthz/hs-certificate";

17284 description = "Handle per-operating-system X.509 accessors and storage";

17285 license = stdenv.lib.licenses.bsd3;

17286 }) {};

17287 "x509-validation" = callPackage

17288 ({ mkDerivation, asn1-encoding, asn1-types, base, byteable

17289 , bytestring, containers, crypto-pubkey, crypto-pubkey-types

17290 , cryptohash, data-default-class, directory, filepath, hourglass

17291 , mtl, network, pem, process, x509, x509-store

17292 }:

17293 mkDerivation {

17294 pname = "x509-validation";

17295 version = "1.5.1";

17296 sha256 = "19cp187id9hdlzkr7sbv2sdxqxnpjv0db09hwf3zdqqqxr30mn6x";

17297 configureFlags = [

17298 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17299 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17300 "-fsplitbase" "-f-test-hlint"

17301 ];

17302 libraryHaskellDepends = [

17303 asn1-encoding asn1-types base byteable bytestring containers

17304 crypto-pubkey crypto-pubkey-types cryptohash data-default-class

17305 directory filepath hourglass mtl network pem process x509

17306 x509-store

17307 ];

17308 homepage = "http://github.com/vincenthz/hs-certificate";

17309 description = "X.509 Certificate and CRL validation";

17310 license = stdenv.lib.licenses.bsd3;

17311 }) {};

17312 "xenstore" = callPackage

17313 ({ mkDerivation, base, bytestring, cereal, mtl, network }:

17314 mkDerivation {

17315 pname = "xenstore";

17316 version = "0.1.1";

17317 sha256 = "0x788lpkkxg7ds1bgnw0kvkf6pkfbknn7jy0njhz85k7rv4kidf2";

17318 configureFlags = [

17319 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17320 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17321 "-fsplitbase" "-f-test-hlint"

17322 ];

17323 isLibrary = true;

17324 isExecutable = true;

17325 libraryHaskellDepends = [ base bytestring cereal mtl network ];

17326 description = "Xenstore client access";

17327 license = stdenv.lib.licenses.bsd3;

17328 }) {};

17329 "xml" = callPackage

17330 ({ mkDerivation, base, bytestring, text }:

17331 mkDerivation {

17332 pname = "xml";

17333 version = "1.3.14";

17334 sha256 = "0g814lj7vaxvib2g3r734221k80k7ap9czv9hinifn8syals3l9j";

17335 configureFlags = [

17336 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17337 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17338 "-fsplitbase" "-f-test-hlint"

17339 ];

17340 libraryHaskellDepends = [ base bytestring text ];

17341 homepage = "http://code.galois.com";

17342 description = "A simple XML library";

17343 license = stdenv.lib.licenses.bsd3;

17344 }) {};

17345 "xml-conduit" = callPackage

17346 ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html

17347 , blaze-markup, bytestring, conduit, conduit-extra, containers

17348 , data-default, deepseq, hspec, HUnit, monad-control, resourcet

17349 , system-filepath, text, transformers, xml-types

17350 }:

17351 mkDerivation {

17352 pname = "xml-conduit";

17353 version = "1.2.3.3";

17354 sha256 = "0y5k2l6a4vl5gl8ch8gwjqyg0v2qkiwrixf0yb0ik71z8zb9ki8b";

17355 revision = "1";

17356 editedCabalFile = "0r1fvsp33y5wdyxc7rmcnf55b2k216ra47wnyixlhr53cvqdgkjx";

17357 configureFlags = [

17358 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17359 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17360 "-fsplitbase" "-f-test-hlint"

17361 ];

17362 libraryHaskellDepends = [

17363 attoparsec base blaze-builder blaze-html blaze-markup bytestring

17364 conduit conduit-extra containers data-default deepseq monad-control

17365 resourcet system-filepath text transformers xml-types

17366 ];

17367 testHaskellDepends = [

17368 base blaze-markup bytestring conduit containers hspec HUnit

17369 resourcet text transformers xml-types

17370 ];

17371 homepage = "http://github.com/snoyberg/xml";

17372 description = "Pure-Haskell utilities for dealing with XML with the conduit package";

17373 license = stdenv.lib.licenses.bsd3;

17374 }) {};

17375 "xml-hamlet" = callPackage

17376 ({ mkDerivation, base, containers, hspec, HUnit, parsec

17377 , shakespeare, template-haskell, text, xml-conduit

17378 }:

17379 mkDerivation {

17380 pname = "xml-hamlet";

17381 version = "0.4.0.10";

17382 sha256 = "0bvgd3xbc25d2zdmpzq1rxhr7rkglf0zpc8wy75j2yqv6ymylb6v";

17383 configureFlags = [

17384 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17385 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17386 "-fsplitbase" "-f-test-hlint"

17387 ];

17388 libraryHaskellDepends = [

17389 base containers parsec shakespeare template-haskell text

17390 xml-conduit

17391 ];

17392 testHaskellDepends = [

17393 base containers hspec HUnit parsec shakespeare template-haskell

17394 text xml-conduit

17395 ];

17396 homepage = "http://www.yesodweb.com/";

17397 description = "Hamlet-style quasiquoter for XML content";

17398 license = stdenv.lib.licenses.bsd3;

17399 }) {};

17400 "xml-types" = callPackage

17401 ({ mkDerivation, base, deepseq, text }:

17402 mkDerivation {

17403 pname = "xml-types";

17404 version = "0.3.4";

17405 sha256 = "1689ijr4xxh4shxxvd51wdkpc535kzv6liqg4m1prag96aq05r8y";

17406 configureFlags = [

17407 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17408 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17409 "-fsplitbase" "-f-test-hlint"

17410 ];

17411 libraryHaskellDepends = [ base deepseq text ];

17412 homepage = "https://john-millikin.com/software/haskell-xml/";

17413 description = "Basic types for representing XML";

17414 license = stdenv.lib.licenses.mit;

17415 }) {};

17416 "xmlgen" = callPackage

17417 ({ mkDerivation, base, blaze-builder, bytestring, containers

17418 , criterion, filepath, HUnit, hxt, mtl, process, QuickCheck, text

17419 , unix

17420 }:

17421 mkDerivation {

17422 pname = "xmlgen";

17423 version = "0.6.2.1";

17424 sha256 = "1rmsg9wxs0bsj0xpagxrm3fmlqd63b0dfyc21rx9jj76g9za29wh";

17425 configureFlags = [

17426 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17427 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17428 "-fsplitbase" "-f-test-hlint"

17429 ];

17430 libraryHaskellDepends = [

17431 base blaze-builder bytestring containers mtl text

17432 ];

17433 testHaskellDepends = [

17434 base bytestring containers filepath HUnit hxt process QuickCheck

17435 text unix

17436 ];

17437 benchmarkHaskellDepends = [ base bytestring criterion text ];

17438 doCheck = false;

17439 description = "Fast XML generation library";

17440 license = stdenv.lib.licenses.bsd3;

17441 }) {};

17442 "xmlhtml" = callPackage

17443 ({ mkDerivation, base, blaze-builder, blaze-html, blaze-markup

17444 , bytestring, containers, parsec, text, unordered-containers

17445 }:

17446 mkDerivation {

17447 pname = "xmlhtml";

17448 version = "0.2.3.4";

17449 sha256 = "0cv5jqzbq7mi5lcrnaxr5qaprp8biv1jlyzpjhwnwqzla6fqamfr";

17450 revision = "1";

17451 editedCabalFile = "1aa3hi46q1f9il9jyyabl33rny0fl3a5prhj9gm3xl5x3fw7xqqp";

17452 configureFlags = [

17453 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17454 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17455 "-fsplitbase" "-f-test-hlint"

17456 ];

17457 libraryHaskellDepends = [

17458 base blaze-builder blaze-html blaze-markup bytestring containers

17459 parsec text unordered-containers

17460 ];

17461 description = "XML parser and renderer with HTML 5 quirks mode";

17462 license = stdenv.lib.licenses.bsd3;

17463 }) {};

17464 "xss-sanitize" = callPackage

17465 ({ mkDerivation, attoparsec, base, containers, css-text, hspec

17466 , HUnit, network-uri, tagsoup, text, utf8-string

17467 }:

17468 mkDerivation {

17469 pname = "xss-sanitize";

17470 version = "0.3.5.5";

17471 sha256 = "05qmhd50bdy5z0nvqvrm25ax4i642gv6gkdn678flg6sckshr4s2";

17472 configureFlags = [

17473 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17474 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17475 "-fsplitbase" "-f-test-hlint"

17476 ];

17477 libraryHaskellDepends = [

17478 attoparsec base containers css-text network-uri tagsoup text

17479 utf8-string

17480 ];

17481 testHaskellDepends = [

17482 attoparsec base containers css-text hspec HUnit network-uri tagsoup

17483 text utf8-string

17484 ];

17485 homepage = "http://github.com/yesodweb/haskell-xss-sanitize";

17486 description = "sanitize untrusted HTML to prevent XSS attacks";

17487 license = stdenv.lib.licenses.bsd3;

17488 }) {};

17489 "yackage" = callPackage

17490 ({ mkDerivation, base, blaze-builder, blaze-html, bytestring, Cabal

17491 , cmdargs, conduit, containers, directory, http-conduit, http-types

17492 , shakespeare, tar, text, transformers, unordered-containers

17493 , vector, wai, warp, yaml, yesod-core, yesod-form, zlib

17494 }:

17495 mkDerivation {

17496 pname = "yackage";

17497 version = "0.7.0.7";

17498 sha256 = "168dcl2ham94k0wmf75lgazn6q82yfww5lpl24nhmdr3fwd4p6p1";

17499 configureFlags = [

17500 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17501 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17502 "-fsplitbase" "-f-test-hlint"

17503 ];

17504 isLibrary = false;

17505 isExecutable = true;

17506 executableHaskellDepends = [

17507 base blaze-builder blaze-html bytestring Cabal cmdargs conduit

17508 containers directory http-conduit http-types shakespeare tar text

17509 transformers unordered-containers vector wai warp yaml yesod-core

17510 yesod-form zlib

17511 ];

17512 doHaddock = false;

17513 homepage = "http://github.com/snoyberg/yackage";

17514 description = "Personal Hackage replacement for testing new packages";

17515 license = stdenv.lib.licenses.bsd3;

17516 }) {};

17517 "yaml" = callPackage

17518 ({ mkDerivation, aeson, aeson-qq, attoparsec, base, bytestring

17519 , conduit, containers, directory, enclosed-exceptions, filepath

17520 , hspec, hspec-expectations, HUnit, libyaml, resourcet, scientific

17521 , text, transformers, unordered-containers, vector

17522 }:

17523 mkDerivation {

17524 pname = "yaml";

17525 version = "0.8.10.1";

17526 sha256 = "1a8v8digg6mcc4gx4kgfg8wzgj18wdf40wv1b7n72dg1c8kr2xz9";

17527 configureFlags = [

17528 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17529 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17530 "-fsplitbase" "-fsystem-libyaml" "-f-test-hlint"

17531 ];

17532 isLibrary = true;

17533 isExecutable = true;

17534 libraryHaskellDepends = [

17535 aeson attoparsec base bytestring conduit containers directory

17536 enclosed-exceptions filepath resourcet scientific text transformers

17537 unordered-containers vector

17538 ];

17539 libraryPkgconfigDepends = [ libyaml ];

17540 executableHaskellDepends = [ aeson base bytestring ];

17541 testHaskellDepends = [

17542 aeson aeson-qq base bytestring conduit directory hspec

17543 hspec-expectations HUnit resourcet text transformers

17544 unordered-containers vector

17545 ];

17546 homepage = "http://github.com/snoyberg/yaml/";

17547 description = "Support for parsing and rendering YAML documents";

17548 license = stdenv.lib.licenses.bsd3;

17549 }) {inherit (pkgs) libyaml;};

17550 "yesod" = callPackage

17551 ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring

17552 , conduit-extra, data-default, directory, fast-logger

17553 , monad-control, monad-logger, safe, semigroups, shakespeare

17554 , streaming-commons, template-haskell, text, transformers, unix

17555 , unordered-containers, wai, wai-extra, wai-logger, warp, yaml

17556 , yesod-auth, yesod-core, yesod-form, yesod-persistent

17557 }:

17558 mkDerivation {

17559 pname = "yesod";

17560 version = "1.4.1.4";

17561 sha256 = "1av6s5nanq5y9fqlzq2yq95989gg1fyqlpzg6y5pl4dcc45srm1x";

17562 configureFlags = [

17563 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17564 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17565 "-fsplitbase" "-f-test-hlint"

17566 ];

17567 libraryHaskellDepends = [

17568 aeson base blaze-html blaze-markup bytestring conduit-extra

17569 data-default directory fast-logger monad-control monad-logger safe

17570 semigroups shakespeare streaming-commons template-haskell text

17571 transformers unix unordered-containers wai wai-extra wai-logger

17572 warp yaml yesod-auth yesod-core yesod-form yesod-persistent

17573 ];

17574 homepage = "http://www.yesodweb.com/";

17575 description = "Creation of type-safe, RESTful web applications";

17576 license = stdenv.lib.licenses.mit;

17577 }) {};

17578 "yesod-auth" = callPackage

17579 ({ mkDerivation, aeson, authenticate, base, base16-bytestring

17580 , base64-bytestring, binary, blaze-builder, blaze-html

17581 , blaze-markup, byteable, bytestring, conduit, conduit-extra

17582 , containers, cryptohash, data-default, email-validate, file-embed

17583 , http-client, http-conduit, http-types, lifted-base, mime-mail

17584 , network-uri, persistent, persistent-template, random, resourcet

17585 , safe, shakespeare, template-haskell, text, time, transformers

17586 , unordered-containers, wai, yesod-core, yesod-form

17587 , yesod-persistent

17588 }:

17589 mkDerivation {

17590 pname = "yesod-auth";

17591 version = "1.4.4";

17592 sha256 = "079ny0jdg68kxdp117y1av0d09fhpywbb8v9iyl867vswpb38b08";

17593 configureFlags = [

17594 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17595 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17596 "-fsplitbase" "-f-test-hlint"

17597 ];

17598 libraryHaskellDepends = [

17599 aeson authenticate base base16-bytestring base64-bytestring binary

17600 blaze-builder blaze-html blaze-markup byteable bytestring conduit

17601 conduit-extra containers cryptohash data-default email-validate

17602 file-embed http-client http-conduit http-types lifted-base

17603 mime-mail network-uri persistent persistent-template random

17604 resourcet safe shakespeare template-haskell text time transformers

17605 unordered-containers wai yesod-core yesod-form yesod-persistent

17606 ];

17607 homepage = "http://www.yesodweb.com/";

17608 description = "Authentication for Yesod";

17609 license = stdenv.lib.licenses.mit;

17610 }) {};

17611 "yesod-auth-deskcom" = callPackage

17612 ({ mkDerivation, aeson, base, base64-bytestring, byteable

17613 , bytestring, cipher-aes, cprng-aes, crypto-api, crypto-random

17614 , cryptohash, data-default, http-conduit, http-types

17615 , template-haskell, text, time, transformers, yesod-auth

17616 , yesod-core

17617 }:

17618 mkDerivation {

17619 pname = "yesod-auth-deskcom";

17620 version = "1.4.0";

17621 sha256 = "17lpkwrfc10rdmvkjg6qmbi7gysjjhqyh7n5d1mxgxhzxzqbi06w";

17622 configureFlags = [

17623 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17624 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17625 "-fsplitbase" "-f-test-hlint"

17626 ];

17627 libraryHaskellDepends = [

17628 aeson base base64-bytestring byteable bytestring cipher-aes

17629 cprng-aes crypto-api crypto-random cryptohash data-default

17630 http-conduit http-types template-haskell text time transformers

17631 yesod-auth yesod-core

17632 ];

17633 homepage = "https://github.com/prowdsponsor/yesod-auth-deskcom";

17634 description = "Desk.com remote authentication support for Yesod apps.";

17635 license = stdenv.lib.licenses.bsd3;

17636 }) {};

17637 "yesod-auth-fb" = callPackage

17638 ({ mkDerivation, aeson, base, bytestring, conduit, fb, http-conduit

17639 , lifted-base, shakespeare, text, time, transformers, wai

17640 , yesod-auth, yesod-core, yesod-fb

17641 }:

17642 mkDerivation {

17643 pname = "yesod-auth-fb";

17644 version = "1.6.6";

17645 sha256 = "00pk5vridic77laydkfhrixfv50ps7f15dxvcd44cn0z8s2d3y74";

17646 configureFlags = [

17647 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17648 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17649 "-fsplitbase" "-f-test-hlint"

17650 ];

17651 libraryHaskellDepends = [

17652 aeson base bytestring conduit fb http-conduit lifted-base

17653 shakespeare text time transformers wai yesod-auth yesod-core

17654 yesod-fb

17655 ];

17656 homepage = "https://github.com/prowdsponsor/yesod-auth-fb";

17657 description = "Authentication backend for Yesod using Facebook";

17658 license = stdenv.lib.licenses.bsd3;

17659 }) {};

17660 "yesod-auth-hashdb" = callPackage

17661 ({ mkDerivation, base, bytestring, cryptohash, hspec, persistent

17662 , pwstore-fast, text, yesod-auth, yesod-core, yesod-form

17663 , yesod-persistent

17664 }:

17665 mkDerivation {

17666 pname = "yesod-auth-hashdb";

17667 version = "1.4.2";

17668 sha256 = "0nzhwh9aka1a2fk9q7d1xy6wq1fvpl9kjsi4mxjqzvp61sjcmqrs";

17669 configureFlags = [

17670 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17671 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17672 "-fsplitbase" "-f-test-hlint"

17673 ];

17674 libraryHaskellDepends = [

17675 base bytestring cryptohash persistent pwstore-fast text yesod-auth

17676 yesod-core yesod-form yesod-persistent

17677 ];

17678 testHaskellDepends = [ base hspec text ];

17679 homepage = "https://github.com/paul-rouse/yesod-auth-hashdb";

17680 description = "Authentication plugin for Yesod";

17681 license = stdenv.lib.licenses.mit;

17682 }) {};

17683 "yesod-auth-oauth2" = callPackage

17684 ({ mkDerivation, aeson, authenticate, base, bytestring, hoauth2

17685 , http-conduit, http-types, lifted-base, network-uri, text

17686 , transformers, uuid, yesod-auth, yesod-core, yesod-form

17687 }:

17688 mkDerivation {

17689 pname = "yesod-auth-oauth2";

17690 version = "0.0.12";

17691 sha256 = "1n70cnab99ldx4pd9yi7v6lvc7f1psnicmvq7sm8am8p9yhf9bs0";

17692 configureFlags = [

17693 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17694 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17695 "-fsplitbase" "-f-test-hlint"

17696 ];

17697 libraryHaskellDepends = [

17698 aeson authenticate base bytestring hoauth2 http-conduit http-types

17699 lifted-base network-uri text transformers uuid yesod-auth

17700 yesod-core yesod-form

17701 ];

17702 homepage = "http://github.com/scan/yesod-auth-oauth2";

17703 description = "Library to authenticate with OAuth 2.0 for Yesod web applications.";

17704 license = stdenv.lib.licenses.bsd3;

17705 }) {};

17706 "yesod-bin" = callPackage

17707 ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder

17708 , bytestring, Cabal, conduit, conduit-extra, containers

17709 , data-default-class, directory, file-embed, filepath, fsnotify

17710 , ghc, ghc-paths, http-client, http-conduit, http-reverse-proxy

17711 , http-types, lifted-base, network, optparse-applicative, parsec

17712 , process, project-template, resourcet, shakespeare, split

17713 , streaming-commons, system-fileio, system-filepath, tar

17714 , template-haskell, text, time, transformers, transformers-compat

17715 , unix-compat, unordered-containers, wai, wai-extra, warp, yaml

17716 , zlib

17717 }:

17718 mkDerivation {

17719 pname = "yesod-bin";

17720 version = "1.4.5.1";

17721 sha256 = "0q5n2rcwz7qc5gs4r2kfc8dc7xg0khy9khzb1zgbfxl6bv9kvnk5";

17722 configureFlags = [

17723 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17724 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17725 "-fsplitbase" "-f-test-hlint"

17726 ];

17727 isLibrary = false;

17728 isExecutable = true;

17729 enableSeparateDataOutput = true;

17730 executableHaskellDepends = [

17731 attoparsec base base64-bytestring blaze-builder bytestring Cabal

17732 conduit conduit-extra containers data-default-class directory

17733 file-embed filepath fsnotify ghc ghc-paths http-client http-conduit

17734 http-reverse-proxy http-types lifted-base network

17735 optparse-applicative parsec process project-template resourcet

17736 shakespeare split streaming-commons system-fileio system-filepath

17737 tar template-haskell text time transformers transformers-compat

17738 unix-compat unordered-containers wai wai-extra warp yaml zlib

17739 ];

17740 doHaddock = false;

17741 homepage = "http://www.yesodweb.com/";

17742 description = "The yesod helper executable";

17743 license = stdenv.lib.licenses.mit;

17744 }) {};

17745 "yesod-core" = callPackage

17746 ({ mkDerivation, aeson, async, auto-update, base, blaze-builder

17747 , blaze-html, blaze-markup, bytestring, case-insensitive, cereal

17748 , clientsession, conduit, conduit-extra, containers, cookie

17749 , criterion, data-default, deepseq, directory, exceptions

17750 , fast-logger, hspec, hspec-expectations, http-types, HUnit

17751 , lifted-base, monad-control, monad-logger, mtl, mwc-random

17752 , network, old-locale, parsec, path-pieces, primitive, QuickCheck

17753 , random, resourcet, safe, semigroups, shakespeare

17754 , streaming-commons, template-haskell, text, time, transformers

17755 , transformers-base, unix-compat, unordered-containers, vector, wai

17756 , wai-extra, wai-logger, warp, word8

17757 }:

17758 mkDerivation {

17759 pname = "yesod-core";

17760 version = "1.4.9";

17761 sha256 = "10rf7xrb0zrqpiv8149z52h1jx4nr96ajs2pxdr9avazprls9jmb";

17762 configureFlags = [

17763 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17764 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17765 "-fsplitbase" "-f-test-hlint"

17766 ];

17767 libraryHaskellDepends = [

17768 aeson auto-update base blaze-builder blaze-html blaze-markup

17769 bytestring case-insensitive cereal clientsession conduit

17770 conduit-extra containers cookie data-default deepseq directory

17771 exceptions fast-logger http-types lifted-base monad-control

17772 monad-logger mtl mwc-random old-locale parsec path-pieces primitive

17773 random resourcet safe semigroups shakespeare template-haskell text

17774 time transformers transformers-base unix-compat

17775 unordered-containers vector wai wai-extra wai-logger warp word8

17776 ];

17777 testHaskellDepends = [

17778 async base blaze-builder bytestring clientsession conduit

17779 conduit-extra containers cookie hspec hspec-expectations http-types

17780 HUnit lifted-base mwc-random network path-pieces QuickCheck random

17781 resourcet shakespeare streaming-commons template-haskell text

17782 transformers wai wai-extra

17783 ];

17784 benchmarkHaskellDepends = [

17785 base blaze-html bytestring criterion text transformers

17786 ];

17787 homepage = "http://www.yesodweb.com/";

17788 description = "Creation of type-safe, RESTful web applications";

17789 license = stdenv.lib.licenses.mit;

17790 }) {};

17791 "yesod-eventsource" = callPackage

17792 ({ mkDerivation, base, blaze-builder, conduit, transformers, wai

17793 , wai-eventsource, wai-extra, yesod-core

17794 }:

17795 mkDerivation {

17796 pname = "yesod-eventsource";

17797 version = "1.4.0.1";

17798 sha256 = "0j2x2zfr1s5a8m22kf27r6bdw041vmgf9b4v2ylc89n4m0f0dv55";

17799 configureFlags = [

17800 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17801 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17802 "-fsplitbase" "-f-test-hlint"

17803 ];

17804 libraryHaskellDepends = [

17805 base blaze-builder conduit transformers wai wai-eventsource

17806 wai-extra yesod-core

17807 ];

17808 homepage = "http://www.yesodweb.com/";

17809 description = "Server-sent events support for Yesod apps";

17810 license = stdenv.lib.licenses.mit;

17811 }) {};

17812 "yesod-fay" = callPackage

17813 ({ mkDerivation, aeson, base, bytestring, data-default, directory

17814 , fay, fay-dom, monad-loops, process, pureMD5, shakespeare

17815 , system-fileio, system-filepath, template-haskell, text

17816 , transformers, utf8-string, yesod-core, yesod-form, yesod-static

17817 }:

17818 mkDerivation {

17819 pname = "yesod-fay";

17820 version = "0.7.1";

17821 sha256 = "0g17n7aqr1zhlh21dkl13rhac34nq8f77mj85kll6vgcs8nfidhl";

17822 configureFlags = [

17823 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17824 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17825 "-fsplitbase" "-f-test-hlint"

17826 ];

17827 libraryHaskellDepends = [

17828 aeson base bytestring data-default directory fay fay-dom

17829 monad-loops process pureMD5 shakespeare system-fileio

17830 system-filepath template-haskell text transformers utf8-string

17831 yesod-core yesod-form yesod-static

17832 ];

17833 homepage = "https://github.com/fpco/yesod-fay";

17834 description = "Utilities for using the Fay Haskell-to-JS compiler with Yesod";

17835 license = stdenv.lib.licenses.mit;

17836 }) {};

17837 "yesod-fb" = callPackage

17838 ({ mkDerivation, aeson, base, bytestring, conduit, crypto-api, fb

17839 , http-conduit, text, wai, yesod-core

17840 }:

17841 mkDerivation {

17842 pname = "yesod-fb";

17843 version = "0.3.4";

17844 sha256 = "09cymp9y21vawbgr6gcj41s5xkq6j22mvk0vgl3pnyq382j33rmp";

17845 configureFlags = [

17846 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17847 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17848 "-fsplitbase" "-f-test-hlint"

17849 ];

17850 libraryHaskellDepends = [

17851 aeson base bytestring conduit crypto-api fb http-conduit text wai

17852 yesod-core

17853 ];

17854 homepage = "https://github.com/prowdsponsor/yesod-fb";

17855 description = "Useful glue functions between the fb library and Yesod";

17856 license = stdenv.lib.licenses.bsd3;

17857 }) {};

17858 "yesod-form" = callPackage

17859 ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html

17860 , blaze-markup, byteable, bytestring, containers, data-default

17861 , email-validate, hspec, network-uri, persistent, resourcet

17862 , semigroups, shakespeare, template-haskell, text, time

17863 , transformers, wai, xss-sanitize, yesod-core, yesod-persistent

17864 }:

17865 mkDerivation {

17866 pname = "yesod-form";

17867 version = "1.4.4.1";

17868 sha256 = "14v4vhrbca0281im2bnvk36bm7i1r8yanxhv7lvrq5y5nqbc5bl3";

17869 configureFlags = [

17870 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17871 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17872 "-fsplitbase" "-f-test-hlint"

17873 ];

17874 libraryHaskellDepends = [

17875 aeson attoparsec base blaze-builder blaze-html blaze-markup

17876 byteable bytestring containers data-default email-validate

17877 network-uri persistent resourcet semigroups shakespeare

17878 template-haskell text time transformers wai xss-sanitize yesod-core

17879 yesod-persistent

17880 ];

17881 testHaskellDepends = [ base hspec text time ];

17882 homepage = "http://www.yesodweb.com/";

17883 description = "Form handling support for Yesod Web Framework";

17884 license = stdenv.lib.licenses.mit;

17885 }) {};

17886 "yesod-gitrepo" = callPackage

17887 ({ mkDerivation, base, directory, enclosed-exceptions, http-types

17888 , lifted-base, process, system-filepath, temporary, text, wai

17889 , yesod-core

17890 }:

17891 mkDerivation {

17892 pname = "yesod-gitrepo";

17893 version = "0.1.1.0";

17894 sha256 = "1bf4rhf6i4cciyllkh6zil29i7yi5ph0nkpcqmhbihk4i7xm05zj";

17895 configureFlags = [

17896 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17897 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17898 "-fsplitbase" "-f-test-hlint"

17899 ];

17900 libraryHaskellDepends = [

17901 base directory enclosed-exceptions http-types lifted-base process

17902 system-filepath temporary text wai yesod-core

17903 ];

17904 homepage = "https://github.com/snoyberg/yesod-gitrepo";

17905 description = "Host content provided by a Git repo";

17906 license = stdenv.lib.licenses.mit;

17907 }) {};

17908 "yesod-newsfeed" = callPackage

17909 ({ mkDerivation, base, blaze-html, blaze-markup, bytestring

17910 , containers, shakespeare, text, time, xml-conduit, yesod-core

17911 }:

17912 mkDerivation {

17913 pname = "yesod-newsfeed";

17914 version = "1.4.0.1";

17915 sha256 = "02ydkri23vrm7mak2b1ybfhkdgc2dmv9vq3ki2d7sd005sp3zdly";

17916 configureFlags = [

17917 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17918 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17919 "-fsplitbase" "-f-test-hlint"

17920 ];

17921 libraryHaskellDepends = [

17922 base blaze-html blaze-markup bytestring containers shakespeare text

17923 time xml-conduit yesod-core

17924 ];

17925 homepage = "http://www.yesodweb.com/";

17926 description = "Helper functions and data types for producing News feeds";

17927 license = stdenv.lib.licenses.mit;

17928 }) {};

17929 "yesod-persistent" = callPackage

17930 ({ mkDerivation, base, blaze-builder, conduit, hspec, persistent

17931 , persistent-sqlite, persistent-template, resource-pool, resourcet

17932 , text, transformers, wai-extra, yesod-core

17933 }:

17934 mkDerivation {

17935 pname = "yesod-persistent";

17936 version = "1.4.0.2";

17937 sha256 = "06qzgq0mb7k0h8q6lh47l0mzx91xn4ba07nmn22vsfvjfdji6lib";

17938 configureFlags = [

17939 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17940 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17941 "-fsplitbase" "-f-test-hlint"

17942 ];

17943 libraryHaskellDepends = [

17944 base blaze-builder conduit persistent persistent-template

17945 resource-pool resourcet transformers yesod-core

17946 ];

17947 testHaskellDepends = [

17948 base blaze-builder conduit hspec persistent persistent-sqlite text

17949 wai-extra yesod-core

17950 ];

17951 homepage = "http://www.yesodweb.com/";

17952 description = "Some helpers for using Persistent from Yesod";

17953 license = stdenv.lib.licenses.mit;

17954 }) {};

17955 "yesod-sitemap" = callPackage

17956 ({ mkDerivation, base, conduit, containers, data-default, text

17957 , time, xml-conduit, xml-types, yesod-core

17958 }:

17959 mkDerivation {

17960 pname = "yesod-sitemap";

17961 version = "1.4.0.1";

17962 sha256 = "0ri67r3yjngn4m2lj071n2v3r9w7pvsl24rayf41k7w9j3ylk100";

17963 configureFlags = [

17964 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17965 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17966 "-fsplitbase" "-f-test-hlint"

17967 ];

17968 libraryHaskellDepends = [

17969 base conduit containers data-default text time xml-conduit

17970 xml-types yesod-core

17971 ];

17972 homepage = "http://www.yesodweb.com/";

17973 description = "Generate XML sitemaps";

17974 license = stdenv.lib.licenses.mit;

17975 }) {};

17976 "yesod-static" = callPackage

17977 ({ mkDerivation, async, attoparsec, base, base64-bytestring

17978 , blaze-builder, byteable, bytestring, conduit, conduit-extra

17979 , containers, cryptohash, cryptohash-conduit, css-text

17980 , data-default, directory, file-embed, filepath, hashable, hjsmin

17981 , hspec, http-types, HUnit, mime-types, old-time, process

17982 , resourcet, system-fileio, system-filepath, template-haskell, text

17983 , transformers, unix-compat, unordered-containers, wai

17984 , wai-app-static, wai-extra, yesod-core, yesod-test

17985 }:

17986 mkDerivation {

17987 pname = "yesod-static";

17988 version = "1.4.0.4";

17989 sha256 = "1z01m3rvar6djxqcc2hyi53yfcpqwpi45wffpjnfp8hsr1x0zaqk";

17990 revision = "1";

17991 editedCabalFile = "1iick4vkr84m2gsg2p170q2j40zihba8k82ispb2ymgdpr92cf74";

17992 configureFlags = [

17993 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

17994 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

17995 "-fsplitbase" "-f-test-hlint"

17996 ];

17997 libraryHaskellDepends = [

17998 async attoparsec base base64-bytestring blaze-builder byteable

17999 bytestring conduit conduit-extra containers cryptohash

18000 cryptohash-conduit css-text data-default directory file-embed

18001 filepath hashable hjsmin http-types mime-types old-time process

18002 resourcet system-fileio system-filepath template-haskell text

18003 transformers unix-compat unordered-containers wai wai-app-static

18004 yesod-core

18005 ];

18006 testHaskellDepends = [

18007 async base base64-bytestring byteable bytestring conduit

18008 conduit-extra containers cryptohash cryptohash-conduit data-default

18009 directory file-embed filepath hjsmin hspec http-types HUnit

18010 mime-types old-time process resourcet system-fileio system-filepath

18011 template-haskell text transformers unix-compat unordered-containers

18012 wai wai-app-static wai-extra yesod-core yesod-test

18013 ];

18014 homepage = "http://www.yesodweb.com/";

18015 description = "Static file serving subsite for Yesod Web Framework";

18016 license = stdenv.lib.licenses.mit;

18017 }) {};

18018 "yesod-test" = callPackage

18019 ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html

18020 , blaze-markup, bytestring, case-insensitive, containers, cookie

18021 , hspec, hspec-core, html-conduit, http-types, HUnit, monad-control

18022 , network, persistent, text, time, transformers, wai, wai-extra

18023 , xml-conduit, xml-types, yesod-core, yesod-form

18024 }:

18025 mkDerivation {

18026 pname = "yesod-test";

18027 version = "1.4.3.1";

18028 sha256 = "150kzp8h9wl3c1diz6h6m62qd6w0qz4drgrm095amb0sndrh37m2";

18029 configureFlags = [

18030 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

18031 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

18032 "-fsplitbase" "-f-test-hlint"

18033 ];

18034 libraryHaskellDepends = [

18035 attoparsec base blaze-builder blaze-html blaze-markup bytestring

18036 case-insensitive containers cookie hspec-core html-conduit

18037 http-types HUnit monad-control network persistent text time

18038 transformers wai wai-extra xml-conduit xml-types yesod-core

18039 ];

18040 testHaskellDepends = [

18041 base bytestring containers hspec html-conduit HUnit text wai

18042 xml-conduit yesod-core yesod-form

18043 ];

18044 homepage = "http://www.yesodweb.com";

18045 description = "integration testing for WAI/Yesod Applications";

18046 license = stdenv.lib.licenses.mit;

18047 }) {};

18048 "yesod-text-markdown" = callPackage

18049 ({ mkDerivation, aeson, base, markdown, persistent, shakespeare

18050 , text, yesod-core, yesod-form, yesod-persistent

18051 }:

18052 mkDerivation {

18053 pname = "yesod-text-markdown";

18054 version = "0.1.7";

18055 sha256 = "133zv2f8240qbygpza39m28k4hfy2aiqmr6ds8ihwbb8dz98d5rr";

18056 configureFlags = [

18057 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

18058 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

18059 "-fsplitbase" "-f-test-hlint"

18060 ];

18061 libraryHaskellDepends = [

18062 aeson base markdown persistent shakespeare text yesod-core

18063 yesod-form yesod-persistent

18064 ];

18065 description = "Yesod support for Text.Markdown.";

18066 license = stdenv.lib.licenses.bsd3;

18067 }) {};

18068 "yesod-websockets" = callPackage

18069 ({ mkDerivation, async, base, conduit, monad-control, transformers

18070 , wai, wai-websockets, websockets, yesod-core

18071 }:

18072 mkDerivation {

18073 pname = "yesod-websockets";

18074 version = "0.2.1.1";

18075 sha256 = "0ksmyag5h5i78jb7bdvsvq0wkyb82k8i4y5d2m6czvhf3i1zw6da";

18076 configureFlags = [

18077 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

18078 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

18079 "-fsplitbase" "-f-test-hlint"

18080 ];

18081 libraryHaskellDepends = [

18082 async base conduit monad-control transformers wai wai-websockets

18083 websockets yesod-core

18084 ];

18085 homepage = "https://github.com/yesodweb/yesod";

18086 description = "WebSockets support for Yesod";

18087 license = stdenv.lib.licenses.mit;

18088 }) {};

18089 "zeromq4-haskell" = callPackage

18090 ({ mkDerivation, async, base, bytestring, containers, exceptions

18091 , QuickCheck, semigroups, tasty, tasty-hunit, tasty-quickcheck

18092 , transformers, zeromq

18093 }:

18094 mkDerivation {

18095 pname = "zeromq4-haskell";

18096 version = "0.6.3";

18097 sha256 = "0yrwqxm208n9k76i9aby5hiv55kd1p27pq6hyry5ngw95fh95p67";

18098 configureFlags = [

18099 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

18100 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

18101 "-fsplitbase" "-f-test-hlint"

18102 ];

18103 libraryHaskellDepends = [

18104 async base bytestring containers exceptions semigroups transformers

18105 ];

18106 libraryPkgconfigDepends = [ zeromq ];

18107 testHaskellDepends = [

18108 async base bytestring QuickCheck tasty tasty-hunit tasty-quickcheck

18109 ];

18110 homepage = "http://github.com/twittner/zeromq-haskell/";

18111 description = "Bindings to ZeroMQ 4.x";

18112 license = stdenv.lib.licenses.mit;

18113 }) {inherit (pkgs) zeromq;};

18114 "zip-archive" = callPackage

18115 ({ mkDerivation, array, base, binary, bytestring, containers

18116 , digest, directory, filepath, HUnit, mtl, old-time, pretty

18117 , process, text, time, unix, zip, zlib

18118 }:

18119 mkDerivation {

18120 pname = "zip-archive";

18121 version = "0.2.3.7";

18122 sha256 = "169nkxr5zlbymiz1ydlhlqr66vqiycmg85xh559phpkr64w3nqj1";

18123 configureFlags = [

18124 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

18125 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

18126 "-fsplitbase" "-f-test-hlint"

18127 ];

18128 isLibrary = true;

18129 isExecutable = true;

18130 libraryHaskellDepends = [

18131 array base binary bytestring containers digest directory filepath

18132 mtl old-time pretty text time unix zlib

18133 ];

18134 executableHaskellDepends = [ base bytestring directory ];

18135 testHaskellDepends = [

18136 base bytestring directory HUnit old-time process time

18137 ];

18138 testToolDepends = [ zip ];

18139 homepage = "http://github.com/jgm/zip-archive";

18140 description = "Library for creating and modifying zip archives";

18141 license = stdenv.lib.licenses.bsd3;

18142 }) {inherit (pkgs) zip;};

18143 "zlib" = callPackage

18144 ({ mkDerivation, base, bytestring, zlib }:

18145 mkDerivation {

18146 pname = "zlib";

18147 version = "0.5.4.2";

18148 sha256 = "15hhsk7z3gvm7sz2ic2z1ca5c6rpsln2rr391mdbm1bxlzc1gmkm";

18149 configureFlags = [

18150 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

18151 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

18152 "-fsplitbase" "-f-test-hlint"

18153 ];

18154 libraryHaskellDepends = [ base bytestring ];

18155 librarySystemDepends = [ zlib ];

18156 description = "Compression and decompression in the gzip and zlib formats";

18157 license = stdenv.lib.licenses.bsd3;

18158 }) {inherit (pkgs) zlib;};

18159 "zlib-bindings" = callPackage

18160 ({ mkDerivation, base, bytestring, hspec, QuickCheck, zlib }:

18161 mkDerivation {

18162 pname = "zlib-bindings";

18163 version = "0.1.1.5";

18164 sha256 = "02ciywlz4wdlymgc3jsnicz9kzvymjw1www2163gxidnz4wb8fy8";

18165 revision = "2";

18166 editedCabalFile = "0fq49694gqkab8m0vq4i879blswczwd66n7xh4r4gwiahf0ryvqc";

18167 configureFlags = [

18168 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

18169 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

18170 "-fsplitbase" "-f-test-hlint"

18171 ];

18172 libraryHaskellDepends = [ base bytestring zlib ];

18173 testHaskellDepends = [ base bytestring hspec QuickCheck zlib ];

18174 homepage = "http://github.com/snapframework/zlib-bindings";

18175 description = "Low-level bindings to the zlib package";

18176 license = stdenv.lib.licenses.bsd3;

18177 }) {};

18178 "zlib-enum" = callPackage

18179 ({ mkDerivation, base, bytestring, enumerator, transformers

18180 , zlib-bindings

18181 }:

18182 mkDerivation {

18183 pname = "zlib-enum";

18184 version = "0.2.3.1";

18185 sha256 = "1nfczminxafzk69ry1sqkj1ha0jlv3l9ak10yk205snfhpmcjgg4";

18186 configureFlags = [

18187 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

18188 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

18189 "-fsplitbase" "-f-test-hlint"

18190 ];

18191 isLibrary = true;

18192 isExecutable = true;

18193 libraryHaskellDepends = [

18194 base bytestring enumerator transformers zlib-bindings

18195 ];

18196 homepage = "http://github.com/maltem/zlib-enum";

18197 description = "Enumerator interface for zlib compression";

18198 license = stdenv.lib.licenses.mit;

18199 }) {};

18200 "zlib-lens" = callPackage

18201 ({ mkDerivation, base, bytestring, profunctors, zlib }:

18202 mkDerivation {

18203 pname = "zlib-lens";

18204 version = "0.1.1.2";

18205 sha256 = "13zfh0639881nfxibl501f1b3ci9pjvhvdid2l5sf2na8kmpzr61";

18206 revision = "1";

18207 editedCabalFile = "1vdpqwjay045f1lpdcn01cn1rgbs06c9d6jizdsd6r9nbbcrdm9c";

18208 configureFlags = [

18209 "-fblaze_html_0_5" "-f-bytestring-in-base" "-fhttps"

18210 "-fnetwork-uri" "-fnew-base" "-fold-locale" "-fsmall_base"

18211 "-fsplitbase" "-f-test-hlint"

18212 ];

18213 libraryHaskellDepends = [ base bytestring profunctors zlib ];

18214 homepage = "http://lens.github.io/";

18215 description = "Lenses for zlib";

18216 license = stdenv.lib.licenses.bsd3;

18217 }) {};

18218

18219}