(define-module (andromeda packages haskell-xyz)
  #:use-module (andromeda packages haskell)
  #:use-module (andromeda packages haskell-core-xyz)
  #:use-module (andromeda utils)
  #:use-module (gnu packages documentation)
  #:use-module (gnu packages llvm)
  #: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))

(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)
     (patches (list (local-file "../../patches/ghc-9.14-doxygen-parser.diff"))) ;; TODO strange testing config, check with upstream??
     (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 ghc-9.14-quickcheck
                        ghc-9.14-tasty
                        ghc-9.14-tasty-hunit
                        ghc-9.14-tasty-quickcheck))
   (arguments (list #:haskell ghc-9.14
                    #: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)
     (patches (list (local-file "../../patches/ghc-9.14-hs-bindgen.diff"))) ;; skips fixture test suites TODO figure out write-ghc-environment-files
                                                                            ;; skips golden globals tests TODO figure out what fails
                                                                            ;; skips golden doxygen_docs test. Likely https://github.com/well-typed/hs-bindgen/issues/2225, doxygen is 1.16.1
     (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)))