diff options
Diffstat (limited to 'andromeda/packages/haskell-xyz.scm')
| -rw-r--r-- | andromeda/packages/haskell-xyz.scm | 1892 |
1 files changed, 1892 insertions, 0 deletions
diff --git a/andromeda/packages/haskell-xyz.scm b/andromeda/packages/haskell-xyz.scm new file mode 100644 index 0000000..956c3a5 --- /dev/null +++ b/andromeda/packages/haskell-xyz.scm @@ -0,0 +1,1892 @@ +(define-module (andromeda packages haskell-xyz) + #:use-module (andromeda packages haskell) + #:use-module (gnu packages) + #:use-module (gnu packages documentation) + #:use-module (gnu packages haskell-check) + #:use-module (gnu packages haskell-crypto) + #:use-module (gnu packages haskell-web) + #:use-module (gnu packages haskell-xyz) + #:use-module (gnu packages llvm) + #:use-module (gnu packages pcre) + #:use-module (gnu packages pkg-config) + #:use-module (gnu packages vulkan) + #:use-module (guix build-system haskell) + #:use-module (guix download) + #:use-module (guix gexp) + #:use-module (guix git-download) + #:use-module ((guix licenses) #:prefix license:) + #:use-module (guix packages) + #:use-module (guix utils) + #:use-module (ice-9 match)) + +(define-public (from-ghc-to-ghc-9.14 name) (string-append "ghc-9.14" (string-drop name (string-length "ghc")))) +(define* (with-ghc-9.14 base) + (package + (inherit base) + (name (from-ghc-to-ghc-9.14 (package-name base))) + (arguments + (append + (list #:haskell ghc-9.14) + (package-arguments base))) + (inputs + (map + (match-lambda + ((input-name input) + (if (string-prefix? "ghc-" input-name) + (list + (from-ghc-to-ghc-9.14 input-name) + (specification->package (from-ghc-to-ghc-9.14 input-name))) + (if (string=? "hspec-discover" input-name) + (list "ghc-9.14-hspec-discover-bootstrap" (specification->package "ghc-9.14-hspec-discover-bootstrap")) + (list input-name input))))) + (package-inputs base))) + (native-inputs + (map + (match-lambda + ((input-name input) + (if (string-prefix? "ghc-" input-name) + (list + (from-ghc-to-ghc-9.14 input-name) + (specification->package (from-ghc-to-ghc-9.14 input-name))) + (list input-name input)))) + (package-native-inputs base))))) + +(define-public ghc-9.14-adjunctions (with-ghc-9.14 ghc-adjunctions)) +(define-public ghc-9.14-aeson + (with-ghc-9.14 + (package + (inherit ghc-aeson) + (version "2.2.5.1") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "aeson" version)) + (sha256 + (base32 "0xdfpvsv9b2fbgz8qkjzlva7xgp3madkp80kpxyqgn5vq18dd0pa"))))))) +(define-public ghc-9.14-alex (with-ghc-9.14 ghc-alex)) +(define-public ghc-9.14-ansi-terminal (with-ghc-9.14 ghc-ansi-terminal)) +(define-public ghc-9.14-ansi-terminal-types (with-ghc-9.14 ghc-ansi-terminal-types)) +(define-public ghc-9.14-ansi-wl-pprint (with-ghc-9.14 ghc-ansi-wl-pprint)) +(define-public ghc-9.14-assoc + (with-ghc-9.14 + (package + (inherit ghc-assoc) + (arguments '(#:cabal-revision ("2" "1r0as5s5a0xv2pcpxj1a1snxc3kdq1crh6hfy7y5n9d5xm010svn")))))) +(define-public ghc-9.14-async + (with-ghc-9.14 + (package + (inherit ghc-async) + (arguments '(#:cabal-revision ("4" "0amddhjsja9b8nc1yhksn94lwgym9zyzw4hkr7ig3vb8g5qpga72")))))) +(define-public ghc-9.14-attoparsec + (with-ghc-9.14 + (package + (inherit ghc-attoparsec) + (version "0.14.4") + (arguments (list #:cabal-revision `("6" "1wrm23wl373219znwbcgpdpyw6a9ahwwhbvx387h07vln459s4im") + #:tests? #f ;; indeterminate until https://github.com/haskell/attoparsec/pull/237 + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "attoparsec.cabal" + (("QuickCheck [ <>=^*&[0-9.]*") "QuickCheck < 2.17"))))))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "attoparsec" version)) + (sha256 + (base32 "0v4yjz4qi8bwhbyavqxlhsfb1iv07v10gxi64khmsmi4hvjpycrz"))))))) +(define-public ghc-9.14-barbies (with-ghc-9.14 ghc-barbies)) +(define-public ghc-9.14-base-compat (with-ghc-9.14 ghc-base-compat)) +(define-public ghc-9.14-base16-bytestring (with-ghc-9.14 ghc-base16-bytestring)) +(define-public ghc-9.14-base64-bytestring (with-ghc-9.14 ghc-base64-bytestring)) +(define-public ghc-9.14-base-orphans (with-ghc-9.14 ghc-base-orphans)) +(define-public ghc-9.14-base-orphans-bootstrap + (package + (inherit ghc-9.14-base-orphans) + (name "ghc-9.14-base-orphans-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-base-orphans))) + (native-inputs `()))) +(define-public ghc-9.14-bifunctors + (with-ghc-9.14 + (package + (inherit ghc-bifunctors) + (version "5.6.3") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "bifunctors" version)) + (sha256 + (base32 "0p0iv1akpmxv4dhsn2sagdlzv9063hzxfh2ha067hk1g09zkaymd"))))))) +(define-public ghc-9.14-bitvec (with-ghc-9.14 ghc-bitvec)) +(define-public ghc-9.14-blaze-builder (with-ghc-9.14 ghc-blaze-builder)) +(define-public ghc-9.14-blaze-html + (with-ghc-9.14 + (package + (inherit ghc-blaze-html) + (arguments (list #:cabal-revision `("1" "0n4w9id53mckgrh3hb9jncxvplxdd588dq7v8j4c9lpayj22zi45") + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "blaze-html.cabal" + (("containers [ <>=^*&[0-9.]*") "containers < 0.9")))))))))) +(define-public ghc-9.14-blaze-markup + (with-ghc-9.14 + (package + (inherit ghc-blaze-markup) + (version "0.8.3.0") + (arguments (list #:cabal-revision `("2" "1r6pkaip7bgv6i4f3klxbqa2vaas9rn4agdr6c57r2njh65j2zq2") + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "blaze-markup.cabal" + (("containers [ <>=^*&[0-9.]*") "containers < 0.9"))))))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "blaze-markup" version)) + (sha256 + (base32 "1s1hb477smr0m8rvpp7vr768hvwv5rsv4w07phdqyzqz9a5sq1l6"))))))) +(define-public ghc-9.14-boring + (with-ghc-9.14 + (package + (inherit ghc-boring) + (version "0.2.2.1") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "boring" version)) + (sha256 + (base32 "0bg6hib3qwxxf46mw3mr0gnzpird8mqwk6wa0s4ahb3qi8fxqvm9"))))))) +(define-public ghc-9.14-call-stack (with-ghc-9.14 ghc-call-stack)) +(define-public ghc-9.14-case-insensitive (with-ghc-9.14 ghc-case-insensitive)) +(define-public ghc-9.14-character-ps (with-ghc-9.14 ghc-character-ps)) +(define-public ghc-9.14-charset (with-ghc-9.14 ghc-charset)) +(define-public ghc-9.14-chasingbottoms + (with-ghc-9.14 + (package + (inherit ghc-chasingbottoms) + (version "1.3.1.17") + (arguments `(#:cabal-revision ("1" "1xz1wpi3k2bzgxnai38840z18hk03ha4xdgjvjg5g8dlja946dih"))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "ChasingBottoms" version)) + (sha256 + (base32 "0713mgd71dix9dq1i812ydahcacfpsxmciqxwhg4qj0migyc4ymg"))))))) +(define-public ghc-9.14-code-page (with-ghc-9.14 ghc-code-page)) +(define-public ghc-9.14-colour (with-ghc-9.14 ghc-colour)) +(define-public ghc-9.14-comonad (with-ghc-9.14 ghc-comonad)) +(define-public ghc-9.14-concurrent-output (with-ghc-9.14 ghc-concurrent-output)) +(define-public ghc-9.14-conduit (with-ghc-9.14 ghc-conduit)) +(define-public ghc-9.14-conduit-extra (with-ghc-9.14 ghc-conduit-extra)) +(define-public ghc-9.14-constraints (with-ghc-9.14 ghc-constraints)) +(define-public ghc-9.14-constraints-extras + (with-ghc-9.14 + (package + (inherit ghc-constraints-extras) + (arguments `(#:cabal-revision ("1" "0iqip860a6gzkiypagxq2sqfi54brybrblmzi4cvd0s1sc0bd5d7")))))) +(define-public ghc-9.14-contravariant (with-ghc-9.14 ghc-contravariant)) +(define-public ghc-9.14-clock (with-ghc-9.14 ghc-clock)) +(define-public ghc-9.14-clock-bootstrap + (package + (inherit ghc-9.14-clock) + (name "ghc-9.14-clock-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-clock))) + (native-inputs `()))) +(define-public ghc-9.14-cryptohash-sha256 (with-ghc-9.14 ghc-cryptohash-sha256)) +(define-public ghc-9.14-data-default + (with-ghc-9.14 + (package + (inherit ghc-data-default) + (arguments `(#:cabal-revision ("1" "0vak67a186xb8fbvk4wkiyhr3dx0limdsi0q7zclysc3syjn8s21")))))) +(define-public ghc-9.14-data-fix + (with-ghc-9.14 + (package + (inherit ghc-data-fix) + (arguments `(#:cabal-revision ("2" "04yk077mzip7ly0b159kkp8gygz0mvaayjfzpfwgh768kk2600r0")))))) +(define-public ghc-9.14-dec + (with-ghc-9.14 + (package + (inherit ghc-dec) + (arguments `(#:cabal-revision ("2" "1zimm9sia4sb05v6z1n980x7zwy4fryrbrqizp1d50gfb7qwblms")))))) +(define-public ghc-9.14-dependent-sum ;; TODO upgrade to 0.8 + (with-ghc-9.14 + (package + (inherit ghc-dependent-sum) + (version "0.7.2.0") + (arguments (list #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "dependent-sum.cabal" + (("some [ <>=^*&[0-9.]*") "some < 1.1"))))))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "dependent-sum" version)) + (sha256 + (base32 "1frw5965v8i6xqdgs95gg8asgdqcqnmfahz0pmbwiaw5ybn62rc2"))))))) +(define-public ghc-9.14-diff (with-ghc-9.14 ghc-diff)) +(define-public ghc-9.14-distributive (with-ghc-9.14 ghc-distributive)) +(define-public ghc-9.14-dlist (with-ghc-9.14 ghc-dlist)) +(define-public ghc-9.14-doctest + (with-ghc-9.14 + (package + (inherit ghc-doctest) + (version "0.24.3") + (source + (origin + (method url-fetch) + (uri (hackage-uri "doctest" version)) + (sha256 + (base32 "0f0j5ds8wihac23ck5fd1bf6m8i4vxnqvazfyn6fasl5247hy935"))))))) +(define-public ghc-9.14-doctest-parallel + (with-ghc-9.14 + (package + (inherit ghc-doctest-parallel) + (version "0.4.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "doctest-parallel" version)) + (sha256 + (base32 "01dagq1wa56hswhabw56dyv172y0lp5fh0gg7ij1i01fqg61rc5s"))))))) +(define-public ghc-9.14-edit-distance + (with-ghc-9.14 + (package + (inherit ghc-edit-distance) + (arguments (list #:cabal-revision `("1" "1vjn4ryzdilz7l1ad7czh11nw48h5mj8if7ij3q0mmc3sffa8csd") + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "edit-distance.cabal" + (("QuickCheck [ <>=^*&[0-9.]*") "QuickCheck < 2.17")))))))))) +(define-public ghc-9.14-erf (with-ghc-9.14 ghc-erf)) +(define-public ghc-9.14-exactprint + (with-ghc-9.14 + (package + (inherit ghc-exactprint) + (version "1.14.1.0") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "ghc-exactprint" version)) + (sha256 + (base32 "0j48z0h55q25j8ymwvcdnrkb9851bw07x72ir1dncnszzmiqfws8"))))))) +(define-public ghc-9.14-extensible-exceptions (with-ghc-9.14 ghc-extensible-exceptions)) +(define-public ghc-9.14-extra (with-ghc-9.14 ghc-extra)) +(define-public ghc-9.14-fail (with-ghc-9.14 ghc-fail)) +(define-public ghc-9.14-filelock (with-ghc-9.14 ghc-filelock)) +(define-public ghc-9.14-finite-typelits + (with-ghc-9.14 + (package + (inherit ghc-finite-typelits) + (version "0.2.1.0") + (arguments (list #:cabal-revision `("2" "0hffbfd0kbxg6w2fgxfsr3q6b54pgwjs12q4ajqjmblfha02pgqk") + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "finite-typelits.cabal" + (("QuickCheck [ <>=^*&[0-9.]*") "QuickCheck < 2.17"))))))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "finite-typelits" version)) + (sha256 + (base32 "0i786r2l3k9fxkpyy6rsi8my6kkar7y8yxk7h9gncm0z6kmvrnvk"))))))) +(define-public ghc-9.14-foldl + (with-ghc-9.14 + (package + (inherit ghc-foldl) + (arguments `(,@(package-arguments ghc-foldl) #:cabal-revision ("2" "0k39y5nmb9h26501iw9xjqjvq87ap78rcs847bkjczapx69gva8x")))))) +(define-public ghc-9.14-free + (with-ghc-9.14 + (package + (inherit ghc-free) + (arguments `(#:cabal-revision ("8" "0r0imkhc4xzyz4azhj6shx595p2ba4f8j9j2svzhhbvwbxj03jir")))))) +(define-public ghc-9.14-generic-deriving + (with-ghc-9.14 + (package + (inherit ghc-generic-deriving) + (arguments `(#:cabal-revision ("2" "18xwnkng3qpjf3y322mbnrmhm3cp8iwz2idzgqzmffxnx1r20ak2")))))) +(define-public ghc-9.14-generically + (with-ghc-9.14 + (package + (inherit ghc-generically) + (arguments `(#:cabal-revision ("5" "0sd3lja677rivn6rxc5a1d6kfilyjsn9jy270a2bapj59liibr3z")))))) +(define-public ghc-9.14-glob (with-ghc-9.14 ghc-glob)) +(define-public ghc-9.14-half (with-ghc-9.14 ghc-half)) +(define-public ghc-9.14-happy (with-ghc-9.14 ghc-happy)) +(define-public ghc-9.14-happy-lib (with-ghc-9.14 ghc-happy-lib)) +(define-public ghc-9.14-hashable + (with-ghc-9.14 + (package + (inherit ghc-hashable) + (version "1.5.1.0") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "hashable" version)) + (sha256 + (base32 "04mig5gzgjbwaq9zycrnzy3b97fkqqwdrni0akjgzjcjrq87q2zd"))))))) +(define-public ghc-9.14-hashable-bootstrap + (package + (inherit ghc-9.14-hashable) + (name "ghc-9.14-hashable-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-hashable))) + (native-inputs '()))) +(define-public ghc-9.14-haskell-lexer (with-ghc-9.14 ghc-haskell-lexer)) +(define-public ghc-9.14-haskell-src-exts (with-ghc-9.14 ghc-haskell-src-exts)) +(define-public ghc-9.14-haskell-src-meta + (with-ghc-9.14 + (package + (inherit ghc-haskell-src-meta) + (arguments `(#:cabal-revision ("1" "1ifh83zib6m113gzd4cfdw70w1lcz1ag5cskxnf1nvsfaa2k115h")))))) +(define-public ghc-9.14-hedgehog + (with-ghc-9.14 + (package + (inherit ghc-hedgehog) + (version "1.7") + (arguments `(#:cabal-revision ("1" "17k8m45craiwpfhp4kypnzxwkv7vzgsh9q99r3k3bzcxnfycqj8z"))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "hedgehog" version)) + (sha256 + (base32 "0kjn3dxyhk55ayjd9m8acr8kxhbzc70piszkiy2gbnwqyyhbrqh9"))))))) +(define-public ghc-9.14-hostname (with-ghc-9.14 ghc-hostname)) +(define-public ghc-9.14-hspec (with-ghc-9.14 ghc-hspec)) +(define-public ghc-9.14-hspec-api (with-ghc-9.14 ghc-hspec-api)) +(define-public ghc-9.14-hspec-core (with-ghc-9.14 ghc-hspec-core)) +(define-public ghc-9.14-hspec-discover (with-ghc-9.14 ghc-hspec-discover)) +(define-public ghc-9.14-hspec-discover-bootstrap + (package + (inherit ghc-9.14-hspec-discover) + (name "ghc-9.14-hspec-discover-bootstrap") + (native-inputs (list ghc-9.14-hspec-meta + ghc-9.14-mockery-bootstrap + ghc-9.14-quickcheck)))) +(define-public ghc-9.14-hspec-meta (with-ghc-9.14 ghc-hspec-meta)) +(define-public ghc-9.14-hspec-expectations (with-ghc-9.14 ghc-hspec-expectations)) +(define-public ghc-9.14-hunit (with-ghc-9.14 ghc-hunit)) +(define-public ghc-9.14-indexed-profunctors (with-ghc-9.14 ghc-indexed-profunctors)) +(define-public ghc-9.14-indexed-traversable + (with-ghc-9.14 + (package + (inherit ghc-indexed-traversable) + (arguments `(#:cabal-revision ("2" "1khvjcdhl9i26r7nmzsrg3vacmrp778m081iswwr0j4m4yww1fla")))))) +(define-public ghc-9.14-indexed-traversable-instances + (with-ghc-9.14 + (package + (inherit ghc-indexed-traversable-instances) + (version "0.1.2.1") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "indexed-traversable-instances" version)) + (sha256 + (base32 "1v0z86lwri4r2hjvwdgjgcpwg2gllis37q5f0cp3qilm7br437g6"))))))) +(define-public ghc-9.14-inline-c (with-ghc-9.14 ghc-inline-c)) +(define-public ghc-9.14-inspection-testing + (with-ghc-9.14 + (package + (inherit ghc-inspection-testing) + (version "0.6.3") + (source + (origin + (method url-fetch) + (uri (hackage-uri "inspection-testing" version)) + (sha256 + (base32 "04p5y2qqp1sbslzjxr961m6ahizq0rhlcx117sl2w5g56s8blibq"))))))) +(define-public ghc-9.14-integer-conversion + (with-ghc-9.14 + (package + (inherit ghc-integer-conversion) + (arguments `(#:cabal-revision ("2" "17vw8kq3glpb5bihhmff10ly78lajw2q33f601jrgw04hh41ng8j")))))) +(define-public ghc-9.14-integer-logarithms + (with-ghc-9.14 + (package + (inherit ghc-integer-logarithms) + (version "1.0.5") + (source + (origin + (method url-fetch) + (uri (hackage-uri "integer-logarithms" version)) + (sha256 + (base32 "0nclcr82rypaj7453iil6xj9asjfrljy37qki731xzkqyzqzdpv6"))))))) +(define-public ghc-9.14-interpolate (with-ghc-9.14 ghc-interpolate)) +(define-public ghc-9.14-invariant + (with-ghc-9.14 + (package + (inherit ghc-invariant) + (version "0.6.5") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "invariant" version)) + (sha256 + (base32 "0fkf75r5wlz72f6544cjz7yaa06bj9lpgk3di4ahzyr5r73xwsv2"))))))) +(define-public ghc-9.14-kan-extensions (with-ghc-9.14 ghc-kan-extensions)) +(define-public ghc-9.14-language-c (with-ghc-9.14 ghc-language-c)) +(define-public ghc-9.14-lens + (with-ghc-9.14 + (package + (inherit ghc-lens) + (version "5.3.6") + (source + (origin + (method url-fetch) + (uri (hackage-uri "lens" version)) + (sha256 + (base32 "1hi320652dqnmcagvn0bfm9cz0zpca5n6hjdp0ks3m54zpqxqifk"))))))) +(define-public ghc-9.14-libyaml (with-ghc-9.14 ghc-libyaml)) +(define-public ghc-9.14-libyaml-clib (with-ghc-9.14 ghc-libyaml-clib)) +(define-public ghc-9.14-lifted-async + (with-ghc-9.14 + (package + (inherit ghc-lifted-async) + (version "0.11.0") + (source + (origin + (method url-fetch) + (uri (hackage-uri "lifted-async" version)) + (sha256 + (base32 "121j10146py2hl1lrywhbaqqghhh0lbafnljmq7qb2jfnjbyjlif"))))))) +(define-public ghc-9.14-lifted-base (with-ghc-9.14 ghc-lifted-base)) +(define-public ghc-9.14-logging-facade (with-ghc-9.14 ghc-logging-facade)) +(define-public ghc-9.14-logging-facade-bootstrap + (package + (inherit ghc-9.14-logging-facade) + (name "ghc-9.14-logging-facade-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-logging-facade))) + (native-inputs '()))) +(define-public ghc-9.14-logict (with-ghc-9.14 ghc-logict)) +(define-public ghc-9.14-math-functions (with-ghc-9.14 ghc-math-functions)) +(define-public ghc-9.14-mmorph (with-ghc-9.14 ghc-mmorph)) +(define-public ghc-9.14-mockery (with-ghc-9.14 ghc-mockery)) +(define-public ghc-9.14-mockery-bootstrap + (package + (inherit ghc-9.14-mockery) + (name "ghc-9.14-mockery-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-mockery))) + (inputs (modify-inputs (package-inputs ghc-9.14-mockery) + (replace "ghc-9.14-logging-facade" ghc-9.14-logging-facade-bootstrap) + (replace "ghc-9.14-temporary" ghc-9.14-temporary-bootstrap))) + (native-inputs '()))) +(define-public ghc-9.14-monad-control (with-ghc-9.14 ghc-monad-control)) +(define-public ghc-9.14-mono-traversable + (with-ghc-9.14 + (package + (inherit ghc-mono-traversable) + (version "1.0.21.0") + (source + (origin + (method url-fetch) + (patches (list (local-file "../../patches/packages-haskell-ghc-9.14-mono-traversable-fix-test-suite.diff"))) + (uri (hackage-uri "mono-traversable" version)) + (sha256 + (base32 "1kf5qwicr8ld4bgkzijxwpzppfwdr4wsl1rg8009a5n06jikxnad"))))))) +(define-public ghc-9.14-nanospec (with-ghc-9.14 ghc-nanospec)) +(define-public ghc-9.14-nanospec-bootstrap + (package + (inherit ghc-9.14-nanospec) + (name "ghc-9.14-nanospec-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-nanospec))) + (native-inputs '()))) +(define-public ghc-9.14-nats (with-ghc-9.14 ghc-nats)) +(define-public ghc-9.14-nats-bootstrap + (package + (inherit ghc-9.14-nats) + (name "ghc-9.14-nats-bootstrap") + (inputs `(("ghc-9.14-hashable" ,ghc-9.14-hashable-bootstrap))))) +(define-public ghc-9.14-network (with-ghc-9.14 ghc-network)) +(define-public ghc-9.14-network-uri (with-ghc-9.14 ghc-network-uri)) +(define-public ghc-9.14-nothunks + (with-ghc-9.14 + (package + (inherit ghc-nothunks) + (version "0.3.2") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "nothunks" version)) + (sha256 + (base32 "0xxbrhkp14qn1lqrigldqi4q3sspri9jxpmj0ii79854q00w3606"))))))) +(define-public ghc-9.14-nothunks-bootstrap + (package + (inherit ghc-9.14-nothunks) + (name "ghc-9.14-nothunks-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-nothunks))) + (native-inputs '()))) +(define-public ghc-9.14-old-locale (with-ghc-9.14 ghc-old-locale)) +(define-public ghc-9.14-old-time (with-ghc-9.14 ghc-old-time)) +(define-public ghc-9.14-onetuple + (with-ghc-9.14 + (package + (inherit ghc-onetuple) + (version "0.4.2.1") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "OneTuple" version)) + (sha256 + (base32 "0gp06vc9pg80jkslmjxhk3dg826j3szxbj68wspzbj79a4ji6165"))))))) +(define-public ghc-9.14-only (with-ghc-9.14 ghc-only)) +(define-public ghc-9.14-optparse-applicative + (with-ghc-9.14 + (package + (inherit ghc-optparse-applicative) + (version "0.19.0.0") + (arguments `(#:cabal-revision ("1" "1hvcdhc7m9f3qh70cqhrjf0qszyv0dj8fvl2i3fpr3s9ybdwn7ac"))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "optparse-applicative" version)) + (sha256 + (base32 "0waq6i6jk0zj9vb00m62khfcm9xdnz3afzs471vhqwr1v3psw5ng"))))))) +(define-public ghc-9.14-parallel + (with-ghc-9.14 + (package + (inherit ghc-parallel) + (version "3.3.0.0") + (arguments `(#:cabal-revision ("1" "1aligqvx0zvhfvx4jcw1kax0ayg1r4rfwhp47ddqzqw3mp9q4jvs"))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "parallel" version)) + (sha256 + (base32 "148pakbn546a16fhwrl8n7fzywcy307d6bx7g9jvz3lfimvixhj7"))))))) +(define-public ghc-9.14-parsers (with-ghc-9.14 ghc-parsers)) +(define-public ghc-9.14-paths (with-ghc-9.14 ghc-paths)) +(define-public ghc-9.14-pretty-show (with-ghc-9.14 ghc-pretty-show)) +(define-public ghc-9.14-prettyprinter (with-ghc-9.14 ghc-prettyprinter)) +(define-public ghc-9.14-prettyprinter-ansi-terminal (with-ghc-9.14 ghc-prettyprinter-ansi-terminal)) +(define-public ghc-9.14-prettyprinter-compat-ansi-wl-pprint (with-ghc-9.14 ghc-prettyprinter-compat-ansi-wl-pprint)) +(define-public ghc-9.14-primitive + (with-ghc-9.14 + (package + (inherit ghc-primitive) + (version "0.9.1.0") + (arguments (list #:cabal-revision `("1" "1w1rsak97k5sp1sg25kgxcxwbi90mbdrr9hzm1dyzijvf4n24svm") + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "primitive.cabal" + (("QuickCheck [ <>=^*&[0-9.]*") "QuickCheck < 2.17"))))))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "primitive" version)) + (sha256 + (base32 "0xixplp2b5sh2sx6hqllhr8bcsd028v7ry2pibdwayrwh50xxd24"))))))) +(define-public ghc-9.14-primitive-addr (with-ghc-9.14 ghc-primitive-addr)) +(define-public ghc-9.14-primitive-bootstrap + (package + (inherit ghc-9.14-primitive) + (name "ghc-9.14-primitive-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-primitive))) + (native-inputs '()))) +(define-public ghc-9.14-profunctors (with-ghc-9.14 ghc-profunctors)) +(define-public ghc-9.14-quickcheck + (with-ghc-9.14 + (package + (inherit ghc-quickcheck) + (version "2.16.0.0") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "QuickCheck" version)) + (sha256 + (base32 "1h02m26hvhfcs82rrfmfznwh4vj799gn55kysmv3sr8ixak3ymhb"))))))) +(define-public ghc-9.14-quickcheck-classes (with-ghc-9.14 ghc-quickcheck-classes)) +(define-public ghc-9.14-quickcheck-classes-base (with-ghc-9.14 ghc-quickcheck-classes-base)) +(define-public ghc-9.14-quickcheck-instances + (with-ghc-9.14 + (package + (inherit ghc-quickcheck-instances) + (version "0.3.33") + (arguments (list #:cabal-revision `("1" "1xkc7rsfgya4rwiizh0yfincws3knpdnh08m280v1dgik4kv37vh") + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "quickcheck-instances.cabal" + (("base [ <>=^*&[0-9.]*") "base < 4.23") + (("containers [ <>=^*&[0-9.]*") "containers < 0.9"))))))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "quickcheck-instances" version)) + (sha256 + (base32 "0rl8y3rb4fm4nqz122bp5f2aya4f8bc9m9i9n2vwlyq2gdacs0v8"))))))) +(define-public ghc-9.14-quickcheck-io (with-ghc-9.14 ghc-quickcheck-io)) +(define-public ghc-9.14-quickcheck-unicode (with-ghc-9.14 ghc-quickcheck-unicode)) +(define-public ghc-9.14-random (with-ghc-9.14 ghc-random)) +(define-public ghc-9.14-random-bootstrap + (package + (inherit ghc-9.14-random) + (name "ghc-9.14-random-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-random))) + (inputs (list ghc-9.14-splitmix-bootstrap)) + (native-inputs `()))) +(define-public ghc-9.14-raw-strings-qq (with-ghc-9.14 ghc-raw-strings-qq)) +(define-public ghc-9.14-reflection (with-ghc-9.14 ghc-reflection)) +(define-public ghc-9.14-regex-base (with-ghc-9.14 ghc-regex-base)) +(define-public ghc-9.14-regex-pcre-builtin + (with-ghc-9.14 + (package + (inherit ghc-regex-pcre-builtin) + (arguments `(#:cabal-revision ("7" "0gv55qvcsp579f925xb32n27h5nsvlpfgx65y17h0mk8cf2wwm0y")))))) +(define-public ghc-9.14-regex-posix (with-ghc-9.14 ghc-regex-posix)) +(define-public ghc-9.14-regex-tdfa (with-ghc-9.14 ghc-regex-tdfa)) +(define-public ghc-9.14-resourcet (with-ghc-9.14 ghc-resourcet)) +(define-public ghc-9.14-safe (with-ghc-9.14 ghc-safe)) +(define-public ghc-9.14-safe-exceptions (with-ghc-9.14 ghc-safe-exceptions)) +(define-public ghc-9.14-scientific + (with-ghc-9.14 + (package + (inherit ghc-scientific) + (version "0.3.8.1") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "scientific" version)) + (sha256 + (base32 "1znwribsk6rdyv91dbjdbfcfkl6yg2nw7f9fwqv7kz4x2jz82dxd"))))))) +(define-public ghc-9.14-semialign + (with-ghc-9.14 + (package + (inherit ghc-semialign) + (arguments `()) + (version "1.3.1.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "semialign" version)) + (sha256 + (base32 "023sc13r86spp82r1bcch9lmsjnaaqk6x6bjmz1j5515gwpggqcc"))))))) +(define-public ghc-9.14-semigroupoids (with-ghc-9.14 ghc-semigroupoids)) +(define-public ghc-9.14-semigroups (with-ghc-9.14 ghc-semigroups)) +(define-public ghc-9.14-semigroups-bootstrap + (package + (inherit ghc-9.14-semigroups) + (name "ghc-9.14-semigroups-bootstrap") + (inputs + (list ghc-9.14-nats-bootstrap + ghc-9.14-tagged + ghc-9.14-unordered-containers-bootstrap + ghc-9.14-hashable-bootstrap)))) +(define-public ghc-9.14-semirings (with-ghc-9.14 ghc-semirings)) +(define-public ghc-9.14-setenv (with-ghc-9.14 ghc-setenv)) +(define-public ghc-9.14-sha (with-ghc-9.14 ghc-sha)) +(define-public ghc-9.14-silently (with-ghc-9.14 ghc-silently)) +(define-public ghc-9.14-silently-bootstrap + (package + (inherit ghc-9.14-silently) + (name "ghc-9.14-silently-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-silently))) + (native-inputs `()))) +(define-public ghc-9.14-simple-reflect (with-ghc-9.14 ghc-simple-reflect)) +(define-public ghc-9.14-smallcheck (with-ghc-9.14 ghc-smallcheck)) +(define-public ghc-9.14-some + (with-ghc-9.14 + (package + (inherit ghc-some) + (arguments `(#:cabal-revision ("3" "1lrdpbpf3nk8bqcf21crya3hqfjxjj3rmxrgfibr2qdhpkfpzk1r")))))) +(define-public ghc-9.14-some-next + (with-ghc-9.14 + (package + (inherit ghc-some) + (name "ghc-some-next") + (version "1.1") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "some" version)) + (sha256 + (base32 "1fsim7cbnd4yyw2smm1aj3gl5wassfgvcjsa0zyz7dm4kc2sl113"))))))) +(define-public ghc-9.14-split (with-ghc-9.14 ghc-split)) +(define-public ghc-9.14-splitmix + (with-ghc-9.14 + (package + (inherit ghc-splitmix) + (version "0.1.3.2") + (source + (origin + (method url-fetch) + (uri (hackage-uri "splitmix" version)) + (sha256 + (base32 "136yjj3vsqrks5h80dvz43928ydffjv724fkswk6b8gm625lw7d6"))))))) +(define-public ghc-9.14-splitmix-bootstrap + (package + (inherit ghc-9.14-splitmix) + (name "ghc-9.14-splitmix-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-splitmix))) + (native-inputs `()))) +(define-public ghc-9.14-statevar (with-ghc-9.14 ghc-statevar)) +(define-public ghc-9.14-streaming-commons (with-ghc-9.14 ghc-streaming-commons)) +(define-public ghc-9.14-strict (with-ghc-9.14 ghc-strict)) +(define-public ghc-9.14-stringbuilder (with-ghc-9.14 ghc-stringbuilder)) +(define-public ghc-9.14-syb (with-ghc-9.14 ghc-syb)) +(define-public ghc-9.14-tagged + (let ((base ghc-tagged)) + (with-ghc-9.14 + (package + (inherit base) + (version "0.8.10") + (arguments `(#:cabal-revision ("1" "0chxndgcwylzzm0vvf4jxjn6gfvbkszzxi9p5zb82yc2x6c7rfg9"))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "tagged" version)) + (sha256 + (base32 "0pbcyl88qgcyy1shibr459f6jjqz1xx84n5injii9wyanhg7kvqp")))))))) +(define-public ghc-9.14-tasty (with-ghc-9.14 ghc-tasty)) +(define-public ghc-9.14-tasty-expected-failure (with-ghc-9.14 ghc-tasty-expected-failure)) +(define-public ghc-9.14-tasty-golden (with-ghc-9.14 ghc-tasty-golden)) +(define-public ghc-9.14-tasty-hedgehog + (with-ghc-9.14 + (package + (inherit ghc-tasty-hedgehog) + (arguments `(#:cabal-revision ("8" "06iccmqazsdvcwlx2x68xg77m26cyg66r8xqijgqmz2pkx73mrni")))))) +(define-public ghc-9.14-tasty-hspec + (with-ghc-9.14 + (package + (inherit ghc-tasty-hspec) + (version "1.2.0.4") + (arguments (list #:cabal-revision `("8" "1jg5gjmcir11vwj5jp2h077xrb9f7y13zl9asl048nd0wg2qxym8") + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "tasty-hspec.cabal" + (("base [ <>=^*&[0-9.]*") "base < 4.23"))))))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "tasty-hspec" version)) + (sha256 + (base32 "1hk1nkjvhp89xxgzj6dhbgw0fknnghpng6afq4i39hjkwv5p78ni"))))))) +(define-public ghc-9.14-tasty-hunit (with-ghc-9.14 ghc-tasty-hunit)) +(define-public ghc-9.14-tasty-inspection-testing + (with-ghc-9.14 + (package + (inherit ghc-tasty-inspection-testing) + (arguments `(#:cabal-revision ("3" "1gvwk8q20bbjny660qqp43y4ng5m56hk40mpvl8hi94wdw39pr6v")))))) +(define-public ghc-9.14-tasty-quickcheck (with-ghc-9.14 ghc-tasty-quickcheck)) +(define-public ghc-9.14-tasty-smallcheck (with-ghc-9.14 ghc-tasty-smallcheck)) +(define-public ghc-9.14-tasty-th (with-ghc-9.14 ghc-tasty-th)) +(define-public ghc-9.14-temporary (with-ghc-9.14 ghc-temporary)) +(define-public ghc-9.14-temporary-bootstrap + (package + (inherit ghc-9.14-temporary) + (name "ghc-9.14-temporary-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-temporary))) + (inputs (list ghc-9.14-random-bootstrap)) + (native-inputs `()))) +(define-public ghc-9.14-terminal-size (with-ghc-9.14 ghc-terminal-size)) +(define-public ghc-9.14-test-framework + (with-ghc-9.14 + (package + (inherit ghc-test-framework) + (version "0.8.2.3") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "test-framework" version)) + (sha256 + (base32 "0pn5qzhzcjxk4cm1h8ld0arxh4awkw44g96ql679wfhcj1n7h2ii"))))))) +(define-public ghc-9.14-test-framework-hunit (with-ghc-9.14 ghc-test-framework-hunit)) +(define-public ghc-9.14-test-framework-quickcheck2 (with-ghc-9.14 ghc-test-framework-quickcheck2)) +(define-public ghc-9.14-text-iso8601 + (with-ghc-9.14 + (package + (inherit ghc-text-iso8601) + (arguments `()) + (version "0.1.1.2") + (source + (origin + (method url-fetch) + (uri (hackage-uri "text-iso8601" version)) + (sha256 + (base32 "163kixpp0g2vjbs223cqk5ahsza6ibiqbgr5g96dabqaqyp17fyx"))))))) +(define-public ghc-9.14-text-short + (with-ghc-9.14 + (package + (inherit ghc-text-short) + (version "0.1.6.1") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "text-short" version)) + (sha256 + (base32 "05klm26sx1kd1hngflg4anwnfckkmx1n84kmvjy4y9sl4d09yrl3"))))))) +(define-public ghc-9.14-tf-random (with-ghc-9.14 ghc-tf-random)) +(define-public ghc-9.14-th-abstraction + (with-ghc-9.14 + (package + (inherit ghc-th-abstraction) + (version "0.7.2.0") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "th-abstraction" version)) + (sha256 + (base32 "08knffg6ffx5rz9r437jvndbx668m1hih1jq01yzybgav2y58rll"))))))) +(define-public ghc-9.14-th-compat + (with-ghc-9.14 + (package + (inherit ghc-th-compat) + (version "0.1.7") + (source + (origin + (method url-fetch) + (uri (hackage-uri "th-compat" version)) + (sha256 + (base32 "1zym9yia0is8wxfd6d1ldwvvghwxg4ww3y4lrxnyb2nk60ig29ly"))))))) +(define-public ghc-9.14-th-expand-syns + (with-ghc-9.14 + (package + (inherit ghc-th-expand-syns) + (arguments `(#:cabal-revision ("1" "09mhaz7ylkh35c7zaix1gfx3z4bqvvibsmb4nd8x42mf87xja5fp")))))) +(define-public ghc-9.14-th-lift + (with-ghc-9.14 + (package + (inherit ghc-th-lift) + (version "0.8.7") + (source + (origin + (method url-fetch) + (uri (hackage-uri "th-lift" version)) + (sha256 + (base32 "01lqqsnhy8cbca3y7z436m8czz7ab8q90dmcmmqzmc5hdii7q5fx"))))))) +(define-public ghc-9.14-th-orphans + (with-ghc-9.14 + (package + (inherit ghc-th-orphans) + (version "0.13.17") + (source + (origin + (method url-fetch) + (uri (hackage-uri "th-orphans" version)) + (sha256 + (base32 "0qlhbsm5d083m50vzn93c72c91y0fczlbpnp3rv7y7lz9i4gnrww"))))))) +(define-public ghc-9.14-th-reify-many (with-ghc-9.14 ghc-th-reify-many)) +(define-public ghc-9.14-these + (with-ghc-9.14 + (package + (inherit ghc-these) + (arguments `(#:cabal-revision ("3" "0h16r51m20y7vpij90vykddlwg4a8qhg8m7j1vwv7cifa2dfq6ms")))))) +(define-public ghc-9.14-time-compat + (with-ghc-9.14 + (package + (inherit ghc-time-compat) + (version "1.9.9") + (arguments `(#:cabal-revision ("1" "1q1javzrcyphpm9kn846vi0a00mi04lvc1via6r0ivl77h61wa8c"))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "time-compat" version)) + (sha256 + (base32 "09bwvzxd41mmr3vq4az301fziy3aaglhky7bbs2ib76gagnxvylh"))))))) +(define-public ghc-9.14-typed-process (with-ghc-9.14 ghc-typed-process)) +(define-public ghc-9.14-transformers-base (with-ghc-9.14 ghc-transformers-base)) +(define-public ghc-9.14-transformers-compat (with-ghc-9.14 ghc-transformers-compat)) +(define-public ghc-9.14-unbounded-delays (with-ghc-9.14 ghc-unbounded-delays)) +(define-public ghc-9.14-unliftio (with-ghc-9.14 ghc-unliftio)) +(define-public ghc-9.14-unliftio-core (with-ghc-9.14 ghc-unliftio-core)) +(define-public ghc-9.14-unordered-containers + (with-ghc-9.14 + (package + (inherit ghc-unordered-containers) + (version "0.2.21") + (arguments `(#:cabal-revision ("2" "01anv9bqh3jw56cs9w5yyv93fp6c38fpf6l5rpscblvy6yrizpn5"))) + (source + (origin + (method url-fetch) + (uri (hackage-uri "unordered-containers" version)) + (sha256 + (base32 "1h7rnxdnm2adrgalga1xx32yx7i3blg7s9ak06b62vjl5d9d2aiv"))))))) +(define-public ghc-9.14-unordered-containers-bootstrap + (package + (inherit ghc-9.14-unordered-containers) + (name "ghc-9.14-unordered-containers-bootstrap") + (arguments `(#:tests? #f ,@(package-arguments ghc-9.14-unordered-containers))) + (inputs `(("ghc-9.14-hashable" ,ghc-9.14-hashable-bootstrap))) + (native-inputs `()))) +(define-public ghc-9.14-utf8-string (with-ghc-9.14 ghc-utf8-string)) +(define-public ghc-9.14-uuid-types + (with-ghc-9.14 + (package + (inherit ghc-uuid-types) + (version "1.0.6.1") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "uuid-types" version)) + (sha256 + (base32 "091h1ifc1srv803rrkw794xiiha51nglsh61mjv084bip5wg404z"))))))) +(define-public ghc-9.14-vector + (with-ghc-9.14 + (package + (inherit ghc-vector) + (arguments `(#:tests? #f ,@(package-arguments ghc-vector)))))) ;; https://github.com/nomeata/inspection-testing/issues/95 breaks `vector` test suite, make a patch? +(define-public ghc-9.14-vector-algorithms + (with-ghc-9.14 + (package + (inherit ghc-vector-algorithms) + (arguments `(#:cabal-revision ("1" "0bakvl54qag5m13ilrqxcv3wdrnb57c76vjmlh3a5v1sk3zgxv5k")))))) +(define-public ghc-9.14-vector-stream (with-ghc-9.14 ghc-vector-stream)) +(define-public ghc-9.14-void (with-ghc-9.14 ghc-void)) +(define-public ghc-9.14-wherefrom-compat + (with-ghc-9.14 + (package + (inherit ghc-wherefrom-compat) + (arguments `(#:cabal-revision ("4" "1yagqxw475jkim3cpqwcaibs8k9cgw2q1xc4qk65kwrhf83qnb09")))))) +(define-public ghc-9.14-witherable + (with-ghc-9.14 + (package + (inherit ghc-witherable) + (arguments `(#:cabal-revision ("2" "0xb29mh29piqm0i21fz0mm24x06f5sy7yb1jih4pyaaxvwqh8q55")))))) +(define-public ghc-9.14-wl-pprint-annotated (with-ghc-9.14 ghc-wl-pprint-annotated)) +(define-public ghc-9.14-xml (with-ghc-9.14 ghc-xml)) +(define-public ghc-9.14-xml-conduit + (let ((base (with-ghc-9.14 ghc-xml-conduit))) + (package + (inherit base) + (inputs `(("ghc-9.14-cabal-doctest" ,ghc-9.14-cabal-doctest) ,@(package-inputs base)))))) ;; scuffed, no clue how gexps work :/ +(define-public ghc-9.14-xml-types (with-ghc-9.14 ghc-xml-types)) +(define-public ghc-9.14-yaml (with-ghc-9.14 ghc-yaml)) +(define-public ghc-9.14-zlib + (with-ghc-9.14 + (package + (inherit ghc-zlib) + (version "0.7.1.1") + (arguments `()) + (source + (origin + (method url-fetch) + (uri (hackage-uri "zlib" version)) + (sha256 + (base32 "1hf1csbc5gb6yipqydkqydlyr5yalpxrb8fyml0fhjwjxl0sp5dz"))))))) + +(define-public ghc-9.14-atomic-file-ops + (package + (name "ghc-9.14-atomic-file-ops") + (version "0.3.0.0") + (source + (origin + (method url-fetch) + (uri (hackage-uri "atomic-file-ops" version)) + (sha256 + (base32 "15gg5g9wnypj3hk5lhrqln2xcf86g84ivm8c8aflhmal26x86x44")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14)) + (properties `((upstream-name . "atomic-file-ops"))) + (inputs (list ghc-9.14-filelock + ghc-9.14-io-string-like)) + (home-page "https://github.com/clintonmead/atomic-file-ops") + (synopsis "Functions to atomically write to files.") + (description synopsis) + (license license:bsd-3))) + +(define-public ghc-9.14-c-expr-dsl + (package + (name "ghc-9.14-c-expr-dsl") + (version "0.1.0.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/well-typed/c-expr") + (commit "release-0.1.0.1"))) + (sha256 + (base32 "021fq59dbd1vdspgnqz9qirn03sjbxfvd75ipws65ry0qdfymhnb")))) + (build-system haskell-build-system) + (properties `((upstream-name . "c-expr-dsl"))) + (inputs (list ghc-9.14-c-expr-runtime + ghc-9.14-debruijn + ghc-9.14-fin + ghc-9.14-indexed-traversable + ghc-9.14-libclang-bindings + ghc-9.14-scientific + ghc-9.14-some + ghc-9.14-vec)) + (native-inputs (list clang + ghc-9.14-tasty + ghc-9.14-tasty-golden + ghc-9.14-tasty-hunit)) + (arguments (list #:haskell ghc-9.14 + #:phases #~(modify-phases %standard-phases (add-after `unpack `chdir (lambda _ (chdir "c-expr-dsl")))))) + (home-page "https://github.com/well-typed/c-expr") + (synopsis "DSL for the language support by c-expr-runtime.") + (description "This library provides the front end for the c-expr DSL: a Parsec-based parser that turns libclang macro tokens into a syntax tree, and a typechecker that assigns types to macro expressions according to the rules implemented in c-expr-runtime.") + (license license:bsd-3))) + +(define-public ghc-9.14-c-expr-runtime + (package + (name "ghc-9.14-c-expr-runtime") + (version "0.1.0.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/well-typed/c-expr") + (commit "release-0.1.0.1"))) + (sha256 + (base32 "021fq59dbd1vdspgnqz9qirn03sjbxfvd75ipws65ry0qdfymhnb")))) + (build-system haskell-build-system) + (properties `((upstream-name . "c-expr-runtime"))) + (inputs (list ghc-9.14-data-default + ghc-9.14-fin + ghc-9.14-libclang-bindings + ghc-9.14-some + ghc-9.14-vec)) + (native-inputs (list clang)) + (arguments (list #:haskell ghc-9.14 + #:phases #~(modify-phases %standard-phases (add-after `unpack `chdir (lambda _ (chdir "c-expr-runtime")))))) + (home-page "https://github.com/well-typed/c-expr") + (synopsis "Haskell DSL for simple C arithmetic expressions.") + (description "This library provides a Haskell DSL for simple C arithmetic expressions, implementing the arithmetic conversion and integral promotion rules of the C standard.") + (license license:bsd-3))) + +(define-public ghc-9.14-cabal-doctest + (package + (name "ghc-9.14-cabal-doctest") + (version "1.0.12") + (source + (origin + (method url-fetch) + (uri (hackage-uri "cabal-doctest" version)) + (sha256 + (base32 "0b4vlfdcazlyaklcqv2w94bh6xipjpfdffzp6w36bzj5639g049i")))) + (build-system haskell-build-system) + (properties `((upstream-name . "cabal-doctest"))) + (arguments (list #:haskell ghc-9.14 + #:cabal-revision `("1" "0nlk23g4y7ypsrynsmmr5h6j38nskm5y7pc32drnwil6ml9dzlq7"))) + (home-page "https://github.com/ulidtko/cabal-doctest") + (synopsis "A Setup.hs helper for running doctests.") + (description "As of now (end of 2024), there isn't cabal doctest command. Yet, to properly work, doctest needs plenty of configuration. This library provides the common bits for writing a custom Setup.hs.") + (license license:bsd-3))) + +(define-public ghc-9.14-contra-tracer + (package + (name "ghc-9.14-contra-tracer") + (version "0.2.1.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "contra-tracer" version)) + (sha256 + (base32 "09710jgfjwljsdppcq0hnl6lxa3cqb0ivklqihzkd3kgr8xbggy2")))) + (build-system haskell-build-system) + (properties `((upstream-name . "contra-tracer"))) + (arguments (list #:haskell ghc-9.14)) + (home-page "https://github.com/avieth/contra-tracer") + (synopsis "Arrow and contravariant tracers.") + (description "A simple interface for logging, tracing and monitoring.") + (license license:asl2.0))) + +(define-public ghc-9.14-debruijn + (package + (name "ghc-9.14-debruijn") + (version "0.3.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "debruijn" version)) + (sha256 + (base32 "07hirkxdk28f6ri0dbyw34q2jqa9w7256yib8vjn24v644l9jsdg")))) + (build-system haskell-build-system) + (properties `((upstream-name . "debruijn"))) + (inputs (list ghc-9.14-fin + ghc-9.14-skew-list + ghc-9.14-some)) + (native-inputs (list ghc-9.14-quickcheck + ghc-9.14-tasty + ghc-9.14-tasty-quickcheck)) + (arguments (list #:haskell ghc-9.14 + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "debruijn.cabal" + (("base [ <>=^*&[0-9.]*") "base < 4.23") + (("QuickCheck [ <>=^*&[0-9.]*") "QuickCheck < 2.17"))))))) + (home-page "https://github.com/phadej/debruijn") + (synopsis "de Bruijn indices and levels.") + (description "de Bruijn indices and levels for well-scoped terms. This is \"unsafe\" (as it uses unsafeCoerce) implementation, but it's fast. The API is the same as in debruin-safe package.") + (license license:bsd-3))) + +(define-public ghc-9.14-doxygen-parser + (package + (name "ghc-9.14-doxygen-parser") + (version "0.1.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "doxygen-parser" version)) + (sha256 + (base32 "0g43gb8mg7xxs5sqqys6m5116gkxvfz8qyyzk2i2fm357n7gj0zd")))) + (build-system haskell-build-system) + (properties `((upstream-name . "doxygen-parser"))) + (inputs (list ghc-9.14-temporary + ghc-9.14-xml-conduit)) + (native-inputs (list doxygen + ghc-9.14-quickcheck + ghc-9.14-tasty + ghc-9.14-tasty-hunit + ghc-9.14-tasty-quickcheck)) + (arguments (list #:haskell ghc-9.14 + ;; #:tests? #f + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "doxygen-parser.cabal" + (("QuickCheck [ <>=^*&[0-9.]*") "QuickCheck < 2.17"))))))) + (home-page "https://github.com/well-typed/doxygen-parser") + (synopsis "Parse Doxygen XML output into a typed Haskell AST.") + (description "A standalone library for invoking the doxygen binary on C/C++ headers and turning its XML output into a typed Haskell AST. The library spawns doxygen on a set of header files, walks the resulting xml/ directory, and assembles a Doxygen.Parser.Doxygen value mapping each documented C entity to a structured Doxygen.Parser.Comment tree (with paragraphs, inline markup, parameter docs, group memberships, and cross-references).") + (license license:bsd-3))) + +(define-public ghc-9.14-deepseq + (package + (name "ghc-9.14-deepseq") + (version "1.5.2.0") + (source + (origin + (method url-fetch) + (uri (hackage-uri "deepseq" version)) + (sha256 + (base32 "1rgv1kn3igdip34bpn24syirmsjllipd98l301y5n225gw6q1mq9")))) + (build-system haskell-build-system) + (properties `((upstream-name . "deepseq"))) + (inputs (list)) + (native-inputs (list)) + (arguments (list #:haskell ghc-9.14)) + (home-page "https://github.com/haskell/deepseq") + (synopsis "Deep evaluation of data structures.") + (description "This package provides methods for fully evaluating data structures (\"deep evaluation\"). Deep evaluation is often used for adding strictness to a program, e.g. in order to force pending exceptions, remove space leaks, or force lazy I/O to happen. It is also useful in parallel programs, to ensure pending work does not migrate to the wrong thread.") + (license license:bsd-3))) + +(define-public ghc-9.14-fin + (package + (name "ghc-9.14-fin") + (version "0.3.2") + (source + (origin + (method url-fetch) + (uri (hackage-uri "fin" version)) + (sha256 + (base32 "0h912rcy2krba01yd1xq6wyj2mnq7bqr7ap6rcdfw0sgkxa5j9dr")))) + (build-system haskell-build-system) + (properties `((upstream-name . "fin"))) + (inputs (list ghc-9.14-boring + ghc-9.14-dec + ghc-9.14-hashable + ghc-9.14-some + ghc-9.14-tagged + ghc-9.14-universe-base + ghc-9.14-quickcheck)) ;; unused + (arguments (list #:haskell ghc-9.14 + #:cabal-revision `("2" "0k2s971fvwb1hm3zr1i4b3sjx2phn6ik2mlixfsrnhfapghr8zg3") + #:tests? #f ;; TODO tests fail + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "fin.cabal" + (("QuickCheck [ <>=^*&[0-9.]*") "QuickCheck < 2.17"))))))) + (home-page "https://github.com/phadej/vec") + (synopsis "Nat and Fin: peano naturals and finite numbers") + (description "This package provides two simple types, and some tools to work with them. Also on type level as DataKinds.") + (license license:bsd-3))) + +(define-public ghc-9.14-fir + (package + (name "ghc-9.14-fir") + (version "0.1.0.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.com/sheaf/fir") + (commit "c0d4981a6aae1500bb9df7fb63481b68f0b7abef"))) + (sha256 + (base32 "1q2zaqy1aq93zavv5wyzk4l4ya7fmf664851n7v6grd5w0vk58bl")))) + (build-system haskell-build-system) + (arguments (list #:tests? #f ;; TODO figure out this testing situation + #:haskell ghc-9.14)) + (properties '((upstream-name . "fir"))) + (inputs (list ghc-9.14-atomic-file-ops + ghc-9.14-distributive + ghc-9.14-finite-typelits + ghc-9.14-generic-monoid + ghc-9.14-ghc-typelits-knownnat + ghc-9.14-half + ghc-9.14-lens + ghc-9.14-split + ghc-9.14-text-short + ghc-9.14-tree-view + ghc-9.14-typelits-witnesses + ghc-9.14-variant + ghc-9.14-vector + ghc-9.14-vector-sized)) + (home-page "https://gitlab.com/sheaf/fir") + (synopsis "An EDSL that compiles to SPIR-V for graphics programming on the GPU in Haskell.") + (description "With this library, shader programs can be written using do notation. Such programs are then transformed into abstract syntax trees (ASTs), before being compiled to SPIR-V assembly. In effect, this replaces GLSL as a shader language. This means the Haskell type-system and type-checker are put to use in verifying programs at compile-time. Functional idioms, such as functor and applicative operations, are also supported.") + (license license:bsd-3))) + +(define-public ghc-9.14-generic-monoid + (package + (name "ghc-9.14-generic-monoid") + (version "0.1.0.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "generic-monoid" version)) + (sha256 + (base32 "1pradfv1i2z73f3vxx78ahmfsdszcgi44kn29aww2hdgf2np5l6g")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14 + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "generic-monoid.cabal" + (("base [ <>=^*&[0-9.]*") "base < 4.23"))))))) + (properties '((upstream-name . "generic-monoid"))) + (inputs (list ghc-9.14-filelock + ghc-9.14-io-string-like)) + (home-page "") + (synopsis "Derive monoid instances for product types.") + (description "Using GHC's generics, allow for deriving Monoid and Semigroup instances for your product types.") + (license license:bsd-3))) + +(define-public ghc-9.14-ghc-tcplugin-api + (package + (name "ghc-9.14-ghc-tcplugin-api") + (version "0.19.0.0") + (source + (origin + (method url-fetch) + (uri (hackage-uri "ghc-tcplugin-api" version)) + (sha256 + (base32 "141fg624zywwq1advajvnpigvy2kypbs3vnd9l5pqqr4bdx6m3kf")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14)) + (properties '((upstream-name . "ghc-tcplugin-api"))) + (home-page "https://github.com/sheaf/ghc-tcplugin-api") + (synopsis "An API for type-checker plugins.") + (description "This library provides a streamlined monadic interface for writing GHC type-checking plugins. Each stage in a type-checking plugin (initialisation, solving, rewriting, post-tc) has a corresponding monad, preventing operations that are only allowed in some stages to be used in the other stages. Operations that work across multiple stages are overloaded across monads using MTL-like typeclasses. Some operations, like creating evidence for constraints or creating custom type error messages, are also simplified.") + (license license:bsd-3))) + +(define-public ghc-9.14-ghc-typelits-knownnat + (package + (name "ghc-9.14-ghc-typelits-knownnat") + (version "0.8.4") + (source + (origin + (method url-fetch) + (uri (hackage-uri "ghc-typelits-knownnat" version)) + (sha256 + (base32 "1b93j3iabk0a3vpxc5g7pfff1d4vfb7lyqplm7zpgx571j95nv0i")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14)) + (properties '((upstream-name . "ghc-typelits-knownnat"))) + (inputs (list ghc-9.14-ghc-tcplugin-api + ghc-9.14-ghc-typelits-natnormalise)) + (native-inputs (list ghc-9.14-quickcheck + ghc-9.14-tasty + ghc-9.14-tasty-hunit + ghc-9.14-tasty-quickcheck)) + (home-page "https://clash-lang.org/") + (synopsis "Derive KnownNat constraints from other KnownNat constraints.") + (description "A type checker plugin for GHC that can derive complex KnownNat constraints from other simple/variable KnownNat constraints.") + (license license:bsd-2))) + +(define-public ghc-9.14-ghc-typelits-natnormalise + (package + (name "ghc-9.14-ghc-typelits-natnormalise") + (version "0.9.6") + (source + (origin + (method url-fetch) + (uri (hackage-uri "ghc-typelits-natnormalise" version)) + (sha256 + (base32 "1ly514p0332jj7b1zk4yq19xg10wrwv1l42rlyg9akki4bfb0sv2")))) + (build-system haskell-build-system) + (properties '((upstream-name . "ghc-typelits-natnormalise"))) + (inputs (list ghc-9.14-ghc-tcplugin-api + ghc-9.14-interpolate + ghc-9.14-temporary)) + (native-inputs (list ghc-9.14-tasty + ghc-9.14-tasty-hunit)) + (arguments (list #:haskell ghc-9.14 + #:tests? #f)) ;; tests are recursive?? It needs itself in ghc to test + (home-page "https://clash-lang.org/") + (synopsis "GHC typechecker plugin for types of kind GHC.TypeLits.Nat.") + (description "A type checker plugin for GHC that can solve equalities and inequalities of types of kind Nat, where these types are either Type-level naturals, Type variables, or Applications of the arithmetic expressions (+,-,*,^). It solves these equalities by normalising them to sort-of SOP (Sum-of-Products) form, and then perform a simple syntactic equality.") + (license license:bsd-2))) + +(define-public ghc-9.14-hs-bindgen + (package + (name "ghc-9.14-hs-bindgen") + (version "release-0.1-alpha2-0534f86") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/well-typed/hs-bindgen") + (commit "0534f86c26c39163fb3508467d03fba60bc72d5d"))) + (sha256 + (base32 "1lapm3sk9d6pgr0832n4mha2x2wrldq4f9355fshzsfa3phanrmq")))) + (build-system haskell-build-system) + (properties `((upstream-name . "hs-bindgen"))) + (inputs (list ghc-9.14-aeson + ghc-9.14-ansi-terminal + ghc-9.14-async + ghc-9.14-base-compat + ghc-9.14-base16-bytestring + ghc-9.14-c-expr-dsl + ghc-9.14-c-expr-runtime + ghc-9.14-contra-tracer + ghc-9.14-cryptohash-sha256 + ghc-9.14-data-default + ghc-9.14-debruijn + ghc-9.14-diff + ghc-9.14-doxygen-parser + ghc-9.14-edit-distance + ghc-9.14-fin + ghc-9.14-hs-bindgen-runtime + ghc-9.14-language-c + ghc-9.14-libclang-bindings + ghc-9.14-optics + ghc-9.14-optics-core + ghc-9.14-optparse-applicative + ghc-9.14-prettyprinter + ghc-9.14-primitive + ghc-9.14-regex-pcre-builtin + ghc-9.14-some + ghc-9.14-syb + ghc-9.14-temporary + ghc-9.14-unliftio-core + ghc-9.14-utf8-string + ghc-9.14-vec + ghc-9.14-vector + ghc-9.14-yaml)) + (native-inputs (list clang-toolchain + doxygen + ghc-9.14-tasty + ghc-9.14-tasty-hunit + ghc-9.14-tasty-quickcheck + llvm)) + (arguments (list #:haskell ghc-9.14 + #:phases #~(modify-phases %standard-phases (add-after `unpack `chdir (lambda _ (chdir "hs-bindgen")))))) + (home-page "https://github.com/well-typed/hs-bindgen") + (synopsis "Generate Haskell bindings from C headers") + (description "Automatically generate Haskell bindings from C headers.") + (license license:bsd-3))) + +(define-public ghc-9.14-hs-bindgen-runtime + (package + (name "ghc-9.14-hs-bindgen-runtime") + (version "release-0.1-alpha2-0534f86") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/well-typed/hs-bindgen") + (commit "0534f86c26c39163fb3508467d03fba60bc72d5d"))) + (sha256 + (base32 "1lapm3sk9d6pgr0832n4mha2x2wrldq4f9355fshzsfa3phanrmq")))) + (build-system haskell-build-system) + (properties `((upstream-name . "hs-bindgen-runtime"))) + (inputs (list ghc-9.14-primitive + ghc-9.14-record-hasfield + ghc-9.14-vector)) + (native-inputs (list ghc-9.14-quickcheck + ghc-9.14-tasty + ghc-9.14-tasty-expected-failure + ghc-9.14-tasty-hunit + ghc-9.14-tasty-quickcheck)) + (arguments (list #:haskell ghc-9.14 + #:phases #~(modify-phases %standard-phases (add-after `unpack `chdir (lambda _ (chdir "hs-bindgen-runtime")))))) + (home-page "https://github.com/well-typed/hs-bindgen") + (synopsis "Library for testing bindings generated by hs-bindgen.") + (description synopsis) + (license license:bsd-3))) + +(define-public ghc-9.14-indexed-list-literals + (package + (name "ghc-9.14-indexed-list-literals") + (version "0.2.1.3") + (source + (origin + (method url-fetch) + (uri (hackage-uri "indexed-list-literals" version)) + (sha256 + (base32 "179z0df99ixaplr1qv7dawj3h8fq5qhgfn8mg0i4ix6xhpi9kqr6")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14)) + (properties '((upstream-name . "indexed-list-literals"))) + (inputs (list ghc-9.14-hspec + ghc-9.14-only)) + (home-page "https://github.com/davidm-d/indexed-list-literals") + (synopsis "Type safe indexed list literals.") + (description "This is an incredibly simple library, which makes writing lists where the length is known at compile time a little bit nicer.") + (license license:bsd-3))) + +(define-public ghc-9.14-io-string-like + (package + (name "ghc-9.14-io-string-like") + (version "0.1.0.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "io-string-like" version)) + (sha256 + (base32 "0p8p4xp9qj7h1xa9dyizqpr85j8qjiccj3y9kplbskaqazl9pyqp")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14)) + (properties '((upstream-name . "io-string-like"))) + (inputs (list ghc-9.14-filelock)) + (home-page "https://github.com/clintonmead/io-string-like") + (synopsis "Classes to handle Prelude style IO functions for different datatypes.") + (description "The functions in the Prelude such as getContents, putStr only work for plain Strings. There are similar functions in ByteString for reading and writing, as well as Text. This requires one to import the appropriate functions, usually qualified, for the particular datatype one is using. Changing the datatype at the very least involves changing import statements across your program. The package introduces classes to overload functions like getContents, putStr over multiple datatypes, so implementations can be changed easily.") + (license license:bsd-3))) + +(define-public ghc-9.14-libclang-bindings + (package + (name "ghc-9.14-libclang-bindings") + (version "0.1.0.0-c1340dd") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/well-typed/libclang-bindings") + (commit "c1340ddbd9b26cd59f143f7625beb48187a863bf"))) + (sha256 + (base32 "10xxy0qixhmzincsl172h65fal3zlyvnl9035ip45l1j4prhpvqy")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14 + #:phases #~(modify-phases %standard-phases (add-after `unpack `chdir (lambda _ (chdir "libclang-bindings")))))) + (properties `((upstream-name . "libclang-bindings"))) + (inputs `()) + (native-inputs (list clang + ghc-9.14-quickcheck + ghc-9.14-data-default + ghc-9.14-tasty + ghc-9.14-tasty-hunit + ghc-9.14-tasty-quickcheck + ghc-9.14-unliftio-core + llvm)) + (home-page "https://github.com/well-typed/libclang-bindings") + (synopsis "libclang bindings.") + (description "Haskell bindings to the LLVM/Clang libclang C API, providing low-level FFI bindings and a higher-level API for parsing and traversing C code.") + (license license:bsd-3))) + +(define-public ghc-9.14-optics + (package + (name "ghc-9.14-optics") + (version "0.4.2.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "optics" version)) + (sha256 + (base32 "0sszgi7xw8k57y6w16w80rp7zbcmx0h44bxb46n4yibmp9mdhlz6")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14 + #:cabal-revision `("3" "0a7di79v746gf9l5nkm6i1aamjb4z7bqcjr2xikf8ylsq3yz0454") + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "optics.cabal" + (("inspection-testing [ <>=^*&[0-9.]*") "inspection-testing < 0.7"))))) + #:tests? #f)) ;; TODO fix testing, inspection-testing breaks it + (properties `((upstream-name . "optics"))) + (inputs (list ghc-9.14-indexed-profunctors + ghc-9.14-optics-core + ghc-9.14-optics-extra + ghc-9.14-optics-th + ghc-9.14-random)) + (native-inputs (list ghc-9.14-inspection-testing + ghc-9.14-quickcheck + ghc-9.14-tasty + ghc-9.14-tasty-hunit + ghc-9.14-tasty-quickcheck)) + (home-page "https://github.com/well-typed/optics") + (synopsis "Optics as an abstract interface.") + (description "This package makes it possible to define and use Lenses, Traversals, Prisms and other optics, using an abstract interface. See the main module Optics for the documentation. This is the \"batteries-included\" variant with many dependencies; see the optics-core package and other optics-* dependencies if you need a more limited dependency footprint.") + (license license:bsd-3))) + +(define-public ghc-9.14-optics-core + (package + (name "ghc-9.14-optics-core") + (version "0.4.2") + (source + (origin + (method url-fetch) + (uri (hackage-uri "optics-core" version)) + (sha256 + (base32 "1rywdmndpd3v6adiy3p6v07rrzfvlnxl19nkm59kkcnnia9c938v")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14)) + (properties `((upstream-name . "optics-core"))) + (inputs (list ghc-9.14-indexed-profunctors + ghc-9.14-indexed-traversable)) + (home-page "https://github.com/well-typed/optics") + (synopsis "Optics as an abstract interface: core definitions.") + (description "This package makes it possible to define and use Lenses, Traversals, Prisms and other optics, using an abstract interface. This variant provides core definitions with a minimal dependency footprint. See the optics package (and its dependencies) for documentation and the \"batteries-included\" variant.") + (license license:bsd-3))) + +(define-public ghc-9.14-optics-extra + (package + (name "ghc-9.14-optics-extra") + (version "0.4.2.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "optics-extra" version)) + (sha256 + (base32 "0hfa5yb7l3l310lfxkii13fjzb69g619agadc5a86i734nisf8vy")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14 + #:cabal-revision `("5" "1jnszx2lspvwr121mdxka4kjxh99q03hzf2cvfzw19qpvrgj2g68"))) + (properties `((upstream-name . "optics-extra"))) + (inputs (list ghc-9.14-hashable + ghc-9.14-indexed-profunctors + ghc-9.14-indexed-traversable-instances + ghc-9.14-optics-core + ghc-9.14-unordered-containers + ghc-9.14-vector)) + (home-page "https://github.com/well-typed/optics") + (synopsis "Extra utilities and instances for optics-core.") + (description "This package provides extra definitions and instances that extend the optics-core package, without incurring too many dependencies. See the optics package for more documentation.") + (license license:bsd-3))) + +(define-public ghc-9.14-optics-th + (package + (name "ghc-9.14-optics-th") + (version "0.4.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "optics-th" version)) + (sha256 + (base32 "05zxljfqmhr5if7l8gld5s864nql6kqjfizsf1z7r3ydknvmff6p")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14 + #:cabal-revision `("11" "04wpbb9fcrn34z0pha365b7snywrmb03zy1axj3rzyv0bvwm4xwa"))) + (properties `((upstream-name . "optics-th"))) + (inputs (list ghc-9.14-optics-core + ghc-9.14-tagged + ghc-9.14-th-abstraction)) + (home-page "https://github.com/well-typed/optics") + (synopsis "Optics construction using TemplateHaskell.") + (description "This package is part of the optics package family. It provides machinery to construct optics using TemplateHaskell. See the template-haskell-optics package for optics to work with template-haskell types.") + (license license:bsd-3))) + +(define-public ghc-9.14-record-hasfield + (package + (name "ghc-9.14-record-hasfield") + (version "1.0.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "record-hasfield" version)) + (sha256 + (base32 "17pd8s2r9wnrwmi37b0z9a7006zsx5m6ki24b1pcf6jnqc0bqghs")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14)) + (properties `((upstream-name . "record-hasfield"))) + (home-page "https://github.com/ndmitchell/record-hasfield") + (synopsis "A version of GHC.Records as available in future GHCs.") + (description "This package provides a version of GHC.Records as it will be after the implementation of GHC proposal #42, plus some helper functions over it.") + (license license:bsd-3))) + +(define-public ghc-9.14-recursion-schemes + (package + (name "ghc-9.14-recursion-schemes") + (version "5.2.3") + (source + (origin + (method url-fetch) + (uri (hackage-uri "recursion-schemes" version)) + (sha256 + (base32 "020fk7s4dzim3957h8447mi3jp95k25zrac86dcaavldxjy88kiv")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14 + #:cabal-revision `("2" "0ppyrsm3vnn1lkfan11583rqn26vgzaihbsqa80s969fdf97zb6m"))) + (properties '((upstream-name . "recursion-schemes"))) + (inputs (list ghc-9.14-comonad + ghc-9.14-data-fix + ghc-9.14-free + ghc-9.14-hunit)) + (home-page "https://github.com/recursion-schemes/recursion-schemes") + (synopsis "Representing common recursion patterns as higher-order functions.") + (description "Many recursive functions share the same structure, e.g. pattern-match on the input and, depending on the data constructor, either recur on a smaller input or terminate the recursion with the base case. Another one: start with a seed value, use it to produce the first element of an infinite list, and recur on a modified seed in order to produce the rest of the list. Such a structure is called a recursion scheme. Using higher-order functions to implement those recursion schemes makes your code clearer, faster, and safer.") + (license license:bsd-2))) + +(define-public ghc-9.14-skew-list + (package + (name "ghc-9.14-skew-list") + (version "0.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "skew-list" version)) + (sha256 + (base32 "1j0rc1s3mpf933wl4fifik62d68hx1py8g8wwxz69ynfhjhf9fa2")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14 + #:cabal-revision `("4" "0l72s72kzqgxg07rxm6m75f2jxkhwl0mldj8raqs4hhy0dxhry4z") + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "skew-list.cabal" + (("base [ <>=^*&[0-9.]*") "base < 4.23") + (("QuickCheck [ <>=^*&[0-9.]*") "QuickCheck < 2.17"))))))) + (properties `((upstream-name . "skew-list"))) + (inputs (list ghc-9.14-hashable + ghc-9.14-indexed-traversable + ghc-9.14-strict)) + (native-inputs (list ghc-9.14-quickcheck + ghc-9.14-tasty + ghc-9.14-tasty-hunit + ghc-9.14-tasty-quickcheck)) + (home-page "https://github.com/phadej/skew-list") + (synopsis "Random access lists: skew binary.") + (description "This package provides ordinary random access list, SkewList implemented using skew binary approach. It's worth comparing to ordinary lists, binary random access list (as in ral package) and vectors (vector package) across two operations: indexing and consing.") + (license license:bsd-3))) + +;; USES HELLA AI +(define-public ghc-9.14-tasty-discover + (package + (name "ghc-9.14-tasty-discover") + (version "5.2.0") + (source + (origin + (method url-fetch) + (uri (hackage-uri "tasty-discover" version)) + (sha256 + (base32 "1wnblzl6c094qacspldyfad6mcl3iy0xnqmbzail0gzz8517wix3")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14 + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "tasty-discover.cabal" + (("build-depends: tasty-quickcheck [ <>=^*&[0-9.]*") "build-depends: tasty-quickcheck < 0.12"))))))) + (properties '((upstream-name . "tasty-discover"))) + (inputs (list ghc-9.14-ansi-terminal + ghc-9.14-glob + ghc-9.14-hedgehog + ghc-9.14-hspec + ghc-9.14-hspec-core + ghc-9.14-tasty + ghc-9.14-tasty-expected-failure + ghc-9.14-tasty-golden + ghc-9.14-tasty-hedgehog + ghc-9.14-tasty-hspec + ghc-9.14-tasty-hunit + ghc-9.14-tasty-quickcheck + ghc-9.14-tasty-smallcheck + ghc-9.14-temporary)) + (home-page "https://github.com/haskell-works/tasty-discover") + (synopsis "Test discovery for the tasty framework.") + (description "Prefix your test case names and tasty-discover will discover, collect and run them. All popular test libraries are covered. Configure once and then just write your tests. Avoid forgetting to add test modules to your Cabal/Hpack files. Tasty ingredients are included along with various configuration options for different use cases.") + (license license:expat))) + +(define-public ghc-9.14-tree-view + (package + (name "ghc-9.14-tree-view") + (version "0.5.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "tree-view" version)) + (sha256 + (base32 "1ya3m1qi83pn74wzffvbzj7wn6n5zny4yzzzf7wlfqszl96jhn2g")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14)) + (properties '((upstream-name . "tree-view"))) + (inputs (list ghc-9.14-random-bootstrap + ghc-9.14-splitmix-bootstrap)) + (home-page "https://github.com/emilaxelsson/tree-view") + (synopsis "Render trees as foldable HTML and Unicode art.") + (description synopsis) + (license license:bsd-3))) + +(define-public ghc-9.14-typelits-witnesses + (package + (name "ghc-9.14-typelits-witnesses") + (version "0.4.1.0") + (source + (origin + (method url-fetch) + (uri (hackage-uri "typelits-witnesses" version)) + (sha256 + (base32 "01l5b0iif6m2162qqibgnivcvjfcv74kxwzdilbah33wiiy903fx")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14)) + (properties '((upstream-name . "typelits-witnesses"))) + (inputs (list ghc-9.14-dependent-sum)) + (home-page "https://github.com/mstksg/typelits-witnesses") + (synopsis "Existential witnesses, singletons, and classes for operations on GHC TypeLits.") + (description "This library contains: A small specialized subset of the singletons library as it pertains to Nat and Symbol, for when you need some simple functionality without wanting to invoke the entire singletons library. Operations for manipulating these singletons and KnownNat and KnownSymbol instances, such as addition and multiplication of singletons/KnownNat instances. Operations for the comparison of Nats in a way that works well with GHC.TypeLits's different comparison systems. This is helpful for bridging together libraries that use different systems; this functionality is not yet provided by singletons.") + (license license:expat))) + +(define-public ghc-9.14-universe-base + (package + (name "ghc-9.14-universe-base") + (version "1.1.4") + (source + (origin + (method url-fetch) + (uri (hackage-uri "universe-base" version)) + (sha256 + (base32 "160yyhbvfnl88kbxx4rpmb03b4mqhkig833flqzxq9r96ygmirdf")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14 + #:cabal-revision `("2" "076r1kbvnw1jdg71gjq84i5bqk3a66fs9h78c00r6hbc59m6c9c9"))) + (properties `((upstream-name . "universe-base"))) + (inputs (list ghc-9.14-tagged)) + (native-inputs (list ghc-9.14-quickcheck)) + (home-page "https://github.com/dmwit/universe") + (synopsis "A class for finite and recursively enumerable types.") + (description "A class for finite and recursively enumerable types and some helper functions for enumerating them. This is slim package definiting only the type-classes and instances for types in GHC boot libraries. For more instances check universe-instances-* packages.") + (license license:bsd-3))) + +(define-public ghc-9.14-variant + (package + (name "ghc-9.14-variant") + (version "1.0.3") + (source + (origin + (method url-fetch) + (uri (hackage-uri "variant" version)) + (sha256 + (base32 "0a7vajilkvxwgkck1b02wp2wvc03sbgllk4xf78lgasw5rg6854v")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14)) + (properties '((upstream-name . "variant"))) + (inputs (list ghc-9.14-recursion-schemes + ghc-9.14-unliftio-core)) + (native-inputs (list ghc-9.14-tasty + ghc-9.14-tasty-quickcheck)) + (home-page "https://www.haskus.org") + (synopsis "Variant and EADT.") + (description "Variant (extensible sum type) and EADT (extensible recursive sum type) datatypes.") + (license license:bsd-3))) + +(define-public ghc-9.14-vec + (package + (name "ghc-9.14-vec") + (version "0.5.1.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "vec" version)) + (sha256 + (base32 "14w5i9gydlxs60x025ai6wrbirhcsqzb0hh77zjyn16i034sdx8p")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14 + #:phases #~(modify-phases + %standard-phases + (add-before `configure `relax-deps + (lambda _ (substitute* + "vec.cabal" + (("QuickCheck [ <>=^*&[0-9.]*") "QuickCheck < 2.17"))))))) + (properties `((upstream-name . "vec"))) + (inputs (list ghc-9.14-adjunctions + ghc-9.14-boring + ghc-9.14-distributive + ghc-9.14-fin + ghc-9.14-hashable + ghc-9.14-indexed-traversable)) + (native-inputs (list ghc-9.14-inspection-testing + ghc-9.14-quickcheck)) + (home-page "https://github.com/phadej/vec") + (synopsis "Vec: length-indexed (sized) list.") + (description "This package provides length-indexed (sized) lists, also known as vectors. As best approach depends on the application, vec doesn't do any magic transformation. Benchmark your code.") + (license license:bsd-3))) + +(define-public ghc-9.14-vector-sized + (package + (name "ghc-9.14-vector-sized") + (version "1.6.1") + (source + (origin + (method url-fetch) + (uri (hackage-uri "vector-sized" version)) + (sha256 + (base32 "0gj9lgfakgzx2klhmbrlsf7lplc377s1mp6grbay7vranm2fj586")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14)) + (properties '((upstream-name . "vector-sized"))) + (inputs (list ghc-9.14-adjunctions + ghc-9.14-comonad + ghc-9.14-distributive + ghc-9.14-finite-typelits + ghc-9.14-hashable + ghc-9.14-indexed-list-literals + ghc-9.14-indexed-traversable + ghc-9.14-primitive + ghc-9.14-vector)) + (home-page "https://github.com/expipiplus1/vector-sized") + (synopsis "Size tagged vectors.") + (description "This package exports a newtype tagging the vectors from the vector package with a type-level natural representing their size. It also exports functions from vector whose size can be determined ahead of time, appropriately retyped.") + (license license:bsd-3))) + +(define-public ghc-9.14-vulkan + (package + (name "ghc-9.14-vulkan") + (version "3.27") + (source + (origin + (method url-fetch) + (uri (hackage-uri "vulkan" version)) + (sha256 + (base32 "062yz53il25p0s4dl99mypkjkzwmdrgas0dwsnxq3ka145pn30ni")))) + (build-system haskell-build-system) + (arguments (list #:haskell ghc-9.14)) + (properties '((upstream-name . "vulkan"))) + (inputs (list ghc-9.14-inline-c + ghc-9.14-vector + vulkan-loader)) + (native-inputs (list ghc-9.14-tasty + ghc-9.14-tasty-discover + ghc-9.14-tasty-hunit + pkg-config)) + (home-page "https://github.com/haskell-game/vulkan") + (synopsis "Bindings to the Vulkan graphics API.") + (description "Slightly high level Haskell bindings to the Vulkan graphics API. These bindings present an interface to Vulkan which looks like more idiomatic Haskell and which is much less verbose than the C API. Nevertheless, it retains access to all the functionality.") + (license license:bsd-3))) |