From c5d5b47e5aa729f1bd6d83090cfe74f86133c254 Mon Sep 17 00:00:00 2001 From: pranaysashank Date: Thu, 5 Dec 2024 00:16:42 +0000 Subject: [PATCH] Automatic Update --- ...308aee5e1c98ecf495b6743ff72bba07d515b5.nix | 41 ++++ ...4b4e1e14a60096d0a6131153d5f757eb0dc7b5.nix | 46 +++++ ...0128f88f4b0c1a1242699f7603a80963ba1f4a.nix | 46 +++++ ...886bdc8a88a08dc0e095fa63250b0977328f03.nix | 37 ++++ ...b644a0eb5e1f6179366b16177ef68a5d4cdb15.nix | 40 ++++ ...2a6d980ef2bbf0c51f2a2449a323075202ab4f.nix | 69 +++++++ ...fe232b25b75f55e1e8b36f8578dcefa4bb99d6.nix | 38 ++++ ...b6ad9615d3c87218959b989e72c398ec1f3572.nix | 58 ++++++ ...624f46544a6afe1c149053294d80d60f6eafd4.nix | 55 ++++++ ...52c99e69ed2ce7f2d6c14e464ef6ff590cf8fb.nix | 70 +++++++ ...91f527b11b5489f2566930a05f29fb872fd0ef.nix | 40 ++++ ...8bf869ea8ab8ebe878964daec0f6478ab53bb3.nix | 36 ++++ ...2a4a10b7f11998d3842cfc367b6b5563c3f580.nix | 38 ++++ ...09e6a2ca0185563976a8000632ea45609e08c4.nix | 50 +++++ ...bd9d03938a11b91e2fe8c94ded99520128764e.nix | 182 ++++++++++++++++++ ...38289e82b3b5e83b2383600b2c838a68218068.nix | 31 +++ ...a106a9c61c01981678610d6a0e2be5ab4f9ea0.nix | 78 ++++++++ ...b7990b7c76049c097a2d95cd901380fd129d67.nix | 37 ++++ ...c55cdfe90f8ef7db426498b1e251ed175ce855.nix | 38 ++++ ...0bba1a8bad673743be80bc357788652006d07c.nix | 45 +++++ ...57d36632adbbac8678ff0cb1e8dbe690e53d0b.nix | 42 ++++ ...23cddd0b283a5a867499f2143a1b279cec620d.nix | 41 ++++ ...6064543376395bed40a5a6ad12fba0e292ba43.nix | 58 ++++++ ...6aaf76a8d9aaf9fc4c0bca0190b4bfded48212.nix | 58 ++++++ ...ef2f248328fda5d0b65d1bbe9f363df572159b.nix | 58 ++++++ ...eddb54355859319c1eee0c8ceb5e8a6444e588.nix | 58 ++++++ ...288366fa09970cc2101f7245b096a4a99c82a8.nix | 58 ++++++ ...4e266877341fd1258f65acf5529d32924ecfd7.nix | 59 ++++++ ...29263b1f6fb34dbaa299336a69ec910a3a5115.nix | 59 ++++++ ...3fe6ded77365dce680f871de548792b3133569.nix | 60 ++++++ ...8b41241eb7aef5c71954806c8b85b7bd91384b.nix | 52 +++++ ...90123102c546ae1e2f924c3fdebba340a9381b.nix | 48 +++++ ...5ad21962b5840567379770bf2efc29822401fb.nix | 68 +++++++ ...7d70947734bb7dae35f6ba36cfbd0bb23c1fe3.nix | 47 +++++ ...89af310a8dcea9d3fa817df0b4b076909d8ab9.nix | 70 +++++++ index-state-hashes.nix | 1 + nix/_Click_Haskell.nix | 8 +- nix/bytes.nix | 18 ++ nix/charset.nix | 12 ++ nix/comonad.nix | 12 ++ nix/eventlog2html.nix | 8 +- nix/fedora-releases.nix | 12 ++ nix/ghc-lib-parser.nix | 8 +- nix/ghc-lib.nix | 8 +- nix/ghc-source-gen.nix | 12 ++ nix/gloss-algorithms.nix | 8 +- nix/gloss-rendering.nix | 8 +- nix/gloss.nix | 8 +- nix/half.nix | 12 ++ nix/haskoin-store.nix | 12 ++ nix/heaps.nix | 12 ++ nix/horizontal-rule.nix | 12 ++ nix/hybrid-vectors.nix | 12 ++ nix/intern.nix | 12 ++ nix/intervals.nix | 12 ++ nix/ip2location.nix | 12 ++ nix/ip2proxy.nix | 12 ++ nix/lawful-conversions.nix | 68 ++++++- nix/ngx-export-distribution.nix | 12 ++ nix/reflection.nix | 12 ++ nix/sqlite-easy.nix | 12 ++ nix/tasty-bench.nix | 8 +- nix/toxcore-c.nix | 12 ++ 63 files changed, 2257 insertions(+), 9 deletions(-) create mode 100644 hackage/ClickHaskell-0.1.0-r1-3f3f97114628d66a5ac3cc9a7e308aee5e1c98ecf495b6743ff72bba07d515b5.nix create mode 100644 hackage/bytes-0.17.4-r0-b83d3d91c4574a11221df328d14b4e1e14a60096d0a6131153d5f757eb0dc7b5.nix create mode 100644 hackage/bytes-0.17.4-r1-27b117394065d8b8bd845c54dc0128f88f4b0c1a1242699f7603a80963ba1f4a.nix create mode 100644 hackage/charset-0.3.11-r0-0521970d253950ae712425a03c886bdc8a88a08dc0e095fa63250b0977328f03.nix create mode 100644 hackage/comonad-5.0.9-r0-f7bf55e62c24e9a9f523dc63e8b644a0eb5e1f6179366b16177ef68a5d4cdb15.nix create mode 100644 hackage/eventlog2html-0.11.1-r1-5142ac71e1864d8b1d8ccfb0452a6d980ef2bbf0c51f2a2449a323075202ab4f.nix create mode 100644 hackage/fedora-releases-0.2.0-r0-a4abd965642628d5732a73f195fe232b25b75f55e1e8b36f8578dcefa4bb99d6.nix create mode 100644 hackage/ghc-lib-9.8.4.20241130-r1-7f8d71e34b78c341e1e5c60817b6ad9615d3c87218959b989e72c398ec1f3572.nix create mode 100644 hackage/ghc-lib-parser-9.8.4.20241130-r1-18d72b8794b507613f1e311b5d624f46544a6afe1c149053294d80d60f6eafd4.nix create mode 100644 hackage/ghc-source-gen-0.4.6.0-r0-e6a310d225e65f453fca3d365952c99e69ed2ce7f2d6c14e464ef6ff590cf8fb.nix create mode 100644 hackage/gloss-1.13.2.2-r2-31467330073c706f28a640b1c891f527b11b5489f2566930a05f29fb872fd0ef.nix create mode 100644 hackage/gloss-algorithms-1.13.0.3-r1-0601fb6c0cc5277028851759668bf869ea8ab8ebe878964daec0f6478ab53bb3.nix create mode 100644 hackage/gloss-rendering-1.13.1.2-r2-2047344b061332101a4c38a1902a4a10b7f11998d3842cfc367b6b5563c3f580.nix create mode 100644 hackage/half-0.3.2-r0-dc49517b0f8c2523218c55190909e6a2ca0185563976a8000632ea45609e08c4.nix create mode 100644 hackage/haskoin-store-1.5.14-r0-268683641ff4b96632ce279546bd9d03938a11b91e2fe8c94ded99520128764e.nix create mode 100644 hackage/heaps-0.4.1-r0-74ce60a23b8ef247b8bca71eeb38289e82b3b5e83b2383600b2c838a68218068.nix create mode 100644 hackage/horizontal-rule-0.7.0.0-r0-ae1b4bc0d9d69baac9eee14f8ba106a9c61c01981678610d6a0e2be5ab4f9ea0.nix create mode 100644 hackage/hybrid-vectors-0.2.5-r0-d4041e1e58b29ed60b8c4681c4b7990b7c76049c097a2d95cd901380fd129d67.nix create mode 100644 hackage/intern-0.9.6-r0-1a0c01d19739a9e575d001ad4fc55cdfe90f8ef7db426498b1e251ed175ce855.nix create mode 100644 hackage/intervals-0.9.3-r0-82f7df005cbd6edbc1c8860fa70bba1a8bad673743be80bc357788652006d07c.nix create mode 100644 hackage/ip2location-8.5.1-r0-461159aa584da4a8db78508d5557d36632adbbac8678ff0cb1e8dbe690e53d0b.nix create mode 100644 hackage/ip2proxy-3.2.1-r0-7d348bdcabbd691fbc7af2379a23cddd0b283a5a867499f2143a1b279cec620d.nix create mode 100644 hackage/lawful-conversions-0.1.1-r1-122baa7ec69d983da1feadeed66064543376395bed40a5a6ad12fba0e292ba43.nix create mode 100644 hackage/lawful-conversions-0.1.1-r2-9ec257c52deb296660e3cd18bc6aaf76a8d9aaf9fc4c0bca0190b4bfded48212.nix create mode 100644 hackage/lawful-conversions-0.1.1-r3-85762616fc1acbcf643f9da133ef2f248328fda5d0b65d1bbe9f363df572159b.nix create mode 100644 hackage/lawful-conversions-0.1.1-r4-0fc4fc2cfcc69ff336bbe0863eeddb54355859319c1eee0c8ceb5e8a6444e588.nix create mode 100644 hackage/lawful-conversions-0.1.1-r5-176e908155df2de5c499690b16288366fa09970cc2101f7245b096a4a99c82a8.nix create mode 100644 hackage/lawful-conversions-0.1.2.1-r0-ea31eeeaaaa7e023147b29b5604e266877341fd1258f65acf5529d32924ecfd7.nix create mode 100644 hackage/lawful-conversions-0.1.2.2-r0-23fc4bd62507c14053c670520b29263b1f6fb34dbaa299336a69ec910a3a5115.nix create mode 100644 hackage/lawful-conversions-0.1.3-r0-b0b635df17ad69f347a6249ec73fe6ded77365dce680f871de548792b3133569.nix create mode 100644 hackage/ngx-export-distribution-0.6.0.1-r0-306c61eabf0bd782dadea52c528b41241eb7aef5c71954806c8b85b7bd91384b.nix create mode 100644 hackage/reflection-2.1.9-r0-6f0ac9648b61040293e9257bac90123102c546ae1e2f924c3fdebba340a9381b.nix create mode 100644 hackage/sqlite-easy-1.1.1.0-r0-57538ee4bac16992b8561b1c205ad21962b5840567379770bf2efc29822401fb.nix create mode 100644 hackage/tasty-bench-0.4-r1-06e336ea94ae35f116318e535a7d70947734bb7dae35f6ba36cfbd0bb23c1fe3.nix create mode 100644 hackage/toxcore-c-0.2.19-r0-61959fb920dcdb1feb291486b489af310a8dcea9d3fa817df0b4b076909d8ab9.nix diff --git a/hackage/ClickHaskell-0.1.0-r1-3f3f97114628d66a5ac3cc9a7e308aee5e1c98ecf495b6743ff72bba07d515b5.nix b/hackage/ClickHaskell-0.1.0-r1-3f3f97114628d66a5ac3cc9a7e308aee5e1c98ecf495b6743ff72bba07d515b5.nix new file mode 100644 index 00000000000..31abe7bb17f --- /dev/null +++ b/hackage/ClickHaskell-0.1.0-r1-3f3f97114628d66a5ac3cc9a7e308aee5e1c98ecf495b6743ff72bba07d515b5.nix @@ -0,0 +1,41 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { release = false; dev = false; }; + package = { + specVersion = "3.4"; + identifier = { name = "ClickHaskell"; version = "0.1.0"; }; + license = "BSD-3-Clause"; + copyright = "2023 Kovalev Dmitry"; + maintainer = "Kovalev Dmitry"; + author = "Kovalev Dmitry"; + homepage = "https://kovalevdima.github.io/ClickHaskell/"; + url = ""; + synopsis = "ClickHouse driver"; + description = "Small dependency footprint highlevel ClickHouse driver "; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."wide-word" or (errorHandler.buildDepError "wide-word")) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/bytes-0.17.4-r0-b83d3d91c4574a11221df328d14b4e1e14a60096d0a6131153d5f757eb0dc7b5.nix b/hackage/bytes-0.17.4-r0-b83d3d91c4574a11221df328d14b4e1e14a60096d0a6131153d5f757eb0dc7b5.nix new file mode 100644 index 00000000000..b7c8aed3383 --- /dev/null +++ b/hackage/bytes-0.17.4-r0-b83d3d91c4574a11221df328d14b4e1e14a60096d0a6131153d5f757eb0dc7b5.nix @@ -0,0 +1,46 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "bytes"; version = "0.17.4"; }; + license = "BSD-3-Clause"; + copyright = "Copyright (C) 2013-2015 Edward A. Kmett"; + maintainer = "Edward A. Kmett "; + author = "Edward A. Kmett"; + homepage = "https://github.com/ekmett/bytes"; + url = ""; + synopsis = "Sharing code for serialization between binary and cereal"; + description = "Sharing code for serialization between binary and cereal."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."binary-orphans" or (errorHandler.buildDepError "binary-orphans")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."cereal" or (errorHandler.buildDepError "cereal")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."transformers-compat" or (errorHandler.buildDepError "transformers-compat")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."scientific" or (errorHandler.buildDepError "scientific")) + (hsPkgs."void" or (errorHandler.buildDepError "void")) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/bytes-0.17.4-r1-27b117394065d8b8bd845c54dc0128f88f4b0c1a1242699f7603a80963ba1f4a.nix b/hackage/bytes-0.17.4-r1-27b117394065d8b8bd845c54dc0128f88f4b0c1a1242699f7603a80963ba1f4a.nix new file mode 100644 index 00000000000..b7c8aed3383 --- /dev/null +++ b/hackage/bytes-0.17.4-r1-27b117394065d8b8bd845c54dc0128f88f4b0c1a1242699f7603a80963ba1f4a.nix @@ -0,0 +1,46 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "bytes"; version = "0.17.4"; }; + license = "BSD-3-Clause"; + copyright = "Copyright (C) 2013-2015 Edward A. Kmett"; + maintainer = "Edward A. Kmett "; + author = "Edward A. Kmett"; + homepage = "https://github.com/ekmett/bytes"; + url = ""; + synopsis = "Sharing code for serialization between binary and cereal"; + description = "Sharing code for serialization between binary and cereal."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."binary-orphans" or (errorHandler.buildDepError "binary-orphans")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."cereal" or (errorHandler.buildDepError "cereal")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."transformers-compat" or (errorHandler.buildDepError "transformers-compat")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."scientific" or (errorHandler.buildDepError "scientific")) + (hsPkgs."void" or (errorHandler.buildDepError "void")) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/charset-0.3.11-r0-0521970d253950ae712425a03c886bdc8a88a08dc0e095fa63250b0977328f03.nix b/hackage/charset-0.3.11-r0-0521970d253950ae712425a03c886bdc8a88a08dc0e095fa63250b0977328f03.nix new file mode 100644 index 00000000000..2871d27e90f --- /dev/null +++ b/hackage/charset-0.3.11-r0-0521970d253950ae712425a03c886bdc8a88a08dc0e095fa63250b0977328f03.nix @@ -0,0 +1,37 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "charset"; version = "0.3.11"; }; + license = "BSD-3-Clause"; + copyright = "(c) Edward Kmett 2010-2012"; + maintainer = "ekmett@gmail.com"; + author = "Edward Kmett"; + homepage = "http://github.com/ekmett/charset"; + url = ""; + synopsis = "Fast unicode character sets based on complemented PATRICIA tries"; + description = "Fast unicode character sets based on complemented PATRICIA tries."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/comonad-5.0.9-r0-f7bf55e62c24e9a9f523dc63e8b644a0eb5e1f6179366b16177ef68a5d4cdb15.nix b/hackage/comonad-5.0.9-r0-f7bf55e62c24e9a9f523dc63e8b644a0eb5e1f6179366b16177ef68a5d4cdb15.nix new file mode 100644 index 00000000000..1aacfe6bce8 --- /dev/null +++ b/hackage/comonad-5.0.9-r0-f7bf55e62c24e9a9f523dc63e8b644a0eb5e1f6179366b16177ef68a5d4cdb15.nix @@ -0,0 +1,40 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { + containers = true; + distributive = true; + indexed-traversable = true; + }; + package = { + specVersion = "1.10"; + identifier = { name = "comonad"; version = "5.0.9"; }; + license = "BSD-3-Clause"; + copyright = "Copyright (C) 2008-2014 Edward A. Kmett,\nCopyright (C) 2004-2008 Dave Menendez"; + maintainer = "Edward A. Kmett "; + author = "Edward A. Kmett"; + homepage = "http://github.com/ekmett/comonad/"; + url = ""; + synopsis = "Comonads"; + description = "Comonads."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = (([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."tagged" or (errorHandler.buildDepError "tagged")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."transformers-compat" or (errorHandler.buildDepError "transformers-compat")) + ] ++ (pkgs.lib).optional (flags.containers) (hsPkgs."containers" or (errorHandler.buildDepError "containers"))) ++ (pkgs.lib).optional (flags.distributive) (hsPkgs."distributive" or (errorHandler.buildDepError "distributive"))) ++ (pkgs.lib).optional (flags.indexed-traversable) (hsPkgs."indexed-traversable" or (errorHandler.buildDepError "indexed-traversable")); + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/eventlog2html-0.11.1-r1-5142ac71e1864d8b1d8ccfb0452a6d980ef2bbf0c51f2a2449a323075202ab4f.nix b/hackage/eventlog2html-0.11.1-r1-5142ac71e1864d8b1d8ccfb0452a6d980ef2bbf0c51f2a2449a323075202ab4f.nix new file mode 100644 index 00000000000..75bd1aa8a1b --- /dev/null +++ b/hackage/eventlog2html-0.11.1-r1-5142ac71e1864d8b1d8ccfb0452a6d980ef2bbf0c51f2a2449a323075202ab4f.nix @@ -0,0 +1,69 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.4"; + identifier = { name = "eventlog2html"; version = "0.11.1"; }; + license = "BSD-3-Clause"; + copyright = "(C) 2010,2011,2015,2017,2018 Claude Heiland-Allen 2019 Matthew Pickering"; + maintainer = "matthewtpickering@gmail.com"; + author = "Matthew Pickering, David Binder, Claude Heiland-Allen"; + homepage = "https://mpickering.github.io/eventlog2html"; + url = ""; + synopsis = "Visualise an eventlog"; + description = "eventlog2html is a library for visualising eventlogs.\nAt the moment, the intended use is to visualise eventlogs\nwhich have heap profiling events, as a replacement to hp2ps\nand hp2pretty.\neventlog2html creates a static webpage which contains\na collection of different interactive charts for analysing\nheap usage. Trace events are displayed on the chart and\nthe charts can be zoomed, scrolled and filtered to give\na more exploratory feel to heap profile analysis."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."aeson" or (errorHandler.buildDepError "aeson")) + (hsPkgs."attoparsec" or (errorHandler.buildDepError "attoparsec")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."blaze-html" or (errorHandler.buildDepError "blaze-html")) + (hsPkgs."blaze-markup" or (errorHandler.buildDepError "blaze-markup")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."file-embed" or (errorHandler.buildDepError "file-embed")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."ghc-events" or (errorHandler.buildDepError "ghc-events")) + (hsPkgs."ghc-heap" or (errorHandler.buildDepError "ghc-heap")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."hashtables" or (errorHandler.buildDepError "hashtables")) + (hsPkgs."hvega" or (errorHandler.buildDepError "hvega")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."optparse-applicative" or (errorHandler.buildDepError "optparse-applicative")) + (hsPkgs."raw-strings-qq" or (errorHandler.buildDepError "raw-strings-qq")) + (hsPkgs."semigroups" or (errorHandler.buildDepError "semigroups")) + (hsPkgs."statistics-linreg" or (errorHandler.buildDepError "statistics-linreg")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."trie-simple" or (errorHandler.buildDepError "trie-simple")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + ]; + buildable = true; + }; + exes = { + "eventlog2html" = { + depends = [ + (hsPkgs."aeson" or (errorHandler.buildDepError "aeson")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."eventlog2html" or (errorHandler.buildDepError "eventlog2html")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."githash" or (errorHandler.buildDepError "githash")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/fedora-releases-0.2.0-r0-a4abd965642628d5732a73f195fe232b25b75f55e1e8b36f8578dcefa4bb99d6.nix b/hackage/fedora-releases-0.2.0-r0-a4abd965642628d5732a73f195fe232b25b75f55e1e8b36f8578dcefa4bb99d6.nix new file mode 100644 index 00000000000..bc403e3424b --- /dev/null +++ b/hackage/fedora-releases-0.2.0-r0-a4abd965642628d5732a73f195fe232b25b75f55e1e8b36f8578dcefa4bb99d6.nix @@ -0,0 +1,38 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.18"; + identifier = { name = "fedora-releases"; version = "0.2.0"; }; + license = "GPL-3.0-only"; + copyright = "2018-2022,2024 Jens Petersen"; + maintainer = "Jens Petersen "; + author = "Jens Petersen "; + homepage = "https://github.com/juhp/fedora-releases"; + url = ""; + synopsis = "Library for Fedora release versions"; + description = "This library provides the Branch and Release data types\nand various associated metadata functions for\nFedora releases (Fedora and EPEL) needed for\npackaging development and building.\nIt uses current release data from Fedora Bodhi."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."aeson" or (errorHandler.buildDepError "aeson")) + (hsPkgs."bodhi" or (errorHandler.buildDepError "bodhi")) + (hsPkgs."cached-json-file" or (errorHandler.buildDepError "cached-json-file")) + (hsPkgs."extra" or (errorHandler.buildDepError "extra")) + (hsPkgs."safe" or (errorHandler.buildDepError "safe")) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/ghc-lib-9.8.4.20241130-r1-7f8d71e34b78c341e1e5c60817b6ad9615d3c87218959b989e72c398ec1f3572.nix b/hackage/ghc-lib-9.8.4.20241130-r1-7f8d71e34b78c341e1e5c60817b6ad9615d3c87218959b989e72c398ec1f3572.nix new file mode 100644 index 00000000000..76babe14e86 --- /dev/null +++ b/hackage/ghc-lib-9.8.4.20241130-r1-7f8d71e34b78c341e1e5c60817b6ad9615d3c87218959b989e72c398ec1f3572.nix @@ -0,0 +1,58 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { threaded-rts = true; }; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-lib"; version = "9.8.4.20241130"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Digital Asset"; + author = "The GHC Team and Digital Asset"; + homepage = "https://github.com/digital-asset/ghc-lib"; + url = ""; + synopsis = "The GHC API, decoupled from GHC versions"; + description = "A package equivalent to the @ghc@ package, but which can be loaded on many compiler versions."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."parsec" or (errorHandler.buildDepError "parsec")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."semaphore-compat" or (errorHandler.buildDepError "semaphore-compat")) + (hsPkgs."rts" or (errorHandler.buildDepError "rts")) + (hsPkgs."hpc" or (errorHandler.buildDepError "hpc")) + (hsPkgs."ghc-lib-parser" or (errorHandler.buildDepError "ghc-lib-parser")) + ] ++ (if !system.isWindows + then [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ] + else [ (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) ]); + build-tools = [ + (hsPkgs.buildPackages.alex.components.exes.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex:alex"))) + (hsPkgs.buildPackages.happy.components.exes.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy:happy"))) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/ghc-lib-parser-9.8.4.20241130-r1-18d72b8794b507613f1e311b5d624f46544a6afe1c149053294d80d60f6eafd4.nix b/hackage/ghc-lib-parser-9.8.4.20241130-r1-18d72b8794b507613f1e311b5d624f46544a6afe1c149053294d80d60f6eafd4.nix new file mode 100644 index 00000000000..0b4eadaceb1 --- /dev/null +++ b/hackage/ghc-lib-parser-9.8.4.20241130-r1-18d72b8794b507613f1e311b5d624f46544a6afe1c149053294d80d60f6eafd4.nix @@ -0,0 +1,55 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { threaded-rts = true; }; + package = { + specVersion = "3.0"; + identifier = { name = "ghc-lib-parser"; version = "9.8.4.20241130"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "Digital Asset"; + author = "The GHC Team and Digital Asset"; + homepage = "https://github.com/digital-asset/ghc-lib"; + url = ""; + synopsis = "The GHC API, decoupled from GHC versions"; + description = "A package equivalent to the @ghc@ package, but which can be loaded on many compiler versions."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = ([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."parsec" or (errorHandler.buildDepError "parsec")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."pretty" or (errorHandler.buildDepError "pretty")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."process" or (errorHandler.buildDepError "process")) + ] ++ (if !system.isWindows + then [ (hsPkgs."unix" or (errorHandler.buildDepError "unix")) ] + else [ + (hsPkgs."Win32" or (errorHandler.buildDepError "Win32")) + ])) ++ (pkgs.lib).optional (compiler.isGhc && (compiler.version).ge "9.10") (hsPkgs."ghc-internal" or (errorHandler.buildDepError "ghc-internal")); + build-tools = [ + (hsPkgs.buildPackages.alex.components.exes.alex or (pkgs.buildPackages.alex or (errorHandler.buildToolDepError "alex:alex"))) + (hsPkgs.buildPackages.happy.components.exes.happy or (pkgs.buildPackages.happy or (errorHandler.buildToolDepError "happy:happy"))) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/ghc-source-gen-0.4.6.0-r0-e6a310d225e65f453fca3d365952c99e69ed2ce7f2d6c14e464ef6ff590cf8fb.nix b/hackage/ghc-source-gen-0.4.6.0-r0-e6a310d225e65f453fca3d365952c99e69ed2ce7f2d6c14e464ef6ff590cf8fb.nix new file mode 100644 index 00000000000..08fad1c1662 --- /dev/null +++ b/hackage/ghc-source-gen-0.4.6.0-r0-e6a310d225e65f453fca3d365952c99e69ed2ce7f2d6c14e464ef6ff590cf8fb.nix @@ -0,0 +1,70 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.12"; + identifier = { name = "ghc-source-gen"; version = "0.4.6.0"; }; + license = "BSD-3-Clause"; + copyright = "Google LLC"; + maintainer = "judahjacobson@google.com"; + author = "Judah Jacobson"; + homepage = "https://github.com/google/ghc-source-gen#readme"; + url = ""; + synopsis = "Constructs Haskell syntax trees for the GHC API."; + description = "@ghc-source-gen@ is a library for generating Haskell source code.\nIt uses the library\nto support recent language extensions, and provides a simple, consistent\ninterface across several major versions of GHC.\n\nTo get started, take a look at the \"GHC.SourceGen\" module.\n\nFor more information, please see the ."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc" or (errorHandler.buildDepError "ghc")) + ]; + buildable = true; + }; + tests = { + "name_test" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc" or (errorHandler.buildDepError "ghc")) + (hsPkgs."ghc-source-gen" or (errorHandler.buildDepError "ghc-source-gen")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + ]; + buildable = true; + }; + "pprint_examples" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc" or (errorHandler.buildDepError "ghc")) + (hsPkgs."ghc-paths" or (errorHandler.buildDepError "ghc-paths")) + (hsPkgs."ghc-source-gen" or (errorHandler.buildDepError "ghc-source-gen")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + ]; + buildable = true; + }; + "pprint_test" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc" or (errorHandler.buildDepError "ghc")) + (hsPkgs."ghc-paths" or (errorHandler.buildDepError "ghc-paths")) + (hsPkgs."ghc-source-gen" or (errorHandler.buildDepError "ghc-source-gen")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/gloss-1.13.2.2-r2-31467330073c706f28a640b1c891f527b11b5489f2566930a05f29fb872fd0ef.nix b/hackage/gloss-1.13.2.2-r2-31467330073c706f28a640b1c891f527b11b5489f2566930a05f29fb872fd0ef.nix new file mode 100644 index 00000000000..d63bd3881b7 --- /dev/null +++ b/hackage/gloss-1.13.2.2-r2-31467330073c706f28a640b1c891f527b11b5489f2566930a05f29fb872fd0ef.nix @@ -0,0 +1,40 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { glut = true; glfw = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "gloss"; version = "1.13.2.2"; }; + license = "MIT"; + copyright = ""; + maintainer = "benl@ouroborus.net"; + author = "Ben Lippmeier"; + homepage = "http://gloss.ouroborus.net"; + url = ""; + synopsis = "Painless 2D vector graphics, animations and simulations."; + description = "Gloss hides the pain of drawing simple vector graphics behind a nice data type and\na few display functions. Gloss uses OpenGL under the hood, but you won't need to\nworry about any of that. Get something cool on the screen in under 10 minutes."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."bmp" or (errorHandler.buildDepError "bmp")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."gloss-rendering" or (errorHandler.buildDepError "gloss-rendering")) + (hsPkgs."GLUT" or (errorHandler.buildDepError "GLUT")) + (hsPkgs."OpenGL" or (errorHandler.buildDepError "OpenGL")) + ] ++ (pkgs.lib).optional (flags.glfw) (hsPkgs."GLFW-b" or (errorHandler.buildDepError "GLFW-b")); + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/gloss-algorithms-1.13.0.3-r1-0601fb6c0cc5277028851759668bf869ea8ab8ebe878964daec0f6478ab53bb3.nix b/hackage/gloss-algorithms-1.13.0.3-r1-0601fb6c0cc5277028851759668bf869ea8ab8ebe878964daec0f6478ab53bb3.nix new file mode 100644 index 00000000000..395a84d2867 --- /dev/null +++ b/hackage/gloss-algorithms-1.13.0.3-r1-0601fb6c0cc5277028851759668bf869ea8ab8ebe878964daec0f6478ab53bb3.nix @@ -0,0 +1,36 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "gloss-algorithms"; version = "1.13.0.3"; }; + license = "MIT"; + copyright = ""; + maintainer = "benl@ouroborus.net"; + author = "Ben Lippmeier"; + homepage = "http://gloss.ouroborus.net"; + url = ""; + synopsis = "Data structures and algorithms for working with 2D graphics."; + description = "Data structures and algorithms for working with 2D graphics."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."gloss" or (errorHandler.buildDepError "gloss")) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/gloss-rendering-1.13.1.2-r2-2047344b061332101a4c38a1902a4a10b7f11998d3842cfc367b6b5563c3f580.nix b/hackage/gloss-rendering-1.13.1.2-r2-2047344b061332101a4c38a1902a4a10b7f11998d3842cfc367b6b5563c3f580.nix new file mode 100644 index 00000000000..56a6c9e6ef1 --- /dev/null +++ b/hackage/gloss-rendering-1.13.1.2-r2-2047344b061332101a4c38a1902a4a10b7f11998d3842cfc367b6b5563c3f580.nix @@ -0,0 +1,38 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "gloss-rendering"; version = "1.13.1.2"; }; + license = "MIT"; + copyright = ""; + maintainer = "elise@jabberwocky.eu benl@ouroborus.net"; + author = "Elise Huard"; + homepage = ""; + url = ""; + synopsis = "Gloss picture data types and rendering functions."; + description = "Gloss picture data types and rendering functions. These functions\ndon't do any window management. If you want gloss to setup your window as\nwell then use the plain @gloss@ package."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bmp" or (errorHandler.buildDepError "bmp")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."GLUT" or (errorHandler.buildDepError "GLUT")) + (hsPkgs."OpenGL" or (errorHandler.buildDepError "OpenGL")) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/half-0.3.2-r0-dc49517b0f8c2523218c55190909e6a2ca0185563976a8000632ea45609e08c4.nix b/hackage/half-0.3.2-r0-dc49517b0f8c2523218c55190909e6a2ca0185563976a8000632ea45609e08c4.nix new file mode 100644 index 00000000000..d8759de75fd --- /dev/null +++ b/hackage/half-0.3.2-r0-dc49517b0f8c2523218c55190909e6a2ca0185563976a8000632ea45609e08c4.nix @@ -0,0 +1,50 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "half"; version = "0.3.2"; }; + license = "BSD-3-Clause"; + copyright = "Copyright (C) 2014 Edward A. Kmett"; + maintainer = "Edward A. Kmett "; + author = "Edward A. Kmett"; + homepage = "http://github.com/ekmett/half"; + url = ""; + synopsis = "Half-precision floating-point"; + description = "Half-precision floating-point."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + ]; + buildable = true; + }; + tests = { + "spec" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."half" or (errorHandler.buildDepError "half")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."test-framework" or (errorHandler.buildDepError "test-framework")) + (hsPkgs."test-framework-quickcheck2" or (errorHandler.buildDepError "test-framework-quickcheck2")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/haskoin-store-1.5.14-r0-268683641ff4b96632ce279546bd9d03938a11b91e2fe8c94ded99520128764e.nix b/hackage/haskoin-store-1.5.14-r0-268683641ff4b96632ce279546bd9d03938a11b91e2fe8c94ded99520128764e.nix new file mode 100644 index 00000000000..78124c44b55 --- /dev/null +++ b/hackage/haskoin-store-1.5.14-r0-268683641ff4b96632ce279546bd9d03938a11b91e2fe8c94ded99520128764e.nix @@ -0,0 +1,182 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.12"; + identifier = { name = "haskoin-store"; version = "1.5.14"; }; + license = "MIT"; + copyright = ""; + maintainer = "jprupp@protonmail.ch"; + author = "Jean-Pierre Rupp"; + homepage = "http://github.com/haskoin/haskoin-store#readme"; + url = ""; + synopsis = "Storage and index for Bitcoin and Bitcoin Cash"; + description = "Please see the README on GitHub at "; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."aeson" or (errorHandler.buildDepError "aeson")) + (hsPkgs."aeson-pretty" or (errorHandler.buildDepError "aeson-pretty")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base16" or (errorHandler.buildDepError "base16")) + (hsPkgs."bytes" or (errorHandler.buildDepError "bytes")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."cereal" or (errorHandler.buildDepError "cereal")) + (hsPkgs."conduit" or (errorHandler.buildDepError "conduit")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."data-default" or (errorHandler.buildDepError "data-default")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."hashtables" or (errorHandler.buildDepError "hashtables")) + (hsPkgs."haskoin-core" or (errorHandler.buildDepError "haskoin-core")) + (hsPkgs."haskoin-node" or (errorHandler.buildDepError "haskoin-node")) + (hsPkgs."haskoin-store-data" or (errorHandler.buildDepError "haskoin-store-data")) + (hsPkgs."hedis" or (errorHandler.buildDepError "hedis")) + (hsPkgs."http-types" or (errorHandler.buildDepError "http-types")) + (hsPkgs."lens" or (errorHandler.buildDepError "lens")) + (hsPkgs."monad-control" or (errorHandler.buildDepError "monad-control")) + (hsPkgs."monad-logger" or (errorHandler.buildDepError "monad-logger")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."nqe" or (errorHandler.buildDepError "nqe")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."rocksdb-haskell-jprupp" or (errorHandler.buildDepError "rocksdb-haskell-jprupp")) + (hsPkgs."rocksdb-query" or (errorHandler.buildDepError "rocksdb-query")) + (hsPkgs."scotty" or (errorHandler.buildDepError "scotty")) + (hsPkgs."statsd-rupp" or (errorHandler.buildDepError "statsd-rupp")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."string-conversions" or (errorHandler.buildDepError "string-conversions")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."unliftio" or (errorHandler.buildDepError "unliftio")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."vault" or (errorHandler.buildDepError "vault")) + (hsPkgs."wai" or (errorHandler.buildDepError "wai")) + (hsPkgs."wai-websockets" or (errorHandler.buildDepError "wai-websockets")) + (hsPkgs."warp" or (errorHandler.buildDepError "warp")) + (hsPkgs."websockets" or (errorHandler.buildDepError "websockets")) + (hsPkgs."wreq" or (errorHandler.buildDepError "wreq")) + ]; + buildable = true; + }; + exes = { + "haskoin-store" = { + depends = [ + (hsPkgs."aeson" or (errorHandler.buildDepError "aeson")) + (hsPkgs."aeson-pretty" or (errorHandler.buildDepError "aeson-pretty")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base16" or (errorHandler.buildDepError "base16")) + (hsPkgs."bytes" or (errorHandler.buildDepError "bytes")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."cereal" or (errorHandler.buildDepError "cereal")) + (hsPkgs."conduit" or (errorHandler.buildDepError "conduit")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."data-default" or (errorHandler.buildDepError "data-default")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."hashtables" or (errorHandler.buildDepError "hashtables")) + (hsPkgs."haskoin-core" or (errorHandler.buildDepError "haskoin-core")) + (hsPkgs."haskoin-node" or (errorHandler.buildDepError "haskoin-node")) + (hsPkgs."haskoin-store" or (errorHandler.buildDepError "haskoin-store")) + (hsPkgs."haskoin-store-data" or (errorHandler.buildDepError "haskoin-store-data")) + (hsPkgs."hedis" or (errorHandler.buildDepError "hedis")) + (hsPkgs."http-types" or (errorHandler.buildDepError "http-types")) + (hsPkgs."lens" or (errorHandler.buildDepError "lens")) + (hsPkgs."monad-control" or (errorHandler.buildDepError "monad-control")) + (hsPkgs."monad-logger" or (errorHandler.buildDepError "monad-logger")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."nqe" or (errorHandler.buildDepError "nqe")) + (hsPkgs."optparse-applicative" or (errorHandler.buildDepError "optparse-applicative")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."rocksdb-haskell-jprupp" or (errorHandler.buildDepError "rocksdb-haskell-jprupp")) + (hsPkgs."rocksdb-query" or (errorHandler.buildDepError "rocksdb-query")) + (hsPkgs."scotty" or (errorHandler.buildDepError "scotty")) + (hsPkgs."statsd-rupp" or (errorHandler.buildDepError "statsd-rupp")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."string-conversions" or (errorHandler.buildDepError "string-conversions")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."unliftio" or (errorHandler.buildDepError "unliftio")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."vault" or (errorHandler.buildDepError "vault")) + (hsPkgs."wai" or (errorHandler.buildDepError "wai")) + (hsPkgs."wai-websockets" or (errorHandler.buildDepError "wai-websockets")) + (hsPkgs."warp" or (errorHandler.buildDepError "warp")) + (hsPkgs."websockets" or (errorHandler.buildDepError "websockets")) + (hsPkgs."wreq" or (errorHandler.buildDepError "wreq")) + ]; + buildable = true; + }; + }; + tests = { + "spec" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."aeson" or (errorHandler.buildDepError "aeson")) + (hsPkgs."aeson-pretty" or (errorHandler.buildDepError "aeson-pretty")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base16" or (errorHandler.buildDepError "base16")) + (hsPkgs."base64" or (errorHandler.buildDepError "base64")) + (hsPkgs."bytes" or (errorHandler.buildDepError "bytes")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."cereal" or (errorHandler.buildDepError "cereal")) + (hsPkgs."conduit" or (errorHandler.buildDepError "conduit")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."data-default" or (errorHandler.buildDepError "data-default")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."hashtables" or (errorHandler.buildDepError "hashtables")) + (hsPkgs."haskoin-core" or (errorHandler.buildDepError "haskoin-core")) + (hsPkgs."haskoin-node" or (errorHandler.buildDepError "haskoin-node")) + (hsPkgs."haskoin-store" or (errorHandler.buildDepError "haskoin-store")) + (hsPkgs."haskoin-store-data" or (errorHandler.buildDepError "haskoin-store-data")) + (hsPkgs."hedis" or (errorHandler.buildDepError "hedis")) + (hsPkgs."hspec" or (errorHandler.buildDepError "hspec")) + (hsPkgs."http-types" or (errorHandler.buildDepError "http-types")) + (hsPkgs."lens" or (errorHandler.buildDepError "lens")) + (hsPkgs."monad-control" or (errorHandler.buildDepError "monad-control")) + (hsPkgs."monad-logger" or (errorHandler.buildDepError "monad-logger")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."network" or (errorHandler.buildDepError "network")) + (hsPkgs."nqe" or (errorHandler.buildDepError "nqe")) + (hsPkgs."random" or (errorHandler.buildDepError "random")) + (hsPkgs."rocksdb-haskell-jprupp" or (errorHandler.buildDepError "rocksdb-haskell-jprupp")) + (hsPkgs."rocksdb-query" or (errorHandler.buildDepError "rocksdb-query")) + (hsPkgs."scotty" or (errorHandler.buildDepError "scotty")) + (hsPkgs."statsd-rupp" or (errorHandler.buildDepError "statsd-rupp")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."string-conversions" or (errorHandler.buildDepError "string-conversions")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."transformers" or (errorHandler.buildDepError "transformers")) + (hsPkgs."unliftio" or (errorHandler.buildDepError "unliftio")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."vault" or (errorHandler.buildDepError "vault")) + (hsPkgs."wai" or (errorHandler.buildDepError "wai")) + (hsPkgs."wai-websockets" or (errorHandler.buildDepError "wai-websockets")) + (hsPkgs."warp" or (errorHandler.buildDepError "warp")) + (hsPkgs."websockets" or (errorHandler.buildDepError "websockets")) + (hsPkgs."wreq" or (errorHandler.buildDepError "wreq")) + ]; + build-tools = [ + (hsPkgs.buildPackages.hspec-discover.components.exes.hspec-discover or (pkgs.buildPackages.hspec-discover or (errorHandler.buildToolDepError "hspec-discover:hspec-discover"))) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/heaps-0.4.1-r0-74ce60a23b8ef247b8bca71eeb38289e82b3b5e83b2383600b2c838a68218068.nix b/hackage/heaps-0.4.1-r0-74ce60a23b8ef247b8bca71eeb38289e82b3b5e83b2383600b2c838a68218068.nix new file mode 100644 index 00000000000..815c96f3a0e --- /dev/null +++ b/hackage/heaps-0.4.1-r0-74ce60a23b8ef247b8bca71eeb38289e82b3b5e83b2383600b2c838a68218068.nix @@ -0,0 +1,31 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "heaps"; version = "0.4.1"; }; + license = "BSD-3-Clause"; + copyright = "(c) 2010-2015 Edward A. Kmett"; + maintainer = "Edward A. Kmett "; + author = "Edward A. Kmett"; + homepage = "http://github.com/ekmett/heaps/"; + url = ""; + synopsis = "Asymptotically optimal Brodal/Okasaki heaps."; + description = "Asymptotically optimal Brodal\\/Okasaki bootstrapped skew-binomial heaps from the paper , extended with a 'Foldable' interface."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ (hsPkgs."base" or (errorHandler.buildDepError "base")) ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/horizontal-rule-0.7.0.0-r0-ae1b4bc0d9d69baac9eee14f8ba106a9c61c01981678610d6a0e2be5ab4f9ea0.nix b/hackage/horizontal-rule-0.7.0.0-r0-ae1b4bc0d9d69baac9eee14f8ba106a9c61c01981678610d6a0e2be5ab4f9ea0.nix new file mode 100644 index 00000000000..749fefbb95c --- /dev/null +++ b/hackage/horizontal-rule-0.7.0.0-r0-ae1b4bc0d9d69baac9eee14f8ba106a9c61c01981678610d6a0e2be5ab4f9ea0.nix @@ -0,0 +1,78 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { optparse-applicative_ge_0_18 = false; }; + package = { + specVersion = "3.0"; + identifier = { name = "horizontal-rule"; version = "0.7.0.0"; }; + license = "MIT"; + copyright = "Copyright (c) 2019-2024 Travis Cardwell"; + maintainer = "Travis Cardwell "; + author = "Travis Cardwell "; + homepage = "https://github.com/ExtremaIS/hr-haskell#readme"; + url = ""; + synopsis = "horizontal rule for the terminal"; + description = "This package provides a utility for displaying a horizontal rule in a\nterminal. Please see the README on GitHub at\n."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."terminal-size" or (errorHandler.buildDepError "terminal-size")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ]; + buildable = true; + }; + exes = { + "hr" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."horizontal-rule" or (errorHandler.buildDepError "horizontal-rule")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + ] ++ (if flags.optparse-applicative_ge_0_18 + then [ + (hsPkgs."optparse-applicative" or (errorHandler.buildDepError "optparse-applicative")) + (hsPkgs."prettyprinter" or (errorHandler.buildDepError "prettyprinter")) + ] + else [ + (hsPkgs."ansi-wl-pprint" or (errorHandler.buildDepError "ansi-wl-pprint")) + (hsPkgs."optparse-applicative" or (errorHandler.buildDepError "optparse-applicative")) + ]); + buildable = true; + }; + }; + tests = { + "horizontal-rule-test" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."horizontal-rule" or (errorHandler.buildDepError "horizontal-rule")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-hunit" or (errorHandler.buildDepError "tasty-hunit")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."constraints" or (errorHandler.buildDepError "constraints")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."data-default" or (errorHandler.buildDepError "data-default")) + (hsPkgs."exceptions" or (errorHandler.buildDepError "exceptions")) + (hsPkgs."extra" or (errorHandler.buildDepError "extra")) + (hsPkgs."monad-control" or (errorHandler.buildDepError "monad-control")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."stm" or (errorHandler.buildDepError "stm")) + (hsPkgs."syb" or (errorHandler.buildDepError "syb")) + (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")) + (hsPkgs."transformers-base" or (errorHandler.buildDepError "transformers-base")) + (hsPkgs."unliftio" or (errorHandler.buildDepError "unliftio")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/hybrid-vectors-0.2.5-r0-d4041e1e58b29ed60b8c4681c4b7990b7c76049c097a2d95cd901380fd129d67.nix b/hackage/hybrid-vectors-0.2.5-r0-d4041e1e58b29ed60b8c4681c4b7990b7c76049c097a2d95cd901380fd129d67.nix new file mode 100644 index 00000000000..3faebaedb8a --- /dev/null +++ b/hackage/hybrid-vectors-0.2.5-r0-d4041e1e58b29ed60b8c4681c4b7990b7c76049c097a2d95cd901380fd129d67.nix @@ -0,0 +1,37 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "hybrid-vectors"; version = "0.2.5"; }; + license = "BSD-3-Clause"; + copyright = "Copyright (C) 2013 Edward A. Kmett"; + maintainer = "Edward A. Kmett "; + author = "Edward A. Kmett"; + homepage = "http://github.com/ekmett/hybrid-vectors"; + url = ""; + synopsis = "Hybrid vectors e.g. Mixed Boxed/Unboxed vectors"; + description = "Hybrid vectors e.g. Mixed Boxed/Unboxed vectors."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + (hsPkgs."semigroups" or (errorHandler.buildDepError "semigroups")) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/intern-0.9.6-r0-1a0c01d19739a9e575d001ad4fc55cdfe90f8ef7db426498b1e251ed175ce855.nix b/hackage/intern-0.9.6-r0-1a0c01d19739a9e575d001ad4fc55cdfe90f8ef7db426498b1e251ed175ce855.nix new file mode 100644 index 00000000000..182d8bff00e --- /dev/null +++ b/hackage/intern-0.9.6-r0-1a0c01d19739a9e575d001ad4fc55cdfe90f8ef7db426498b1e251ed175ce855.nix @@ -0,0 +1,38 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "intern"; version = "0.9.6"; }; + license = "BSD-3-Clause"; + copyright = "Copyright (C) 2011-2014 Edward A. Kmett"; + maintainer = "Edward A. Kmett "; + author = "Edward A. Kmett"; + homepage = "http://github.com/ekmett/intern/"; + url = ""; + synopsis = "Efficient hash-consing for arbitrary data types"; + description = "Efficient hash-consing for arbitrary data types."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."array" or (errorHandler.buildDepError "array")) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/intervals-0.9.3-r0-82f7df005cbd6edbc1c8860fa70bba1a8bad673743be80bc357788652006d07c.nix b/hackage/intervals-0.9.3-r0-82f7df005cbd6edbc1c8860fa70bba1a8bad673743be80bc357788652006d07c.nix new file mode 100644 index 00000000000..9068f63fe90 --- /dev/null +++ b/hackage/intervals-0.9.3-r0-82f7df005cbd6edbc1c8860fa70bba1a8bad673743be80bc357788652006d07c.nix @@ -0,0 +1,45 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { herbie = false; }; + package = { + specVersion = "1.10"; + identifier = { name = "intervals"; version = "0.9.3"; }; + license = "BSD-3-Clause"; + copyright = ""; + maintainer = "ekmett@gmail.com"; + author = "Edward Kmett"; + homepage = "http://github.com/ekmett/intervals"; + url = ""; + synopsis = "Interval Arithmetic"; + description = "A 'Numeric.Interval.Interval' is a closed, convex set of floating point values.\n\nWe do not control the rounding mode of the end points of the interval when\nusing floating point arithmetic, so be aware that in order to get precise\ncontainment of the result, you will need to use an underlying type with\nboth lower and upper bounds like 'CReal'"; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."array" or (errorHandler.buildDepError "array")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."distributive" or (errorHandler.buildDepError "distributive")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + ] ++ (pkgs.lib).optional (flags.herbie) (hsPkgs."HerbiePlugin" or (errorHandler.buildDepError "HerbiePlugin")); + buildable = true; + }; + tests = { + "doctests" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/ip2location-8.5.1-r0-461159aa584da4a8db78508d5557d36632adbbac8678ff0cb1e8dbe690e53d0b.nix b/hackage/ip2location-8.5.1-r0-461159aa584da4a8db78508d5557d36632adbbac8678ff0cb1e8dbe690e53d0b.nix new file mode 100644 index 00000000000..31455cc8956 --- /dev/null +++ b/hackage/ip2location-8.5.1-r0-461159aa584da4a8db78508d5557d36632adbbac8678ff0cb1e8dbe690e53d0b.nix @@ -0,0 +1,42 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "ip2location"; version = "8.5.1"; }; + license = "MIT"; + copyright = ""; + maintainer = "sales@ip2location.com"; + author = "IP2Location"; + homepage = "http://www.ip2location.com"; + url = ""; + synopsis = "IP2Location Haskell package for IP geolocation."; + description = "This Haskell package provides a fast lookup of country, region, city, latitude, longitude, ZIP code, time zone, ISP, domain name, connection type, IDD code, area code, weather station code, weather station name, mcc, mnc, mobile brand, elevation, usage type, address type and IAB category from IP address by using IP2Location database. This package uses a file based database available at IP2Location.com. This database simply contains IP blocks as keys, and other information such as country, region, city, latitude, longitude, ZIP code, time zone, ISP, domain name, connection type, IDD code, area code, weather station code, weather station name, mcc, mnc, mobile brand, elevation, usage type, address type, IAB category, district, autonomous system number (ASN) and autonomous system (AS) as values. It supports both IP addresses in IPv4 and IPv6."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."iproute" or (errorHandler.buildDepError "iproute")) + (hsPkgs."aeson" or (errorHandler.buildDepError "aeson")) + (hsPkgs."http-types" or (errorHandler.buildDepError "http-types")) + (hsPkgs."http-client" or (errorHandler.buildDepError "http-client")) + (hsPkgs."http-client-tls" or (errorHandler.buildDepError "http-client-tls")) + (hsPkgs."uri-encode" or (errorHandler.buildDepError "uri-encode")) + (hsPkgs."split" or (errorHandler.buildDepError "split")) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/ip2proxy-3.2.1-r0-7d348bdcabbd691fbc7af2379a23cddd0b283a5a867499f2143a1b279cec620d.nix b/hackage/ip2proxy-3.2.1-r0-7d348bdcabbd691fbc7af2379a23cddd0b283a5a867499f2143a1b279cec620d.nix new file mode 100644 index 00000000000..aae152bc411 --- /dev/null +++ b/hackage/ip2proxy-3.2.1-r0-7d348bdcabbd691fbc7af2379a23cddd0b283a5a867499f2143a1b279cec620d.nix @@ -0,0 +1,41 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "ip2proxy"; version = "3.2.1"; }; + license = "MIT"; + copyright = ""; + maintainer = "sales@ip2location.com"; + author = "IP2Location"; + homepage = "https://www.ip2location.com"; + url = ""; + synopsis = "IP2Proxy Haskell package for proxy detection."; + description = "This Haskell package allows users to query an IP address to determine if it was being used as VPN anonymizer, open proxies, web proxies, Tor exits, data center, web hosting (DCH) range, search engine robots (SES) and residential (RES)."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."binary" or (errorHandler.buildDepError "binary")) + (hsPkgs."iproute" or (errorHandler.buildDepError "iproute")) + (hsPkgs."aeson" or (errorHandler.buildDepError "aeson")) + (hsPkgs."http-types" or (errorHandler.buildDepError "http-types")) + (hsPkgs."http-client" or (errorHandler.buildDepError "http-client")) + (hsPkgs."http-client-tls" or (errorHandler.buildDepError "http-client-tls")) + (hsPkgs."uri-encode" or (errorHandler.buildDepError "uri-encode")) + ]; + buildable = true; + }; + }; + } \ No newline at end of file diff --git a/hackage/lawful-conversions-0.1.1-r1-122baa7ec69d983da1feadeed66064543376395bed40a5a6ad12fba0e292ba43.nix b/hackage/lawful-conversions-0.1.1-r1-122baa7ec69d983da1feadeed66064543376395bed40a5a6ad12fba0e292ba43.nix new file mode 100644 index 00000000000..3e81fa241f6 --- /dev/null +++ b/hackage/lawful-conversions-0.1.1-r1-122baa7ec69d983da1feadeed66064543376395bed40a5a6ad12fba0e292ba43.nix @@ -0,0 +1,58 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "lawful-conversions"; version = "0.1.1"; }; + license = "MIT"; + copyright = "(c) 2022 Nikita Volkov"; + maintainer = "Nikita Volkov "; + author = "Nikita Volkov "; + homepage = "https://github.com/nikita-volkov/lawful-conversions"; + url = ""; + synopsis = "Lawful typeclasses for bidirectional conversion between types"; + description = "Lawful typeclasses capturing three main patterns of bidirectional mapping. The typeclasses form a layered hierarchy with ascending strictness of laws.\n\n1. `IsSome`: Smart constructor\n\n2. `IsMany`: Lossy conversion\n\n3. `Is`: Isomorphism or lossless conversion\n\n= The conversion problem\n\nHave you ever looked for a @toString@ function? How often do you\nimport @Data.Text.Lazy@ only to call its 'Data.Text.Lazy.fromStrict'? How\nabout importing @Data.ByteString.Builder@ only to call its\n'Data.ByteString.Builder.toLazyByteString' and then importing\n@Data.ByteString.Lazy@ only to call its 'Data.ByteString.Lazy.toStrict'?\n\nThose all are instances of one pattern. They are conversions between\nrepresentations of the same information. Codebases that don't attempt to\nabstract over this pattern tend to be sprawling with this type of\nboilerplate. It's noise to the codereader, it's a burden to the\nimplementor and the maintainer.\n\n= Why another conversion library?\n\nMany libraries exist that approach the conversion problem. However most of\nthem provide lawless typeclasses leaving it up to the author of the\ninstance to define what makes a proper conversion. This results in\ninconsistencies across instances, their behaviour not being evident to\nthe user and no way to check whether an instance is correct.\n\nThis library tackles this problem with a lawful typeclass hierarchy, making it\nevident what any of its instances do and it provides property-tests for you\nto validate your instances.\n\n= Conversions\n\nThe main part of the API is two functions: 'to' and 'from'. Both\nperform a conversion between two types. The main difference between them\nis in what the first type application parameter specifies. E.g.:\n\n> toString = to @String\n\n> fromText = from @Text\n\nThe types should be self-evident:\n\n> > :t to @String\n> to @String :: IsSome String b => b -> String\n\n> > :t from @Text\n> from @Text :: IsMany Text b => Text -> b\n\nIn other words 'to' and 'from' let you explicitly specify either the source\nor the target type of a conversion when you need to help the type\ninferencer or the reader.\n\n== Examples\n\n@\nrenderNameAndHeight :: 'Text' -> 'Int' -> 'Text'\nrenderNameAndHeight name height =\n 'from' @'Data.Text.Encoding.StrictTextBuilder' $\n \"Height of \" <> 'to' name <> \" is \" <> 'to' (show height)\n@\n\n@\ncombineEncodings :: 'Data.ByteString.Short.ShortByteString' -> 'Data.Primitive.ByteArray' -> ['Word8'] -> 'Data.ByteString.Lazy.ByteString'\ncombineEncodings a b c =\n 'from' @'Data.ByteString.Builder.Builder' $\n 'to' a <> 'to' b <> 'to' c\n@\n\n= Partial conversions\n\nThis library also captures the pattern of smart constructors via the 'IsSome' class, which associates a total 'to' conversion with its partial inverse 'maybeFrom'.\n\nThis captures the codec relationship between types.\nE.g.,\n\n- Every 'Int16' can be losslessly converted into 'Int32', but not every 'Int32' can be losslessly converted into 'Int16'.\n\n- Every 'Text' can be converted into 'ByteString' via UTF-8 encoding, but not every 'ByteString' forms a valid UTF-8 sequence.\n\n- Every URL can be uniquely represented as 'Text', but most 'Text's are not URLs unfortunately."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."profunctors" or (errorHandler.buildDepError "profunctors")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + ]; + buildable = true; + }; + tests = { + "test" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."lawful-conversions" or (errorHandler.buildDepError "lawful-conversions")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."quickcheck-instances" or (errorHandler.buildDepError "quickcheck-instances")) + (hsPkgs."rebase" or (errorHandler.buildDepError "rebase")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/lawful-conversions-0.1.1-r2-9ec257c52deb296660e3cd18bc6aaf76a8d9aaf9fc4c0bca0190b4bfded48212.nix b/hackage/lawful-conversions-0.1.1-r2-9ec257c52deb296660e3cd18bc6aaf76a8d9aaf9fc4c0bca0190b4bfded48212.nix new file mode 100644 index 00000000000..81a436829b6 --- /dev/null +++ b/hackage/lawful-conversions-0.1.1-r2-9ec257c52deb296660e3cd18bc6aaf76a8d9aaf9fc4c0bca0190b4bfded48212.nix @@ -0,0 +1,58 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "lawful-conversions"; version = "0.1.1"; }; + license = "MIT"; + copyright = "(c) 2022 Nikita Volkov"; + maintainer = "Nikita Volkov "; + author = "Nikita Volkov "; + homepage = "https://github.com/nikita-volkov/lawful-conversions"; + url = ""; + synopsis = "Lawful typeclasses for bidirectional conversion between types"; + description = "Lawful typeclasses capturing three main patterns of bidirectional mapping. The typeclasses form a layered hierarchy with ascending strictness of laws.\n\n1. `LawfulConversions.IsSome`: Smart constructor\n\n2. `LawfulConversions.IsMany`: Lossy conversion\n\n3. `LawfulConversions.Is`: Isomorphism or lossless conversion\n\n= The conversion problem\n\nHave you ever looked for a @toString@ function? How often do you\nimport @Data.Text.Lazy@ only to call its 'Data.Text.Lazy.fromStrict'? How\nabout importing @Data.ByteString.Builder@ only to call its\n'Data.ByteString.Builder.toLazyByteString' and then importing\n@Data.ByteString.Lazy@ only to call its 'Data.ByteString.Lazy.toStrict'?\n\nThose all are instances of one pattern. They are conversions between\nrepresentations of the same information. Codebases that don't attempt to\nabstract over this pattern tend to be sprawling with this type of\nboilerplate. It's noise to the codereader, it's a burden to the\nimplementor and the maintainer.\n\n= Why another conversion library?\n\nMany libraries exist that approach the conversion problem. However most of\nthem provide lawless typeclasses leaving it up to the author of the\ninstance to define what makes a proper conversion. This results in\ninconsistencies across instances, their behaviour not being evident to\nthe user and no way to check whether an instance is correct.\n\nThis library tackles this problem with a lawful typeclass hierarchy, making it\nevident what any of its instances do and it provides property-tests for you\nto validate your instances.\n\n= Conversions\n\nThe main part of the API is two functions: 'LawfulConversions.to' and 'LawfulConversions.from'. Both\nperform a conversion between two types. The main difference between them\nis in what the first type application parameter specifies. E.g.:\n\n> toString = to @String\n\n> fromText = from @Text\n\nThe types should be self-evident:\n\n> > :t to @String\n> to @String :: IsSome String b => b -> String\n\n> > :t from @Text\n> from @Text :: IsMany Text b => Text -> b\n\nIn other words 'LawfulConversions.to' and 'LawfulConversions.from' let you explicitly specify either the source\nor the target type of a conversion when you need to help the type\ninferencer or the reader.\n\n== Examples\n\n@\nrenderNameAndHeight :: 'Text' -> 'Int' -> 'Text'\nrenderNameAndHeight name height =\n 'LawfulConversions.from' @'Data.Text.Encoding.StrictTextBuilder' $\n \"Height of \" <> 'LawfulConversions.to' name <> \" is \" <> 'LawfulConversions.to' (show height)\n@\n\n@\ncombineEncodings :: 'Data.ByteString.Short.ShortByteString' -> 'Data.Primitive.ByteArray' -> ['Word8'] -> 'Data.ByteString.Lazy.ByteString'\ncombineEncodings a b c =\n 'LawfulConversions.from' @'Data.ByteString.Builder.Builder' $\n 'LawfulConversions.to' a <> 'LawfulConversions.to' b <> 'LawfulConversions.to' c\n@\n\n= Partial conversions\n\nThis library also captures the pattern of smart constructors via the 'LawfulConversions.IsSome' class, which associates a total 'LawfulConversions.to' conversion with its partial inverse 'LawfulConversions.maybeFrom'.\n\nThis captures the codec relationship between types.\nE.g.,\n\n- Every 'Int16' can be losslessly converted into 'Int32', but not every 'Int32' can be losslessly converted into 'Int16'.\n\n- Every 'Text' can be converted into 'ByteString' via UTF-8 encoding, but not every 'ByteString' forms a valid UTF-8 sequence.\n\n- Every URL can be uniquely represented as 'Text', but most 'Text's are not URLs unfortunately."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."profunctors" or (errorHandler.buildDepError "profunctors")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + ]; + buildable = true; + }; + tests = { + "test" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."lawful-conversions" or (errorHandler.buildDepError "lawful-conversions")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."quickcheck-instances" or (errorHandler.buildDepError "quickcheck-instances")) + (hsPkgs."rebase" or (errorHandler.buildDepError "rebase")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/lawful-conversions-0.1.1-r3-85762616fc1acbcf643f9da133ef2f248328fda5d0b65d1bbe9f363df572159b.nix b/hackage/lawful-conversions-0.1.1-r3-85762616fc1acbcf643f9da133ef2f248328fda5d0b65d1bbe9f363df572159b.nix new file mode 100644 index 00000000000..3e81fa241f6 --- /dev/null +++ b/hackage/lawful-conversions-0.1.1-r3-85762616fc1acbcf643f9da133ef2f248328fda5d0b65d1bbe9f363df572159b.nix @@ -0,0 +1,58 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "lawful-conversions"; version = "0.1.1"; }; + license = "MIT"; + copyright = "(c) 2022 Nikita Volkov"; + maintainer = "Nikita Volkov "; + author = "Nikita Volkov "; + homepage = "https://github.com/nikita-volkov/lawful-conversions"; + url = ""; + synopsis = "Lawful typeclasses for bidirectional conversion between types"; + description = "Lawful typeclasses capturing three main patterns of bidirectional mapping. The typeclasses form a layered hierarchy with ascending strictness of laws.\n\n1. `IsSome`: Smart constructor\n\n2. `IsMany`: Lossy conversion\n\n3. `Is`: Isomorphism or lossless conversion\n\n= The conversion problem\n\nHave you ever looked for a @toString@ function? How often do you\nimport @Data.Text.Lazy@ only to call its 'Data.Text.Lazy.fromStrict'? How\nabout importing @Data.ByteString.Builder@ only to call its\n'Data.ByteString.Builder.toLazyByteString' and then importing\n@Data.ByteString.Lazy@ only to call its 'Data.ByteString.Lazy.toStrict'?\n\nThose all are instances of one pattern. They are conversions between\nrepresentations of the same information. Codebases that don't attempt to\nabstract over this pattern tend to be sprawling with this type of\nboilerplate. It's noise to the codereader, it's a burden to the\nimplementor and the maintainer.\n\n= Why another conversion library?\n\nMany libraries exist that approach the conversion problem. However most of\nthem provide lawless typeclasses leaving it up to the author of the\ninstance to define what makes a proper conversion. This results in\ninconsistencies across instances, their behaviour not being evident to\nthe user and no way to check whether an instance is correct.\n\nThis library tackles this problem with a lawful typeclass hierarchy, making it\nevident what any of its instances do and it provides property-tests for you\nto validate your instances.\n\n= Conversions\n\nThe main part of the API is two functions: 'to' and 'from'. Both\nperform a conversion between two types. The main difference between them\nis in what the first type application parameter specifies. E.g.:\n\n> toString = to @String\n\n> fromText = from @Text\n\nThe types should be self-evident:\n\n> > :t to @String\n> to @String :: IsSome String b => b -> String\n\n> > :t from @Text\n> from @Text :: IsMany Text b => Text -> b\n\nIn other words 'to' and 'from' let you explicitly specify either the source\nor the target type of a conversion when you need to help the type\ninferencer or the reader.\n\n== Examples\n\n@\nrenderNameAndHeight :: 'Text' -> 'Int' -> 'Text'\nrenderNameAndHeight name height =\n 'from' @'Data.Text.Encoding.StrictTextBuilder' $\n \"Height of \" <> 'to' name <> \" is \" <> 'to' (show height)\n@\n\n@\ncombineEncodings :: 'Data.ByteString.Short.ShortByteString' -> 'Data.Primitive.ByteArray' -> ['Word8'] -> 'Data.ByteString.Lazy.ByteString'\ncombineEncodings a b c =\n 'from' @'Data.ByteString.Builder.Builder' $\n 'to' a <> 'to' b <> 'to' c\n@\n\n= Partial conversions\n\nThis library also captures the pattern of smart constructors via the 'IsSome' class, which associates a total 'to' conversion with its partial inverse 'maybeFrom'.\n\nThis captures the codec relationship between types.\nE.g.,\n\n- Every 'Int16' can be losslessly converted into 'Int32', but not every 'Int32' can be losslessly converted into 'Int16'.\n\n- Every 'Text' can be converted into 'ByteString' via UTF-8 encoding, but not every 'ByteString' forms a valid UTF-8 sequence.\n\n- Every URL can be uniquely represented as 'Text', but most 'Text's are not URLs unfortunately."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."profunctors" or (errorHandler.buildDepError "profunctors")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + ]; + buildable = true; + }; + tests = { + "test" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."lawful-conversions" or (errorHandler.buildDepError "lawful-conversions")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."quickcheck-instances" or (errorHandler.buildDepError "quickcheck-instances")) + (hsPkgs."rebase" or (errorHandler.buildDepError "rebase")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/lawful-conversions-0.1.1-r4-0fc4fc2cfcc69ff336bbe0863eeddb54355859319c1eee0c8ceb5e8a6444e588.nix b/hackage/lawful-conversions-0.1.1-r4-0fc4fc2cfcc69ff336bbe0863eeddb54355859319c1eee0c8ceb5e8a6444e588.nix new file mode 100644 index 00000000000..93f070dd438 --- /dev/null +++ b/hackage/lawful-conversions-0.1.1-r4-0fc4fc2cfcc69ff336bbe0863eeddb54355859319c1eee0c8ceb5e8a6444e588.nix @@ -0,0 +1,58 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "lawful-conversions"; version = "0.1.1"; }; + license = "MIT"; + copyright = "(c) 2022 Nikita Volkov"; + maintainer = "Nikita Volkov "; + author = "Nikita Volkov "; + homepage = "https://github.com/nikita-volkov/lawful-conversions"; + url = ""; + synopsis = "Lawful typeclasses for bidirectional conversion between types"; + description = "# Summary\n\nLawful typeclasses capturing three main patterns of bidirectional mapping. The typeclasses form a layered hierarchy with ascending strictness of laws:\n\n1. `IsSome`: Smart constructor pattern\n\n2. `IsMany`: Lossy conversion\n\n3. `Is`: Isomorphism (lossless conversion)\n\n# The conversion problem\n\nHave you ever looked for a `toString` function? How often do you\nimport `Data.Text.Lazy` only to call its `Data.Text.Lazy.fromStrict`? How\nabout importing `Data.ByteString.Builder` only to call its\n`Data.ByteString.Builder.toLazyByteString` and then importing\n`Data.ByteString.Lazy` only to call its `Data.ByteString.Lazy.toStrict`?\n\nThose all are instances of one pattern. They are conversions between\nrepresentations of the same information. Codebases that don't attempt to\nabstract over this pattern tend to be sprawling with this type of\nboilerplate. It's noise to the codereader, it's a burden to the\nimplementor and the maintainer.\n\n# Why another conversion library?\n\nMany libraries exist that approach the conversion problem. However most of\nthem provide lawless typeclasses leaving it up to the author of the\ninstance to define what makes a proper conversion. This results in\ninconsistencies across instances, their behaviour not being evident to\nthe user and no way to check whether an instance is correct.\n\nThis library tackles this problem with a lawful typeclass hierarchy, making it\nevident what any of its instances do and it provides property-tests for you\nto validate your instances."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."profunctors" or (errorHandler.buildDepError "profunctors")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + ]; + buildable = true; + }; + tests = { + "test" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."lawful-conversions" or (errorHandler.buildDepError "lawful-conversions")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."quickcheck-instances" or (errorHandler.buildDepError "quickcheck-instances")) + (hsPkgs."rebase" or (errorHandler.buildDepError "rebase")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/lawful-conversions-0.1.1-r5-176e908155df2de5c499690b16288366fa09970cc2101f7245b096a4a99c82a8.nix b/hackage/lawful-conversions-0.1.1-r5-176e908155df2de5c499690b16288366fa09970cc2101f7245b096a4a99c82a8.nix new file mode 100644 index 00000000000..3a9949035d8 --- /dev/null +++ b/hackage/lawful-conversions-0.1.1-r5-176e908155df2de5c499690b16288366fa09970cc2101f7245b096a4a99c82a8.nix @@ -0,0 +1,58 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "lawful-conversions"; version = "0.1.1"; }; + license = "MIT"; + copyright = "(c) 2022 Nikita Volkov"; + maintainer = "Nikita Volkov "; + author = "Nikita Volkov "; + homepage = "https://github.com/nikita-volkov/lawful-conversions"; + url = ""; + synopsis = "Lawful typeclasses for bidirectional conversion between types"; + description = "= Summary\n\nLawful typeclasses capturing three patterns of bidirectional mapping and forming a layered hierarchy with an ascending strictness of laws.\n\n1. `IsSome`: Smart constructor\n\n2. `IsMany`: Lossy conversion\n\n3. `Is`: Isomorphism or lossless conversion\n\n= The conversion problem\n\nHave you ever looked for a @toString@ function? How often do you\nimport @Data.Text.Lazy@ only to call its 'Data.Text.Lazy.fromStrict'? How\nabout importing @Data.ByteString.Builder@ only to call its\n'Data.ByteString.Builder.toLazyByteString' and then importing\n@Data.ByteString.Lazy@ only to call its 'Data.ByteString.Lazy.toStrict'?\n\nThose all are instances of one pattern. They are conversions between different\nrepresentations of the same information. Codebases that don't attempt to\nabstract over this pattern tend to be sprawling with this type of\nboilerplate. It's noise to the codereader, it's a burden to the\nimplementor and the maintainer.\n\n= Why another conversion library?\n\nMany libraries exist that approach the conversion problem. However most of\nthem provide lawless typeclasses leaving it up to the author of the\ninstance to define what makes a proper conversion. This results in\ninconsistencies across instances, their behaviour not being evident to\nthe user and no way to check whether an instance is correct.\n\nThis library tackles this problem with a lawful typeclass hierarchy, making it\nevident what any of its instances do and it provides property-tests for you\nto validate your instances."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."profunctors" or (errorHandler.buildDepError "profunctors")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + ]; + buildable = true; + }; + tests = { + "test" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."lawful-conversions" or (errorHandler.buildDepError "lawful-conversions")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."quickcheck-instances" or (errorHandler.buildDepError "quickcheck-instances")) + (hsPkgs."rebase" or (errorHandler.buildDepError "rebase")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/lawful-conversions-0.1.2.1-r0-ea31eeeaaaa7e023147b29b5604e266877341fd1258f65acf5529d32924ecfd7.nix b/hackage/lawful-conversions-0.1.2.1-r0-ea31eeeaaaa7e023147b29b5604e266877341fd1258f65acf5529d32924ecfd7.nix new file mode 100644 index 00000000000..3aa9f31c78c --- /dev/null +++ b/hackage/lawful-conversions-0.1.2.1-r0-ea31eeeaaaa7e023147b29b5604e266877341fd1258f65acf5529d32924ecfd7.nix @@ -0,0 +1,59 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "lawful-conversions"; version = "0.1.2.1"; }; + license = "MIT"; + copyright = "(c) 2022 Nikita Volkov"; + maintainer = "Nikita Volkov "; + author = "Nikita Volkov "; + homepage = "https://github.com/nikita-volkov/lawful-conversions"; + url = ""; + synopsis = "Lawful typeclasses for bidirectional conversion between types"; + description = "= Summary\n\nLawful typeclasses capturing three patterns of bidirectional mapping and forming a layered hierarchy with an ascending strictness of laws.\n\n1. `IsSome`: Smart constructor\n\n2. `IsMany`: Lossy conversion\n\n3. `Is`: Isomorphism or lossless conversion\n\n= The conversion problem\n\nHave you ever looked for a @toString@ function? How often do you\nimport @Data.Text.Lazy@ only to call its 'Data.Text.Lazy.fromStrict'? How\nabout importing @Data.ByteString.Builder@ only to call its\n'Data.ByteString.Builder.toLazyByteString' and then importing\n@Data.ByteString.Lazy@ only to call its 'Data.ByteString.Lazy.toStrict'?\n\nThose all are instances of one pattern. They are conversions between different\nrepresentations of the same information. Codebases that don't attempt to\nabstract over this pattern tend to be sprawling with this type of\nboilerplate. It's noise to the codereader, it's a burden to the\nimplementor and the maintainer.\n\n= Why another conversion library?\n\nMany libraries exist that approach the conversion problem. However most of\nthem provide lawless typeclasses leaving it up to the author of the\ninstance to define what makes a proper conversion. This results in\ninconsistencies across instances, their behaviour not being evident to\nthe user and no way to check whether an instance is correct.\n\nThis library tackles this problem with a lawful typeclass hierarchy, making it\nevident what any of its instances do and it provides property-tests for you\nto validate your instances.\n\n= Prior work and acknowledgements\n\nThis library is a direct successor of the [\"isomorphism-class\"](https://hackage.haskell.org/package/isomorphism-class) library, expanding upon the patterns discovered there. It also shares some ideas with [\"control-iso\"](https://hackage.haskell.org/package/control-iso) and [\"type-iso\"](https://hackage.haskell.org/package/type-iso)."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."profunctors" or (errorHandler.buildDepError "profunctors")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."uuid-types" or (errorHandler.buildDepError "uuid-types")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + ]; + buildable = true; + }; + tests = { + "test" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."lawful-conversions" or (errorHandler.buildDepError "lawful-conversions")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."quickcheck-instances" or (errorHandler.buildDepError "quickcheck-instances")) + (hsPkgs."rebase" or (errorHandler.buildDepError "rebase")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/lawful-conversions-0.1.2.2-r0-23fc4bd62507c14053c670520b29263b1f6fb34dbaa299336a69ec910a3a5115.nix b/hackage/lawful-conversions-0.1.2.2-r0-23fc4bd62507c14053c670520b29263b1f6fb34dbaa299336a69ec910a3a5115.nix new file mode 100644 index 00000000000..b70c9464d17 --- /dev/null +++ b/hackage/lawful-conversions-0.1.2.2-r0-23fc4bd62507c14053c670520b29263b1f6fb34dbaa299336a69ec910a3a5115.nix @@ -0,0 +1,59 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "lawful-conversions"; version = "0.1.2.2"; }; + license = "MIT"; + copyright = "(c) 2022 Nikita Volkov"; + maintainer = "Nikita Volkov "; + author = "Nikita Volkov "; + homepage = "https://github.com/nikita-volkov/lawful-conversions"; + url = ""; + synopsis = "Lawful typeclasses for bidirectional conversion between types"; + description = "= Summary\n\nLawful typeclasses capturing three patterns of bidirectional mapping and forming a layered hierarchy with an ascending strictness of laws.\n\n1. `IsSome`: Smart constructor\n\n2. `IsMany`: Lossy conversion\n\n3. `Is`: Isomorphism or lossless conversion\n\n= The conversion problem\n\nHave you ever looked for a @toString@ function? How often do you\nimport @Data.Text.Lazy@ only to call its @fromStrict@? How\nabout importing @Data.ByteString.Builder@ only to call its\n@toLazyByteString@ and then importing\n@Data.ByteString.Lazy@ only to call its @toStrict@?\n\nThose all are instances of one pattern. They are conversions between different\nrepresentations of the same information. Codebases that don't attempt to\nabstract over this pattern tend to be sprawling with this type of\nboilerplate. It's noise to the codereader, it's a burden to the\nimplementor and the maintainer.\n\n= Why another conversion library?\n\nMany libraries exist that approach the conversion problem. However most of\nthem provide lawless typeclasses leaving it up to the author of the\ninstance to define what makes a proper conversion. This results in\ninconsistencies across instances, their behaviour not being evident to\nthe user and no way to check whether an instance is correct.\n\nThis library tackles this problem with a lawful typeclass hierarchy, making it\nevident what any of its instances do and it provides property-tests for you\nto validate your instances.\n\n= Prior work and acknowledgements\n\nThis library is a direct successor of the \"[isomorphism-class](https://hackage.haskell.org/package/isomorphism-class)\" library, expanding upon the patterns discovered there. It also shares some ideas with \"[control-iso](https://hackage.haskell.org/package/control-iso)\" and \"[type-iso](https://hackage.haskell.org/package/type-iso)\"."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."profunctors" or (errorHandler.buildDepError "profunctors")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."uuid-types" or (errorHandler.buildDepError "uuid-types")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + ]; + buildable = true; + }; + tests = { + "test" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."lawful-conversions" or (errorHandler.buildDepError "lawful-conversions")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."quickcheck-instances" or (errorHandler.buildDepError "quickcheck-instances")) + (hsPkgs."rebase" or (errorHandler.buildDepError "rebase")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/lawful-conversions-0.1.3-r0-b0b635df17ad69f347a6249ec73fe6ded77365dce680f871de548792b3133569.nix b/hackage/lawful-conversions-0.1.3-r0-b0b635df17ad69f347a6249ec73fe6ded77365dce680f871de548792b3133569.nix new file mode 100644 index 00000000000..2f0a82831f6 --- /dev/null +++ b/hackage/lawful-conversions-0.1.3-r0-b0b635df17ad69f347a6249ec73fe6ded77365dce680f871de548792b3133569.nix @@ -0,0 +1,60 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "3.0"; + identifier = { name = "lawful-conversions"; version = "0.1.3"; }; + license = "MIT"; + copyright = "(c) 2022 Nikita Volkov"; + maintainer = "Nikita Volkov "; + author = "Nikita Volkov "; + homepage = "https://github.com/nikita-volkov/lawful-conversions"; + url = ""; + synopsis = "Lawful typeclasses for bidirectional conversion between types"; + description = "= Summary\n\nLawful typeclasses capturing three patterns of bidirectional mapping and forming a layered hierarchy with an ascending strictness of laws.\n\n1. Smart constructor\n\n2. Canonicalization or lossy conversion\n\n3. Isomorphism or lossless conversion\n\n= The conversion problem\n\nHave you ever looked for a @toString@ function? How often do you\nimport @Data.Text.Lazy@ only to call its @fromStrict@? How\nabout importing @Data.ByteString.Builder@ only to call its\n@toLazyByteString@ and then importing\n@Data.ByteString.Lazy@ only to call its @toStrict@?\n\nThose all are instances of one pattern. They are conversions between different\nrepresentations of the same information. Codebases that don't attempt to\nabstract over this pattern tend to be sprawling with this type of\nboilerplate. It's noise to the codereader, it's a burden to the\nimplementor and the maintainer.\n\n= Why another conversion library?\n\nMany libraries exist that approach the conversion problem. However most of\nthem provide lawless typeclasses leaving it up to the author of the\ninstance to define what makes a proper conversion. This results in\ninconsistencies across instances, their behaviour not being evident to\nthe user and no way to check whether an instance is correct.\n\nThis library tackles this problem with a lawful typeclass hierarchy, making it\nevident what any of its instances do and it provides property-tests for you\nto validate your instances.\n\n= Prior work and acknowledgements\n\nThis library is a direct successor of the \"[isomorphism-class](https://hackage.haskell.org/package/isomorphism-class)\" library, expanding upon the patterns discovered there. It also shares some ideas with \"[control-iso](https://hackage.haskell.org/package/control-iso)\" and \"[type-iso](https://hackage.haskell.org/package/type-iso)\"."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."hashable" or (errorHandler.buildDepError "hashable")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."profunctors" or (errorHandler.buildDepError "profunctors")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."time" or (errorHandler.buildDepError "time")) + (hsPkgs."unordered-containers" or (errorHandler.buildDepError "unordered-containers")) + (hsPkgs."uuid-types" or (errorHandler.buildDepError "uuid-types")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + ]; + buildable = true; + }; + tests = { + "test" = { + depends = [ + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."lawful-conversions" or (errorHandler.buildDepError "lawful-conversions")) + (hsPkgs."primitive" or (errorHandler.buildDepError "primitive")) + (hsPkgs."quickcheck-instances" or (errorHandler.buildDepError "quickcheck-instances")) + (hsPkgs."rebase" or (errorHandler.buildDepError "rebase")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + (hsPkgs."tasty-quickcheck" or (errorHandler.buildDepError "tasty-quickcheck")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/ngx-export-distribution-0.6.0.1-r0-306c61eabf0bd782dadea52c528b41241eb7aef5c71954806c8b85b7bd91384b.nix b/hackage/ngx-export-distribution-0.6.0.1-r0-306c61eabf0bd782dadea52c528b41241eb7aef5c71954806c8b85b7bd91384b.nix new file mode 100644 index 00000000000..72f2daa0074 --- /dev/null +++ b/hackage/ngx-export-distribution-0.6.0.1-r0-306c61eabf0bd782dadea52c528b41241eb7aef5c71954806c8b85b7bd91384b.nix @@ -0,0 +1,52 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.20"; + identifier = { name = "ngx-export-distribution"; version = "0.6.0.1"; }; + license = "BSD-3-Clause"; + copyright = "2021-2024 Alexey Radkov"; + maintainer = "Alexey Radkov "; + author = "Alexey Radkov "; + homepage = "https://github.com/lyokha/nginx-haskell-module"; + url = ""; + synopsis = "Build custom libraries for Nginx Haskell module"; + description = "Build custom libraries for\n."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + ]; + buildable = true; + }; + exes = { + "nhm-tool" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."Cabal" or (errorHandler.buildDepError "Cabal")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."filepath" or (errorHandler.buildDepError "filepath")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."ansi-terminal" or (errorHandler.buildDepError "ansi-terminal")) + (hsPkgs."cabal-plan" or (errorHandler.buildDepError "cabal-plan")) + (hsPkgs."parsec" or (errorHandler.buildDepError "parsec")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/reflection-2.1.9-r0-6f0ac9648b61040293e9257bac90123102c546ae1e2f924c3fdebba340a9381b.nix b/hackage/reflection-2.1.9-r0-6f0ac9648b61040293e9257bac90123102c546ae1e2f924c3fdebba340a9381b.nix new file mode 100644 index 00000000000..03b05a84233 --- /dev/null +++ b/hackage/reflection-2.1.9-r0-6f0ac9648b61040293e9257bac90123102c546ae1e2f924c3fdebba340a9381b.nix @@ -0,0 +1,48 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { slow = false; template-haskell = true; }; + package = { + specVersion = "1.10"; + identifier = { name = "reflection"; version = "2.1.9"; }; + license = "BSD-3-Clause"; + copyright = "2009-2013 Edward A. Kmett,\n2012 Elliott Hird,\n2004 Oleg Kiselyov and Chung-chieh Shan"; + maintainer = "Edward A. Kmett "; + author = "Edward A. Kmett, Elliott Hird, Oleg Kiselyov and Chung-chieh Shan"; + homepage = "http://github.com/ekmett/reflection"; + url = ""; + synopsis = "Reifies arbitrary terms into types that can be reflected back into terms"; + description = "This package addresses the /configuration problem/ which is\npropagating configurations that are available at run-time, allowing\nmultiple configurations to coexist without resorting to mutable\nglobal variables or 'System.IO.Unsafe.unsafePerformIO'.\n\nThat package is an implementation of the ideas presented in the\npaper \\\"Functional Pearl: Implicit Configurations\\\" by Oleg Kiselyov\nand Chung-chieh Shan ().\nHowever, the API has been streamlined to improve performance.\n\nThere are a handful of tutorials on how to use this library:\n\n* Austin Seipp's tutorial provides a summary of the\napproach taken by this library, along with more motivating examples.\n\n* Arnaud Spiwack's tutorial explains how to use this library."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + ] ++ (pkgs.lib).optional (flags.template-haskell && (compiler.isGhc && true)) (hsPkgs."template-haskell" or (errorHandler.buildDepError "template-haskell")); + buildable = true; + }; + tests = { + "spec" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."hspec" or (errorHandler.buildDepError "hspec")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."reflection" or (errorHandler.buildDepError "reflection")) + ]; + build-tools = [ + (hsPkgs.buildPackages.hspec-discover.components.exes.hspec-discover or (pkgs.buildPackages.hspec-discover or (errorHandler.buildToolDepError "hspec-discover:hspec-discover"))) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/sqlite-easy-1.1.1.0-r0-57538ee4bac16992b8561b1c205ad21962b5840567379770bf2efc29822401fb.nix b/hackage/sqlite-easy-1.1.1.0-r0-57538ee4bac16992b8561b1c205ad21962b5840567379770bf2efc29822401fb.nix new file mode 100644 index 00000000000..9cfd355fdd9 --- /dev/null +++ b/hackage/sqlite-easy-1.1.1.0-r0-57538ee4bac16992b8561b1c205ad21962b5840567379770bf2efc29822401fb.nix @@ -0,0 +1,68 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "2.4"; + identifier = { name = "sqlite-easy"; version = "1.1.1.0"; }; + license = "BSD-3-Clause"; + copyright = "2022-2024 Gil Mizrahi"; + maintainer = "gil@gilmi.net"; + author = "Gil Mizrahi"; + homepage = "https://gitlab.com/gilmi/sqlite-easy"; + url = ""; + synopsis = "A primitive yet easy to use sqlite library."; + description = "A primitive yet easy to use sqlite library built using sqlite-direct, resource-pool and migrant."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."mtl" or (errorHandler.buildDepError "mtl")) + (hsPkgs."unliftio-core" or (errorHandler.buildDepError "unliftio-core")) + (hsPkgs."direct-sqlite" or (errorHandler.buildDepError "direct-sqlite")) + (hsPkgs."resource-pool" or (errorHandler.buildDepError "resource-pool")) + (hsPkgs."migrant-core" or (errorHandler.buildDepError "migrant-core")) + ]; + buildable = true; + }; + tests = { + "sqlite-easy-test" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."hspec" or (errorHandler.buildDepError "hspec")) + (hsPkgs."hspec-discover" or (errorHandler.buildDepError "hspec-discover")) + (hsPkgs."sqlite-easy" or (errorHandler.buildDepError "sqlite-easy")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."direct-sqlite" or (errorHandler.buildDepError "direct-sqlite")) + (hsPkgs."unliftio" or (errorHandler.buildDepError "unliftio")) + ]; + build-tools = [ + (hsPkgs.buildPackages.hspec-discover.components.exes.hspec-discover or (pkgs.buildPackages.hspec-discover or (errorHandler.buildToolDepError "hspec-discover:hspec-discover"))) + ]; + buildable = true; + }; + }; + benchmarks = { + "sqlite-easy-bench" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."criterion" or (errorHandler.buildDepError "criterion")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."sqlite-easy" or (errorHandler.buildDepError "sqlite-easy")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/tasty-bench-0.4-r1-06e336ea94ae35f116318e535a7d70947734bb7dae35f6ba36cfbd0bb23c1fe3.nix b/hackage/tasty-bench-0.4-r1-06e336ea94ae35f116318e535a7d70947734bb7dae35f6ba36cfbd0bb23c1fe3.nix new file mode 100644 index 00000000000..7c773353a13 --- /dev/null +++ b/hackage/tasty-bench-0.4-r1-06e336ea94ae35f116318e535a7d70947734bb7dae35f6ba36cfbd0bb23c1fe3.nix @@ -0,0 +1,47 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = { tasty = true; }; + package = { + specVersion = "1.18"; + identifier = { name = "tasty-bench"; version = "0.4"; }; + license = "MIT"; + copyright = "2021 Andrew Lelechenko"; + maintainer = "Andrew Lelechenko "; + author = "Andrew Lelechenko"; + homepage = "https://github.com/Bodigrim/tasty-bench"; + url = ""; + synopsis = "Featherlight benchmark framework"; + description = "Featherlight framework (only one file!)\nfor performance measurement with API mimicking\n@criterion@ and @gauge@, featuring built-in comparison\nagainst previous runs and between benchmarks. Our benchmarks are just\nregular @tasty@ tests."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = (([ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."deepseq" or (errorHandler.buildDepError "deepseq")) + (hsPkgs."ghc-prim" or (errorHandler.buildDepError "ghc-prim")) + ] ++ (pkgs.lib).optionals (flags.tasty) [ + (hsPkgs."containers" or (errorHandler.buildDepError "containers")) + (hsPkgs."tasty" or (errorHandler.buildDepError "tasty")) + ]) ++ (pkgs.lib).optional (compiler.isGhc && (compiler.version).lt "7.8") (hsPkgs."tagged" or (errorHandler.buildDepError "tagged"))) ++ (pkgs.lib).optional (compiler.isGhc && (compiler.version).lt "8.4") (hsPkgs."time" or (errorHandler.buildDepError "time")); + buildable = true; + }; + benchmarks = { + "bench-fibo" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."tasty-bench" or (errorHandler.buildDepError "tasty-bench")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/hackage/toxcore-c-0.2.19-r0-61959fb920dcdb1feb291486b489af310a8dcea9d3fa817df0b4b076909d8ab9.nix b/hackage/toxcore-c-0.2.19-r0-61959fb920dcdb1feb291486b489af310a8dcea9d3fa817df0b4b076909d8ab9.nix new file mode 100644 index 00000000000..d63733ec3ab --- /dev/null +++ b/hackage/toxcore-c-0.2.19-r0-61959fb920dcdb1feb291486b489af310a8dcea9d3fa817df0b4b076909d8ab9.nix @@ -0,0 +1,70 @@ +{ system + , compiler + , flags + , pkgs + , hsPkgs + , pkgconfPkgs + , errorHandler + , config + , ... }: + { + flags = {}; + package = { + specVersion = "1.10"; + identifier = { name = "toxcore-c"; version = "0.2.19"; }; + license = "GPL-3.0-only"; + copyright = "Copyright (c) 2016-2020 The TokTok Team"; + maintainer = "iphy"; + author = "iphy"; + homepage = "https://toktok.github.io"; + url = ""; + synopsis = "Haskell bindings to the C reference implementation of Tox"; + description = "Haskell bindings to the C reference implementation of Tox.\n\nSee ."; + buildType = "Simple"; + }; + components = { + "library" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."generic-arbitrary" or (errorHandler.buildDepError "generic-arbitrary")) + (hsPkgs."msgpack-binary" or (errorHandler.buildDepError "msgpack-binary")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."quickcheck-instances" or (errorHandler.buildDepError "quickcheck-instances")) + ]; + libs = [ (pkgs."toxcore" or (errorHandler.sysDepError "toxcore")) ]; + buildable = true; + }; + exes = { + "groupbot" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base16-bytestring" or (errorHandler.buildDepError "base16-bytestring")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."directory" or (errorHandler.buildDepError "directory")) + (hsPkgs."text" or (errorHandler.buildDepError "text")) + (hsPkgs."toxcore-c" or (errorHandler.buildDepError "toxcore-c")) + ]; + libs = [ (pkgs."toxcore" or (errorHandler.sysDepError "toxcore")) ]; + buildable = true; + }; + }; + tests = { + "testsuite" = { + depends = [ + (hsPkgs."base" or (errorHandler.buildDepError "base")) + (hsPkgs."base16-bytestring" or (errorHandler.buildDepError "base16-bytestring")) + (hsPkgs."bytestring" or (errorHandler.buildDepError "bytestring")) + (hsPkgs."cryptohash" or (errorHandler.buildDepError "cryptohash")) + (hsPkgs."hspec" or (errorHandler.buildDepError "hspec")) + (hsPkgs."msgpack-binary" or (errorHandler.buildDepError "msgpack-binary")) + (hsPkgs."QuickCheck" or (errorHandler.buildDepError "QuickCheck")) + (hsPkgs."saltine" or (errorHandler.buildDepError "saltine")) + (hsPkgs."toxcore-c" or (errorHandler.buildDepError "toxcore-c")) + (hsPkgs."vector" or (errorHandler.buildDepError "vector")) + ]; + buildable = true; + }; + }; + }; + } \ No newline at end of file diff --git a/index-state-hashes.nix b/index-state-hashes.nix index 852830d7a83..c4d0bbf8eaa 100644 --- a/index-state-hashes.nix +++ b/index-state-hashes.nix @@ -2074,4 +2074,5 @@ "2024-12-02T00:00:00Z" = "7c5a4ef90b2986970d3e359f495bfbb47d607d081b8f27a9fa7021f136c47d31"; "2024-12-03T00:00:00Z" = "0b6dc80142e34b1dd5393c64587c789a1fed7759bd935fa7d93a145d215ca77b"; "2024-12-04T00:00:00Z" = "0976fef5a9d9ca48bbcfbfc5b50b441b61d1b1eb49ba4accd41c5889b5535458"; + "2024-12-05T00:00:00Z" = "1c8f8ceea4435f9783d82db775699506afc8ffd84d9eb8c0f97db08a8bf33b95"; } diff --git a/nix/_Click_Haskell.nix b/nix/_Click_Haskell.nix index 641e524c39e..8214be855fb 100644 --- a/nix/_Click_Haskell.nix +++ b/nix/_Click_Haskell.nix @@ -8,7 +8,13 @@ revTimestamp = "2024-12-02T03:54:36Z"; sha256 = "5439b9f1cc3a68be6cc60fc0691e7f75a68415b83655c6a4e06e1249bd62a111"; }; - default = "r0"; + r1 = { + nix = import ../hackage/ClickHaskell-0.1.0-r1-3f3f97114628d66a5ac3cc9a7e308aee5e1c98ecf495b6743ff72bba07d515b5.nix; + revNum = 1; + revTimestamp = "2024-12-04T22:24:05Z"; + sha256 = "3f3f97114628d66a5ac3cc9a7e308aee5e1c98ecf495b6743ff72bba07d515b5"; + }; + default = "r1"; }; }; } \ No newline at end of file diff --git a/nix/bytes.nix b/nix/bytes.nix index fccca059cbc..1cfb10d6677 100644 --- a/nix/bytes.nix +++ b/nix/bytes.nix @@ -653,6 +653,24 @@ default = "r2"; }; }; + "0.17.4" = { + sha256 = "8ca99a2449ae1233440930c8393eda065108a8725025bf079c61c6f3a4e5a393"; + revisions = { + r0 = { + nix = import ../hackage/bytes-0.17.4-r0-b83d3d91c4574a11221df328d14b4e1e14a60096d0a6131153d5f757eb0dc7b5.nix; + revNum = 0; + revTimestamp = "2024-12-04T12:50:05Z"; + sha256 = "b83d3d91c4574a11221df328d14b4e1e14a60096d0a6131153d5f757eb0dc7b5"; + }; + r1 = { + nix = import ../hackage/bytes-0.17.4-r1-27b117394065d8b8bd845c54dc0128f88f4b0c1a1242699f7603a80963ba1f4a.nix; + revNum = 1; + revTimestamp = "2024-12-04T12:55:18Z"; + sha256 = "27b117394065d8b8bd845c54dc0128f88f4b0c1a1242699f7603a80963ba1f4a"; + }; + default = "r1"; + }; + }; "0.2" = { sha256 = "09856cfd2db5a090dabdcc0dda1d6a777b5c9899c3a30fac53469467840bcaa4"; revisions = { diff --git a/nix/charset.nix b/nix/charset.nix index bbce63ea9d9..6d3f5b6aa61 100644 --- a/nix/charset.nix +++ b/nix/charset.nix @@ -197,6 +197,18 @@ default = "r1"; }; }; + "0.3.11" = { + sha256 = "9343757569249865b42aa218461c311d619d3c8027dfddbb635146363cc08aac"; + revisions = { + r0 = { + nix = import ../hackage/charset-0.3.11-r0-0521970d253950ae712425a03c886bdc8a88a08dc0e095fa63250b0977328f03.nix; + revNum = 0; + revTimestamp = "2024-12-04T12:25:05Z"; + sha256 = "0521970d253950ae712425a03c886bdc8a88a08dc0e095fa63250b0977328f03"; + }; + default = "r0"; + }; + }; "0.3.2" = { sha256 = "2a602eada4268b333df267dc82589edfbd427f09eb7cacb0245fd37cce3b1e66"; revisions = { diff --git a/nix/comonad.nix b/nix/comonad.nix index acd548419dd..a8c643df066 100644 --- a/nix/comonad.nix +++ b/nix/comonad.nix @@ -1049,4 +1049,16 @@ default = "r2"; }; }; + "5.0.9" = { + sha256 = "69fb0eb49a80055a9b76d31d0a5648777c4050ac8dbf56a9344b862ed878a789"; + revisions = { + r0 = { + nix = import ../hackage/comonad-5.0.9-r0-f7bf55e62c24e9a9f523dc63e8b644a0eb5e1f6179366b16177ef68a5d4cdb15.nix; + revNum = 0; + revTimestamp = "2024-12-04T12:50:42Z"; + sha256 = "f7bf55e62c24e9a9f523dc63e8b644a0eb5e1f6179366b16177ef68a5d4cdb15"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/eventlog2html.nix b/nix/eventlog2html.nix index c3cfd39fa0a..6356fe0bc8b 100644 --- a/nix/eventlog2html.nix +++ b/nix/eventlog2html.nix @@ -50,7 +50,13 @@ revTimestamp = "2024-08-17T16:48:50Z"; sha256 = "15c4770f233500e9fd1642cfcd25d4263951c57ef02f5e36f3beb960e81e229c"; }; - default = "r0"; + r1 = { + nix = import ../hackage/eventlog2html-0.11.1-r1-5142ac71e1864d8b1d8ccfb0452a6d980ef2bbf0c51f2a2449a323075202ab4f.nix; + revNum = 1; + revTimestamp = "2024-12-04T12:33:55Z"; + sha256 = "5142ac71e1864d8b1d8ccfb0452a6d980ef2bbf0c51f2a2449a323075202ab4f"; + }; + default = "r1"; }; }; "0.2.0" = { diff --git a/nix/fedora-releases.nix b/nix/fedora-releases.nix index 063dd965998..78c924472a5 100644 --- a/nix/fedora-releases.nix +++ b/nix/fedora-releases.nix @@ -11,4 +11,16 @@ default = "r0"; }; }; + "0.2.0" = { + sha256 = "32c449c63b296ac8c6fac0bba3660dab7d97c7d5cdd9ae48f3e15ebdf26313de"; + revisions = { + r0 = { + nix = import ../hackage/fedora-releases-0.2.0-r0-a4abd965642628d5732a73f195fe232b25b75f55e1e8b36f8578dcefa4bb99d6.nix; + revNum = 0; + revTimestamp = "2024-12-04T17:08:01Z"; + sha256 = "a4abd965642628d5732a73f195fe232b25b75f55e1e8b36f8578dcefa4bb99d6"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/ghc-lib-parser.nix b/nix/ghc-lib-parser.nix index 57216335129..f5524ebf264 100644 --- a/nix/ghc-lib-parser.nix +++ b/nix/ghc-lib-parser.nix @@ -1544,7 +1544,13 @@ revTimestamp = "2024-11-30T13:06:42Z"; sha256 = "f01b64af0b6b07ef769e37fdbaa4ed73e3ad803a92cdcbfc2d86360866588da5"; }; - default = "r0"; + r1 = { + nix = import ../hackage/ghc-lib-parser-9.8.4.20241130-r1-18d72b8794b507613f1e311b5d624f46544a6afe1c149053294d80d60f6eafd4.nix; + revNum = 1; + revTimestamp = "2024-12-04T16:29:32Z"; + sha256 = "18d72b8794b507613f1e311b5d624f46544a6afe1c149053294d80d60f6eafd4"; + }; + default = "r1"; }; }; } \ No newline at end of file diff --git a/nix/ghc-lib.nix b/nix/ghc-lib.nix index 4d45ecb9123..8745ac568c7 100644 --- a/nix/ghc-lib.nix +++ b/nix/ghc-lib.nix @@ -1526,7 +1526,13 @@ revTimestamp = "2024-11-30T13:07:50Z"; sha256 = "7ec3bdb3c9c2c9d12e231e8030351927ca07a27b049c2aaef226ba81cf5f61a0"; }; - default = "r0"; + r1 = { + nix = import ../hackage/ghc-lib-9.8.4.20241130-r1-7f8d71e34b78c341e1e5c60817b6ad9615d3c87218959b989e72c398ec1f3572.nix; + revNum = 1; + revTimestamp = "2024-12-04T16:30:31Z"; + sha256 = "7f8d71e34b78c341e1e5c60817b6ad9615d3c87218959b989e72c398ec1f3572"; + }; + default = "r1"; }; }; } \ No newline at end of file diff --git a/nix/ghc-source-gen.nix b/nix/ghc-source-gen.nix index 5a0d0b909ef..4463dd1b52e 100644 --- a/nix/ghc-source-gen.nix +++ b/nix/ghc-source-gen.nix @@ -131,4 +131,16 @@ default = "r0"; }; }; + "0.4.6.0" = { + sha256 = "948e1c058739097ef5bb213da4fa13759ae4a15e58d969934fe2557994762f03"; + revisions = { + r0 = { + nix = import ../hackage/ghc-source-gen-0.4.6.0-r0-e6a310d225e65f453fca3d365952c99e69ed2ce7f2d6c14e464ef6ff590cf8fb.nix; + revNum = 0; + revTimestamp = "2024-12-04T05:08:59Z"; + sha256 = "e6a310d225e65f453fca3d365952c99e69ed2ce7f2d6c14e464ef6ff590cf8fb"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/gloss-algorithms.nix b/nix/gloss-algorithms.nix index 63ebf1ff018..3c2aa018827 100644 --- a/nix/gloss-algorithms.nix +++ b/nix/gloss-algorithms.nix @@ -104,7 +104,13 @@ revTimestamp = "2022-03-20T08:44:32Z"; sha256 = "f2e5749bcf43aa0cd0cf74834f923d09417eb417f426ac0586c4da19eef9fce5"; }; - default = "r0"; + r1 = { + nix = import ../hackage/gloss-algorithms-1.13.0.3-r1-0601fb6c0cc5277028851759668bf869ea8ab8ebe878964daec0f6478ab53bb3.nix; + revNum = 1; + revTimestamp = "2024-12-04T21:23:49Z"; + sha256 = "0601fb6c0cc5277028851759668bf869ea8ab8ebe878964daec0f6478ab53bb3"; + }; + default = "r1"; }; }; "1.9.2.1" = { diff --git a/nix/gloss-rendering.nix b/nix/gloss-rendering.nix index c859d1a13a0..bc54e6300d0 100644 --- a/nix/gloss-rendering.nix +++ b/nix/gloss-rendering.nix @@ -164,7 +164,13 @@ revTimestamp = "2024-01-08T15:57:16Z"; sha256 = "2f00aa0fa980427b5d8a2911c34bc0acf16d109c8cfc9addc4e5362aa48a284a"; }; - default = "r1"; + r2 = { + nix = import ../hackage/gloss-rendering-1.13.1.2-r2-2047344b061332101a4c38a1902a4a10b7f11998d3842cfc367b6b5563c3f580.nix; + revNum = 2; + revTimestamp = "2024-12-04T21:23:13Z"; + sha256 = "2047344b061332101a4c38a1902a4a10b7f11998d3842cfc367b6b5563c3f580"; + }; + default = "r2"; }; }; "1.9.1.1" = { diff --git a/nix/gloss.nix b/nix/gloss.nix index b18ca367815..aa4c305de22 100644 --- a/nix/gloss.nix +++ b/nix/gloss.nix @@ -230,7 +230,13 @@ revTimestamp = "2024-01-08T16:01:21Z"; sha256 = "e1a017c22fa337b2eec594dd62db6c9e20cbf02d9e8d98ffd970a1d639a42913"; }; - default = "r1"; + r2 = { + nix = import ../hackage/gloss-1.13.2.2-r2-31467330073c706f28a640b1c891f527b11b5489f2566930a05f29fb872fd0ef.nix; + revNum = 2; + revTimestamp = "2024-12-04T21:13:50Z"; + sha256 = "31467330073c706f28a640b1c891f527b11b5489f2566930a05f29fb872fd0ef"; + }; + default = "r2"; }; }; "1.2.0.0" = { diff --git a/nix/half.nix b/nix/half.nix index 93974e47640..65c1bcde8e5 100644 --- a/nix/half.nix +++ b/nix/half.nix @@ -179,4 +179,16 @@ default = "r2"; }; }; + "0.3.2" = { + sha256 = "19992e9fb6f4ea8a53b0ba0693565e8ec73c620b603e74b6d4f262e49d7df038"; + revisions = { + r0 = { + nix = import ../hackage/half-0.3.2-r0-dc49517b0f8c2523218c55190909e6a2ca0185563976a8000632ea45609e08c4.nix; + revNum = 0; + revTimestamp = "2024-12-04T12:27:01Z"; + sha256 = "dc49517b0f8c2523218c55190909e6a2ca0185563976a8000632ea45609e08c4"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/haskoin-store.nix b/nix/haskoin-store.nix index 2392703237c..1489f49caa5 100644 --- a/nix/haskoin-store.nix +++ b/nix/haskoin-store.nix @@ -3719,6 +3719,18 @@ default = "r0"; }; }; + "1.5.14" = { + sha256 = "fae6957a52d913429cd7a3c2f3d6b9db29bd98d0ac210453c0dfc4f76bb949a0"; + revisions = { + r0 = { + nix = import ../hackage/haskoin-store-1.5.14-r0-268683641ff4b96632ce279546bd9d03938a11b91e2fe8c94ded99520128764e.nix; + revNum = 0; + revTimestamp = "2024-12-04T11:02:22Z"; + sha256 = "268683641ff4b96632ce279546bd9d03938a11b91e2fe8c94ded99520128764e"; + }; + default = "r0"; + }; + }; "1.5.2" = { sha256 = "cebf75dfc7d30cf7754db86f0160bd9f79961748fa764c342fde1400ee87157b"; revisions = { diff --git a/nix/heaps.nix b/nix/heaps.nix index c153a1a70d8..a0f495bf7e0 100644 --- a/nix/heaps.nix +++ b/nix/heaps.nix @@ -275,4 +275,16 @@ default = "r0"; }; }; + "0.4.1" = { + sha256 = "8763a4663a2d0b3c912400a547d66ae11b46a954403b6747272148e950aa0382"; + revisions = { + r0 = { + nix = import ../hackage/heaps-0.4.1-r0-74ce60a23b8ef247b8bca71eeb38289e82b3b5e83b2383600b2c838a68218068.nix; + revNum = 0; + revTimestamp = "2024-12-04T12:18:52Z"; + sha256 = "74ce60a23b8ef247b8bca71eeb38289e82b3b5e83b2383600b2c838a68218068"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/horizontal-rule.nix b/nix/horizontal-rule.nix index 5da5275051a..36b0ffaf780 100644 --- a/nix/horizontal-rule.nix +++ b/nix/horizontal-rule.nix @@ -47,4 +47,16 @@ default = "r4"; }; }; + "0.7.0.0" = { + sha256 = "3d7537af59879b4ea7dc863b0677d53511ebda7368e2817620ec0599dd719068"; + revisions = { + r0 = { + nix = import ../hackage/horizontal-rule-0.7.0.0-r0-ae1b4bc0d9d69baac9eee14f8ba106a9c61c01981678610d6a0e2be5ab4f9ea0.nix; + revNum = 0; + revTimestamp = "2024-12-04T09:51:38Z"; + sha256 = "ae1b4bc0d9d69baac9eee14f8ba106a9c61c01981678610d6a0e2be5ab4f9ea0"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/hybrid-vectors.nix b/nix/hybrid-vectors.nix index db620abac24..ebb0f3a5d18 100644 --- a/nix/hybrid-vectors.nix +++ b/nix/hybrid-vectors.nix @@ -167,4 +167,16 @@ default = "r2"; }; }; + "0.2.5" = { + sha256 = "0b038ae2afcb015c6f8e0201be52821555677daa4f10f9c98e3a86d8df635325"; + revisions = { + r0 = { + nix = import ../hackage/hybrid-vectors-0.2.5-r0-d4041e1e58b29ed60b8c4681c4b7990b7c76049c097a2d95cd901380fd129d67.nix; + revNum = 0; + revTimestamp = "2024-12-04T12:33:49Z"; + sha256 = "d4041e1e58b29ed60b8c4681c4b7990b7c76049c097a2d95cd901380fd129d67"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/intern.nix b/nix/intern.nix index 6862ca13d46..3c1b17145ec 100644 --- a/nix/intern.nix +++ b/nix/intern.nix @@ -335,4 +335,16 @@ default = "r2"; }; }; + "0.9.6" = { + sha256 = "8ec93e0d74b3700bc61f861d9311c66358faa52cda81bbb403ff7f15bec936ca"; + revisions = { + r0 = { + nix = import ../hackage/intern-0.9.6-r0-1a0c01d19739a9e575d001ad4fc55cdfe90f8ef7db426498b1e251ed175ce855.nix; + revNum = 0; + revTimestamp = "2024-12-04T12:14:07Z"; + sha256 = "1a0c01d19739a9e575d001ad4fc55cdfe90f8ef7db426498b1e251ed175ce855"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/intervals.nix b/nix/intervals.nix index a49c81ff3c0..772002d4267 100644 --- a/nix/intervals.nix +++ b/nix/intervals.nix @@ -443,4 +443,16 @@ default = "r0"; }; }; + "0.9.3" = { + sha256 = "d6b67c694b5f67d07e8d3376965451e7db3d2212a421b915a57d3df76ff81a1f"; + revisions = { + r0 = { + nix = import ../hackage/intervals-0.9.3-r0-82f7df005cbd6edbc1c8860fa70bba1a8bad673743be80bc357788652006d07c.nix; + revNum = 0; + revTimestamp = "2024-12-04T12:40:51Z"; + sha256 = "82f7df005cbd6edbc1c8860fa70bba1a8bad673743be80bc357788652006d07c"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/ip2location.nix b/nix/ip2location.nix index 487a0e3a3d3..f82d1c25e8f 100644 --- a/nix/ip2location.nix +++ b/nix/ip2location.nix @@ -107,4 +107,16 @@ default = "r0"; }; }; + "8.5.1" = { + sha256 = "8aa9a55c1c19d52c802e20eca729cefa1fea70f6ec247d1c02aa606e7616b474"; + revisions = { + r0 = { + nix = import ../hackage/ip2location-8.5.1-r0-461159aa584da4a8db78508d5557d36632adbbac8678ff0cb1e8dbe690e53d0b.nix; + revNum = 0; + revTimestamp = "2024-12-04T06:35:05Z"; + sha256 = "461159aa584da4a8db78508d5557d36632adbbac8678ff0cb1e8dbe690e53d0b"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/ip2proxy.nix b/nix/ip2proxy.nix index 2c1d5489d80..274288db86f 100644 --- a/nix/ip2proxy.nix +++ b/nix/ip2proxy.nix @@ -95,4 +95,16 @@ default = "r0"; }; }; + "3.2.1" = { + sha256 = "ff994b2c105b18f8c1de5f8718041dc597201c28d5a16fc303f98dc52f5f1883"; + revisions = { + r0 = { + nix = import ../hackage/ip2proxy-3.2.1-r0-7d348bdcabbd691fbc7af2379a23cddd0b283a5a867499f2143a1b279cec620d.nix; + revNum = 0; + revTimestamp = "2024-12-04T08:02:56Z"; + sha256 = "7d348bdcabbd691fbc7af2379a23cddd0b283a5a867499f2143a1b279cec620d"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/lawful-conversions.nix b/nix/lawful-conversions.nix index 2fc18919f7d..1cfb412d183 100644 --- a/nix/lawful-conversions.nix +++ b/nix/lawful-conversions.nix @@ -20,7 +20,37 @@ revTimestamp = "2024-12-03T02:48:06Z"; sha256 = "ac36513a8b83e2ed8b8483426abf5b02c8b2e0e454d3502abe2b6bf62f65ad41"; }; - default = "r0"; + r1 = { + nix = import ../hackage/lawful-conversions-0.1.1-r1-122baa7ec69d983da1feadeed66064543376395bed40a5a6ad12fba0e292ba43.nix; + revNum = 1; + revTimestamp = "2024-12-04T05:48:29Z"; + sha256 = "122baa7ec69d983da1feadeed66064543376395bed40a5a6ad12fba0e292ba43"; + }; + r2 = { + nix = import ../hackage/lawful-conversions-0.1.1-r2-9ec257c52deb296660e3cd18bc6aaf76a8d9aaf9fc4c0bca0190b4bfded48212.nix; + revNum = 2; + revTimestamp = "2024-12-04T05:53:37Z"; + sha256 = "9ec257c52deb296660e3cd18bc6aaf76a8d9aaf9fc4c0bca0190b4bfded48212"; + }; + r3 = { + nix = import ../hackage/lawful-conversions-0.1.1-r3-85762616fc1acbcf643f9da133ef2f248328fda5d0b65d1bbe9f363df572159b.nix; + revNum = 3; + revTimestamp = "2024-12-04T06:01:16Z"; + sha256 = "85762616fc1acbcf643f9da133ef2f248328fda5d0b65d1bbe9f363df572159b"; + }; + r4 = { + nix = import ../hackage/lawful-conversions-0.1.1-r4-0fc4fc2cfcc69ff336bbe0863eeddb54355859319c1eee0c8ceb5e8a6444e588.nix; + revNum = 4; + revTimestamp = "2024-12-04T06:17:57Z"; + sha256 = "0fc4fc2cfcc69ff336bbe0863eeddb54355859319c1eee0c8ceb5e8a6444e588"; + }; + r5 = { + nix = import ../hackage/lawful-conversions-0.1.1-r5-176e908155df2de5c499690b16288366fa09970cc2101f7245b096a4a99c82a8.nix; + revNum = 5; + revTimestamp = "2024-12-04T06:18:42Z"; + sha256 = "176e908155df2de5c499690b16288366fa09970cc2101f7245b096a4a99c82a8"; + }; + default = "r5"; }; }; "0.1.2" = { @@ -35,4 +65,40 @@ default = "r0"; }; }; + "0.1.2.1" = { + sha256 = "a794ada20beb0df3056a2516da16165ff9cb5151f08d14337aad682d2b4c4190"; + revisions = { + r0 = { + nix = import ../hackage/lawful-conversions-0.1.2.1-r0-ea31eeeaaaa7e023147b29b5604e266877341fd1258f65acf5529d32924ecfd7.nix; + revNum = 0; + revTimestamp = "2024-12-04T18:37:11Z"; + sha256 = "ea31eeeaaaa7e023147b29b5604e266877341fd1258f65acf5529d32924ecfd7"; + }; + default = "r0"; + }; + }; + "0.1.2.2" = { + sha256 = "32a246c00e3149f1567e9e1451aef44b4bbdcda748493725eefdee5000f1d543"; + revisions = { + r0 = { + nix = import ../hackage/lawful-conversions-0.1.2.2-r0-23fc4bd62507c14053c670520b29263b1f6fb34dbaa299336a69ec910a3a5115.nix; + revNum = 0; + revTimestamp = "2024-12-04T20:08:23Z"; + sha256 = "23fc4bd62507c14053c670520b29263b1f6fb34dbaa299336a69ec910a3a5115"; + }; + default = "r0"; + }; + }; + "0.1.3" = { + sha256 = "479858870bee439cbbb7111084f6addff01ce13bdaf29d308d77c6d6ae6d9381"; + revisions = { + r0 = { + nix = import ../hackage/lawful-conversions-0.1.3-r0-b0b635df17ad69f347a6249ec73fe6ded77365dce680f871de548792b3133569.nix; + revNum = 0; + revTimestamp = "2024-12-04T21:45:01Z"; + sha256 = "b0b635df17ad69f347a6249ec73fe6ded77365dce680f871de548792b3133569"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/ngx-export-distribution.nix b/nix/ngx-export-distribution.nix index 03eafa40123..bb573e88b59 100644 --- a/nix/ngx-export-distribution.nix +++ b/nix/ngx-export-distribution.nix @@ -407,4 +407,16 @@ default = "r0"; }; }; + "0.6.0.1" = { + sha256 = "44a31a66aab799430c8b8e2295f7af950d23075bcdb78d79e13b8a81f449c3c6"; + revisions = { + r0 = { + nix = import ../hackage/ngx-export-distribution-0.6.0.1-r0-306c61eabf0bd782dadea52c528b41241eb7aef5c71954806c8b85b7bd91384b.nix; + revNum = 0; + revTimestamp = "2024-12-04T10:23:59Z"; + sha256 = "306c61eabf0bd782dadea52c528b41241eb7aef5c71954806c8b85b7bd91384b"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/reflection.nix b/nix/reflection.nix index 49b20ec7431..483a4aa909d 100644 --- a/nix/reflection.nix +++ b/nix/reflection.nix @@ -767,4 +767,16 @@ default = "r0"; }; }; + "2.1.9" = { + sha256 = "c6a7d5e41ad0ee1a05c660acf4fd34b21f38330eec165d246b7fffb398e59fb3"; + revisions = { + r0 = { + nix = import ../hackage/reflection-2.1.9-r0-6f0ac9648b61040293e9257bac90123102c546ae1e2f924c3fdebba340a9381b.nix; + revNum = 0; + revTimestamp = "2024-12-04T12:05:19Z"; + sha256 = "6f0ac9648b61040293e9257bac90123102c546ae1e2f924c3fdebba340a9381b"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/sqlite-easy.nix b/nix/sqlite-easy.nix index 3cce3511bca..d05f63511e1 100644 --- a/nix/sqlite-easy.nix +++ b/nix/sqlite-easy.nix @@ -95,4 +95,16 @@ default = "r0"; }; }; + "1.1.1.0" = { + sha256 = "d3222ae6c05b2efbc09276d5dd22825e73ae9d9e9cef27bcfaea092910584f70"; + revisions = { + r0 = { + nix = import ../hackage/sqlite-easy-1.1.1.0-r0-57538ee4bac16992b8561b1c205ad21962b5840567379770bf2efc29822401fb.nix; + revNum = 0; + revTimestamp = "2024-12-04T16:51:00Z"; + sha256 = "57538ee4bac16992b8561b1c205ad21962b5840567379770bf2efc29822401fb"; + }; + default = "r0"; + }; + }; } \ No newline at end of file diff --git a/nix/tasty-bench.nix b/nix/tasty-bench.nix index 0d9dd425ad9..5f5eb9e650d 100644 --- a/nix/tasty-bench.nix +++ b/nix/tasty-bench.nix @@ -230,7 +230,13 @@ revTimestamp = "2024-07-06T11:31:53Z"; sha256 = "97a96e7f779a2e5bb69692e776a5a1bb98423fa1fc7ef561248de99a1214201f"; }; - default = "r0"; + r1 = { + nix = import ../hackage/tasty-bench-0.4-r1-06e336ea94ae35f116318e535a7d70947734bb7dae35f6ba36cfbd0bb23c1fe3.nix; + revNum = 1; + revTimestamp = "2024-12-04T23:45:50Z"; + sha256 = "06e336ea94ae35f116318e535a7d70947734bb7dae35f6ba36cfbd0bb23c1fe3"; + }; + default = "r1"; }; }; } \ No newline at end of file diff --git a/nix/toxcore-c.nix b/nix/toxcore-c.nix index 641ef8c5e39..7e558cb2b2a 100644 --- a/nix/toxcore-c.nix +++ b/nix/toxcore-c.nix @@ -11,4 +11,16 @@ default = "r0"; }; }; + "0.2.19" = { + sha256 = "cd651b3f691a66198a935e892bf73941ff4889d2e9f9226155ed1a56673c9a5d"; + revisions = { + r0 = { + nix = import ../hackage/toxcore-c-0.2.19-r0-61959fb920dcdb1feb291486b489af310a8dcea9d3fa817df0b4b076909d8ab9.nix; + revNum = 0; + revTimestamp = "2024-12-04T21:51:28Z"; + sha256 = "61959fb920dcdb1feb291486b489af310a8dcea9d3fa817df0b4b076909d8ab9"; + }; + default = "r0"; + }; + }; } \ No newline at end of file