(define-module (gnu packages futhark)
  #:use-module (guix packages)
  #:use-module (guix download)
  #:use-module (guix build-system haskell)
  #:use-module (guix licenses)
  #:use-module (guix git-download)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (gnu packages)
  #:use-module (gnu packages haskell)
  #:use-module (gnu packages haskell)
  #:use-module (gnu packages haskell-web)
  #:use-module (gnu packages haskell-xyz)
  #:use-module (gnu packages haskell-check)
  #:use-module (gnu packages haskell-crypto))

(define-public ghc-versions
  (package
    (name "ghc-versions")
    (version "5.0.0")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/versions/versions-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "1rfxjivdsaqc6w7dfqdycy3a81rsajvpfyi5si9ssc0w3ljfsbzr"))))
    (build-system haskell-build-system)
    (inputs
     `(("ghc-megaparsec" ,ghc-megaparsec)
       ("ghc-hashable" ,ghc-hashable)
       ("ghc-parser-combinators"
        ,ghc-parser-combinators)))
    (native-inputs
     `(("ghc-microlens" ,ghc-microlens)
       ("ghc-quickcheck" ,ghc-quickcheck)
       ("ghc-tasty" ,ghc-tasty)
       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
    (home-page
     "https://github.com/fosskers/versions")
    (synopsis
     "Types and parsers for software version numbers.")
    (description
     "A library for parsing and comparing software version numbers. We like to give version numbers to our software in a myriad of ways. Some ways follow strict guidelines for incrementing and comparison. Some follow conventional wisdom and are generally self-consistent. Some are just plain asinine. This library provides a means of parsing and comparing /any/ style of versioning, be it a nice Semantic Version like this: . > 1.2.3-r1+git123 . ...or a monstrosity like this: . > 2:10.2+0.0093r3+1-1 . Please switch to <http://semver.org Semantic Versioning> if you aren't currently using it. It provides consistency in version incrementing and has the best constraints on comparisons. . This library implements version @2.0.0@ of the SemVer spec.")
    (license license:bsd-3)))

(define-public ghc-cabal-doctest
  (package
    (name "ghc-cabal-doctest")
    (version "1.0.8")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/cabal-doctest/cabal-doctest-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "03if74imlhhk7m56nci5f1wclniwqdmwl4hl177040j1gnlac9i0"))))
    (build-system haskell-build-system)
    (arguments
     `(#:cabal-revision
       ("2"
        "05v1awad3d1wvc763xcgvxm4n6n7bs7byc6s14kdbw35zcaddlcb")))
    (home-page
     "https://github.com/phadej/cabal-doctest")
    (synopsis
     "A Setup.hs helper for doctests running")
    (description
     "Currently (beginning of 2017), there isn't @cabal doctest@ command. Yet, to properly work doctest needs plenty of configuration. This library provides the common bits for writing custom Setup.hs See <https://github.com/haskell/cabal/issues/2327 Cabal/2327> for the progress of @cabal doctest@, i.e. whether this library is obsolete.")
    (license license:bsd-3)))

(define-public ghc-pcg-random
  (package
    (name "ghc-pcg-random")
    (version "0.1.3.7")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/pcg-random/pcg-random-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "1l6jq5nvmg1ygk7i7g50s47p6qkh74p9avl1wbcxdl5m85lc5j76"))))
    (build-system haskell-build-system)
    (inputs
     `(("ghc-primitive" ,ghc-primitive)
       ("ghc-random" ,ghc-random)
       ("ghc-entropy" ,ghc-entropy)
       ("ghc-doctest" ,ghc-doctest)
       ("ghc-cabal-doctest" ,ghc-cabal-doctest)))
    ;; (native-inputs
    ;;   `(("ghc-doctest" ,ghc-doctest)
    ;;     ("ghc-cabal-doctest" ,ghc-cabal-doctest)))
    (home-page
     "http://github.com/cchalmers/pcg-random")
    (synopsis
     "Haskell bindings to the PCG random number generator.")
    (description
     "PCG is a family of simple fast space-efficient statistically good algorithms for random number generation. Unlike many general-purpose RNGs, they are also hard to predict. . This library implements bindings to the standard C implementation. This includes the standard, unique, fast and single variants in the pcg family. There is a pure implementation that can be used as a generator with the random package as well as a faster primitive api that includes functions for generating common types. . The generators in this module are suitable for use in parallel but make sure threads don't share the same generator or things will go horribly wrong.")
    (license license:bsd-3)))

(define-public ghc-neat-interpolation
  (package
    (name "ghc-neat-interpolation")
    (version "0.5.1.2")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/neat-interpolation/neat-interpolation-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "18c48r5qwrapkjh35l5dng3ahkkn1ch47vc4nzjwh4a9va94laln"))))
    (build-system haskell-build-system)
    (inputs `(("ghc-megaparsec" ,ghc-megaparsec)))
    (native-inputs
     `(("ghc-quickcheck" ,ghc-quickcheck)
       ("ghc-quickcheck-instances"
        ,ghc-quickcheck-instances)
       ("ghc-rerebase" ,ghc-rerebase)
       ("ghc-tasty" ,ghc-tasty)
       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
    (home-page
     "https://github.com/nikita-volkov/neat-interpolation")
    (synopsis
     "A quasiquoter for neat and simple multiline text interpolation")
    (description
     "A quasiquoter for producing Text values with support for a simple interpolation of input values. It removes the excessive indentation from the input and accurately manages the indentation of all lines of the interpolated variables.")
    (license license:expat)))

(define-public ghc-srcloc
  (package
    (name "ghc-srcloc")
    (version "0.6")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/srcloc/srcloc-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "1vcp9vgfi5rscy09l4qaq0pp426b6qcdpzs6kpbzg0k5x81kcsbb"))))
    (build-system haskell-build-system)
    (home-page "https://github.com/mainland/srcloc")
    (synopsis
     "Data types for managing source code locations.")
    (description
     "Data types for tracking, combining, and printing source code locations.")
    (license license:bsd-3)))

(define-public ghc-mainland-pretty
  (package
    (name "ghc-mainland-pretty")
    (version "0.7.1")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/mainland-pretty/mainland-pretty-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "19z2769rik6kwvsil2if2bfq2v59jmwv74jy3fy4q3q3zy4239p1"))))
    (build-system haskell-build-system)
    (inputs `(("ghc-srcloc" ,ghc-srcloc)))
    (home-page
     "https://github.com/mainland/mainland-pretty")
    (synopsis
     "Pretty printing designed for printing source code.")
    (description
     "Pretty printing designed for printing source code based on Wadler's paper /A Prettier Printer/. The main advantage of this library is its ability to automatically track the source locations associated with pretty printed values and output appropriate #line pragmas and its ability to produce output in the form of lazy text using a builder.")
    (license license:bsd-3)))

(define-public ghc-exception-transformers
  (package
    (name "ghc-exception-transformers")
    (version "0.4.0.9")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/exception-transformers/exception-transformers-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "033z8mhczwf59lh59q3z546gkcsy0bzg98r1qhm3fiq7j11hgd95"))))
    (build-system haskell-build-system)
    (inputs
     `(("ghc-transformers-compat"
        ,ghc-transformers-compat)))
    (native-inputs
     `(("ghc-hunit" ,ghc-hunit)
       ("ghc-test-framework" ,ghc-test-framework)
       ("ghc-test-framework-hunit"
        ,ghc-test-framework-hunit)))
    (home-page
     "http://hackage.haskell.org/package/exception-transformers")
    (synopsis
     "Type classes and monads for unchecked extensible exceptions.")
    (description
     "This package provides type classes, a monad and a monad transformer that support unchecked extensible exceptions as well as asynchronous exceptions. It is compatible with the transformers package.")
    (license license:bsd-3)))

(define-public ghc-exception-mtl
  (package
    (name "ghc-exception-mtl")
    (version "0.4.0.1")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/exception-mtl/exception-mtl-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "0d51rsrcjy52d62f51hb6fdg0fj9b0qbv8hqf6523pndwsxbq4zc"))))
    (build-system haskell-build-system)
    (inputs
     `(("ghc-exception-transformers"
        ,ghc-exception-transformers)))
    (home-page
     "http://hackage.haskell.org/package/exception-mtl")
    (synopsis
     "Exception monad transformer instances for mtl classes.")
    (description
     "This package provides exception monad transformer instances for the classes defined by mtl.")
    (license license:bsd-3)))

(define-public ghc-language-c-quote
  (package
    (name "ghc-language-c-quote")
    (version "0.13")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/language-c-quote/language-c-quote-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "02axz6498sg2rf24qds39n9gysc4lm3v354h2qyhrhadlfq8sf6d"))))
    (build-system haskell-build-system)
    (inputs
     `(("ghc-exception-mtl" ,ghc-exception-mtl)
       ("ghc-exception-transformers"
        ,ghc-exception-transformers)
       ("ghc-mainland-pretty" ,ghc-mainland-pretty)
       ("ghc-srcloc" ,ghc-srcloc)
       ("ghc-syb" ,ghc-syb)
       ("ghc-haskell-src-meta" ,ghc-haskell-src-meta)))
    (native-inputs
     `(("ghc-hunit" ,ghc-hunit)
       ("ghc-test-framework" ,ghc-test-framework)
       ("ghc-test-framework-hunit"
        ,ghc-test-framework-hunit)
       ("ghc-alex" ,ghc-alex)
       ("ghc-happy" ,ghc-happy)))
    (home-page
     "https://github.com/mainland/language-c-quote")
    (synopsis
     "C/CUDA/OpenCL/Objective-C quasiquoting library.")
    (description
     "This package provides a general parser for the C language, including most GCC extensions and some CUDA and OpenCL extensions as well as the entire Objective-C language.")
    (license license:bsd-3)))

(define-public ghc-directory-tree
  (package
    (name "ghc-directory-tree")
    (version "0.12.1")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/directory-tree/directory-tree-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "05z5ws58kky3wcwwwv6q16m9vs0lzj35qqs9v5acy9m2nfal8272"))))
    (build-system haskell-build-system)
    (home-page
     "http://brandon.si/code/directory-tree-module-released/")
    (synopsis
     "A simple directory-like tree datatype, with useful IO functions")
    (description
     "A simple directory-like tree datatype, with useful IO functions and Foldable and Traversable instance . Provides a simple data structure mirroring a directory tree on the filesystem, as well as useful functions for reading and writing file and directory structures in the IO monad. . Importing the library and optional (useful) Foldable and Traverable libraries: . > import System.Directory.Tree > import qualified Data.Foldable as F > import qualified Data.Traversable as T . Write a hand-made directory tree of textfiles (strings) to the disk. Simulates creating a new user Tux's home directory on a unix machine: . > writeDirectory$ \"/home\" :/ Dir \"Tux\" [File \"README\" \"Welcome!\"] . \"read\" a directory by opening all the files at a filepath with readFile, returning an 'AnchoredDirTree String' (d2). Then check for any IO failures: . > do (base :/ d2) <- readDirectory \"../parent_dir/dir2/\" >    let failed = anyFailed d2 >    if failed then ... . Use Foldable instance function to concat a directory 'dir' of text files into a single file under the same directory: . > do (b :/ dt) <- readDirectory dir >    let f = F.concat dt >    return$ b :/ File \"ALL_TEXT\" f . Open all the files in the current directory as lazy bytestrings, ignoring the base path in Anchored wrapper: . > import qualified Data.ByteString.Lazy as B > do (_ :/ dTree) <- readDirectoryWith B.readFile \"./\" . This version also offers an experimental function `readDirectoryWithL` that does lazy directory IO, allowing you to treat the returned `DirTree` as if it were a normal lazily-generated data structure. . For example, the following does only the amount of IO necessary to list the file names of the children of the root directory, similar to \"ls /\": . > do d <- readDirectoryWithL readFile \"/\" >    mapM_ (putStrLn . name) $ contents $ free d . Any ideas or suggestions for improvements are most welcome :-) . /CHANGES/: from 0.11 . - export 'System.Directory.Tree.transformDir' as requested . - add test suite to cabal file . - remove redundant @removeNonexistent@ (thanks to dmwit for patch) .")
    (license license:bsd-3)))

(define-public ghc-bmp
  (package
    (name "ghc-bmp")
    (version "1.2.6.3")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/bmp/bmp-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "1k6s5z520dadj38y7ja0m4syrg094gyq14c63i6wx2701zj3viiw"))))
    (build-system haskell-build-system)
    (home-page "https://github.com/benl23x5/bmp")
    (synopsis
     "Read and write uncompressed BMP image files.")
    (description
     "Read and write uncompressed BMP image files. 100% robust Haskell implementation.")
    (license license:expat)))

(define-public ghc-bytestring-to-vector
  (package
    (name "ghc-bytestring-to-vector")
    (version "0.3.0.1")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/bytestring-to-vector/bytestring-to-vector-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "0ji836sl72wlhy6yay11kl86w0nrcdc1lafbi94bx9c8rpf5pyyc"))))
    (build-system haskell-build-system)
    (inputs `(("ghc-vector" ,ghc-vector)))
    (native-inputs
     `(("ghc-byteorder" ,ghc-byteorder)
       ("ghc-quickcheck" ,ghc-quickcheck)))
    (home-page
     "https://github.com/sheyll/bytestring-to-vector")
    (synopsis
     "Convert between ByteString and Vector.Storable without copying")
    (description
     "This library allows conversion between the types from @Data.ByteString@ (package @bytestring@) and @Data.Vector.Storable@ (package @vector@) without copying the underlying data.  This is useful, for example, when @ByteString@ IO produces or consumes vectors of numbers in native byte order. . The conversion relies on the fact that @ByteString@ and @Vector@ use their respective @ForeignPtr@s in compatible ways. . This library is a fork of the @spool@ package written by Keegan McAllister.")
    (license license:bsd-3)))

;; (define-public ghc-containers
;;   (package
;;     (name "ghc-containers")
;;     (version "0.6.5.1")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri (string-append
;;              "https://hackage.haskell.org/package/containers/containers-"
;;              version
;;              ".tar.gz"))
;;        (sha256
;;         (base32
;;          "1zlyvkamzc87hr7r3ckyvgwhszdk9i18jrsv2cmkh9v093gvl7ni"))))
;;     (build-system haskell-build-system)
;;     (home-page
;;      "http://hackage.haskell.org/package/containers")
;;     (synopsis "Assorted concrete container types")
;;     (description
;;      ". This package contains efficient general-purpose implementations of various immutable container types including sets, maps, sequences, trees, and graphs. . For a walkthrough of what this package provides with examples of common operations see the [containers introduction](https://haskell-containers.readthedocs.io). . The declared cost of each operation is either worst-case or amortized, but remains valid even if structures are shared.")
;;     (license license:bsd-3)))

;; (define-public ghc-base
;;   (package
;;     (name "ghc-base")
;;     (version "4.15.0.0")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri (string-append
;;              "https://hackage.haskell.org/package/base/base-"
;;              version
;;              ".tar.gz"))
;;        (sha256
;;         (base32
;;          "12s4v5w97vaxk66a1mgdgypv765j61lq2n2h4iiazirpggd73n3g"))))
;;     (build-system haskell-build-system)
;;     (inputs
;;      `(;; ("ghc-rts" ,ghc-rts)
;;        ;; ("ghc-bignum" ,ghc-bignum)
;;        ))
;;     (home-page
;;      "http://hackage.haskell.org/package/base")
;;     (synopsis "Basic libraries")
;;     (description
;;      "This package contains the Standard Haskell \"Prelude\" and its support libraries, and a large collection of useful libraries ranging from data structures to parsing combinators and debugging utilities.")
;;     (license license:bsd-3)))

;; (define-public ghc-megaparsec (package
;;                                 (name "ghc-megaparsec")
;;                                 (version "9.0.1")
;;                                 (source
;;                                  (origin
;;                                    (method url-fetch)
;;                                    (uri (string-append
;;                                          "https://hackage.haskell.org/package/megaparsec/megaparsec-"
;;                                          version
;;                                          ".tar.gz"))
;;                                    (sha256
;;                                     (base32
;;                                      "00953zvxfyjibw8c1ssmixxh0cwn59pz24zbh6s34rk3v14vqa3j"))))
;;                                 (build-system haskell-build-system)
;;                                 (inputs
;;                                  `(("ghc-case-insensitive" ,ghc-case-insensitive)
;;                                    ("ghc-parser-combinators"
;;                                     ,ghc-parser-combinators)
;;                                    ("ghc-scientific" ,ghc-scientific)))
;;                                 (arguments
;;                                  `(#:cabal-revision
;;                                    ("1"
;;                                     "00vjc5b1x6yd0jqsbcahvghlkwai65dl1ib6744a0lhsa9vsni12")))
;;                                 (home-page
;;                                  "https://github.com/mrkkrp/megaparsec")
;;                                 (synopsis "Monadic parser combinators")
;;                                 (description
;;                                  "This is an industrial-strength monadic parser combinator library. Megaparsec is a feature-rich package that tries to find a nice balance between speed, flexibility, and quality of parse errors.")
;;                                 (license license:bsd-2)))

;; (define-public ghc-cmark-gfm
;;   (package
;;     (name "ghc-cmark-gfm")
;;     (version "0.2.2")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri (string-append
;;              "https://hackage.haskell.org/package/cmark-gfm/cmark-gfm-"
;;              version
;;              ".tar.gz"))
;;        (sha256
;;         (base32
;;          "1skzdg1icmhn0zrkhbnba4200ymah8sd5msk4qfgawrk77zilw7f"))))
;;     (build-system haskell-build-system)
;;     (native-inputs `(("ghc-hunit" ,ghc-hunit)))
;;     (home-page
;;      "https://github.com/kivikakk/cmark-gfm-hs")
;;     (synopsis
;;      "Fast, accurate GitHub Flavored Markdown parser and renderer")
;;     (description
;;      "This package provides Haskell bindings for <https://github.com/github/cmark-gfm libcmark-gfm>, the reference parser for <https://github.github.com/gfm/ GitHub Flavored Markdown>, a fully specified variant of Markdown. It includes sources for libcmark-gfm (0.29.0.gfm.0) and does not require prior installation of the C library.")
;;     (license license:bsd-3)))

(define-public ghc-futhark
  (package
    (name "ghc-futhark")
    (version "0.19.6")
    (source
     (origin
       (method url-fetch)
       (uri (string-append
             "https://hackage.haskell.org/package/futhark/futhark-"
             version
             ".tar.gz"))
       (sha256
        (base32
         "1wpg2ad2xv60xsdvnq3246nps3ldc00n58k7jxmh8lrx5bjzg263"))))
    (build-system haskell-build-system)
    (arguments `(#:haskell ,ghc-8.8))
    (inputs
     `(("ghc-aeson" ,ghc-aeson)
       ("ghc-ansi-terminal" ,ghc-ansi-terminal)
       ("ghc-blaze-html" ,ghc-blaze-html)
       ("ghc-bytestring-to-vector"
        ,ghc-bytestring-to-vector)
       ("ghc-bmp" ,ghc-bmp)
       ("ghc-directory-tree" ,ghc-directory-tree)
       ("ghc-dlist" ,ghc-dlist)
       ("ghc-file-embed" ,ghc-file-embed)
       ("ghc-free" ,ghc-free)
       ("ghc-gitrev" ,ghc-gitrev)
       ("ghc-hashable" ,ghc-hashable)
       ("ghc-language-c-quote" ,ghc-language-c-quote)
       ("ghc-mainland-pretty" ,ghc-mainland-pretty)
       ("ghc-cmark-gfm" ,ghc-cmark-gfm)
       ("ghc-megaparsec" ,ghc-megaparsec)
       ("ghc-neat-interpolation"
        ,ghc-neat-interpolation)
       ("ghc-parallel" ,ghc-parallel)
       ("ghc-pcg-random" ,ghc-pcg-random)
       ("ghc-process-extras" ,ghc-process-extras)
       ("ghc-regex-tdfa" ,ghc-regex-tdfa)
       ("ghc-srcloc" ,ghc-srcloc)
       ("ghc-temporary" ,ghc-temporary)
       ("ghc-terminal-size" ,ghc-terminal-size)
       ("ghc-unordered-containers"
        ,ghc-unordered-containers)
       ("ghc-utf8-string" ,ghc-utf8-string)
       ("ghc-vector" ,ghc-vector)
       ("ghc-vector-binary-instances"
        ,ghc-vector-binary-instances)
       ("ghc-versions" ,ghc-versions)
       ("ghc-zip-archive" ,ghc-zip-archive)
       ("ghc-zlib" ,ghc-zlib)))
    (native-inputs
     `(("ghc-quickcheck" ,ghc-quickcheck)
       ("ghc-parser-combinators"
        ,ghc-parser-combinators)
       ("ghc-tasty" ,ghc-tasty)
       ("ghc-tasty-hunit" ,ghc-tasty-hunit)
       ("ghc-tasty-quickcheck" ,ghc-tasty-quickcheck)))
    (home-page "https://futhark-lang.org")
    (synopsis
     "An optimising compiler for a functional, array-oriented language.")
    (description
     "Futhark is a small programming language designed to be compiled to efficient parallel code. It is a statically typed, data-parallel, and purely functional array language in the ML family, and comes with a heavily optimising ahead-of-time compiler that presently generates GPU code via CUDA and OpenCL, although the language itself is hardware-agnostic. . For more information, see the website at https://futhark-lang.org . For introductionary information about hacking on the Futhark compiler, see <https://futhark.readthedocs.io/en/latest/hacking.html the hacking guide>. Regarding the internal design of the compiler, the following modules make good starting points: . * \"Futhark.IR.Syntax\" explains the basic design of the intermediate representation (IR). * \"Futhark.Construct\" explains how to write code that manipulates and creates AST fragments. . <<docs/assets/ohyes.png You too can go fast once you rewrite your program in Futhark.>>")
    (license license:isc)))

ghc-futhark