guix-devel/gnu/packages/julia-xyz.scm

;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2019 Nicolò Balzarotti <nicolo@nixo.xyz>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu packages julia-xyz)
  #:use-module (guix build-system julia)
  #:use-module (guix git-download)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (guix packages)
  #:use-module (gnu packages algebra)
  #:use-module (gnu packages base)      ; binutils (packagecompiler)
  #:use-module (gnu packages commencement)
  #:use-module (gnu packages compression)
  #:use-module (gnu packages fontutils)
  #:use-module (gnu packages fonts)
  #:use-module (gnu packages graphics)
  #:use-module (gnu packages glib)
  #:use-module (gnu packages gtk)
  #:use-module (gnu packages image)
  #:use-module (gnu packages imagemagick)
  #:use-module (gnu packages maths)
  #:use-module (gnu packages statistics)
  #:use-module (gnu packages video)
  #:use-module (gnu packages web)
  #:use-module (gnu packages xml)
  #:use-module (gnu packages tls))

(define-public julia-compat
  (package
    (name "julia-compat")
    (version "2.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaLang/Compat.jl")
             (commit (string-append "v" version))))
       (file-name "Compat")
       (sha256
        (base32 "024gqvhabranf398hwhb4m2w3a42kdg9zqj8s4pmjvaal14grw70"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaLang/Compat.jl")
    (synopsis "Compatibility across Julia versions")
    (description "The Compat package is designed to ease interoperability
between older and newer versions of the Julia language.  The Compat package
provides a macro that lets you use the latest syntax in a backwards-compatible
way.")
    (license license:expat)))

(define-public julia-uriparser
  (package
    (name "julia-uriparser")
    (version "0.4.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaWeb/URIParser.jl")
             (commit (string-append "v" version))))
       (file-name "URIParser")
       (sha256
        (base32 "1i45wza6jh9k7x8jrqiil6k2yb81hdzm3s0zqhzy3y2sby66p44p"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaWeb/URIParser.jl")
    (synopsis "Provides URI parsing according to RFC 3986")
    (description "@code{URIParser} is a julia package that provides URI
parsing according to RFC 3986.")
    (license license:expat)))

(define-public julia-inifile
  (package
    (name "julia-inifile")
    (version "0.5.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaIO/IniFile.jl")
             (commit (string-append "v" version))))
       (file-name "IniFile")
       (sha256
        (base32 "19cn41w04hikrqdzlxhrgf21rfqhkvj9x1zvwh3yz9hqbf350xs9"))))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "IniFile" "83e8ac13-25f8-5344-8a64-a9f2b223428f" "0.5.0"
              '())
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaIO/IniFile.jl")
    (synopsis "Reading Windows-style INI files")
    (description "@code{julia-inifile} is a julia package that defines an
Inifile type that allows to interface with @file{.ini} files.")
    (license license:expat)))

(define-public julia-sha
  (package
    (name "julia-sha")
    (version "0.5.7")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/staticfloat/SHA.jl")
             ;; Tests fixed after 0.5.7 release
             (commit "97b17a7fabf894257726c33cbd78255ac380906d")))
       (file-name "SHA")
       (sha256
        (base32 "169y78cmppj117cmh8ncnyh381caf9dsklaks5l40mia9jdcqbgl"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/staticfloat/SHA.jl")
    (synopsis "Performant, 100% native-julia SHA1, SHA2, and SHA3
implementation")
    (description "Julia package implementing SHA algorithms.  Each exported
function takes in either an Array{UInt8}, a ByteString or an IO object.")
    (license license:expat)))

(define-public julia-binaryprovider
  (package
    (name "julia-binaryprovider")
    (version "0.5.5")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaPackaging/BinaryProvider.jl")
             (commit (string-append "v" version))))
       (file-name "BinaryProvider")
       (sha256
        (base32 "1papsz5ki5iwv1v3ac1ddybjxak93nydh7dqc3231zm0fzd918ys"))))
    (propagated-inputs `(("julia-sha" ,julia-sha)))
    (arguments
     `(;; wants to download things with curl/wget, both in tests and
       ;; precompilation
       #:tests? #f
       #:phases
       (modify-phases %standard-phases (delete 'precompile))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPackaging/BinaryProvider.jl")
    (synopsis "A reliable binary provider for Julia")
    (description "Install binary packages with Julia.")
    (license license:expat)))

(define-public julia-mbedtls
  (package
    (name "julia-mbedtls")
    (version "0.7.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaWeb/MbedTLS.jl")
             (commit (string-append "v" version))))
       (file-name "MbedTLS")
       (sha256
        (base32 "1a8snw9gi21lm6r3kh6ly7ngi99s9k5shqkfiizj3g9li20q23h2"))))
    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
                         ("mbedtls-apache" ,mbedtls-apache)))
    (arguments
     `(#:tests? #f ;; most of them require network connection
       #:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (let ((f (open-file
                       (string-append
                        (assoc-ref outputs "out")
                        "/share/julia/packages/"
                        (string-append
                         (strip-store-file-name source) "/deps/deps.jl"))
                       "w")))
               (display (string-append "const libmbedcrypto = \""
                                       (assoc-ref inputs "mbedtls-apache")
                                       "/lib/libmbedcrypto.so\"\n") f)
               (display (string-append "const libmbedtls = \""
                                       (assoc-ref inputs "mbedtls-apache")
                                       "/lib/libmbedtls.so\"\n") f)
               (display (string-append "const libmbedx509 = \""
                                       (assoc-ref inputs "mbedtls-apache")
                                       "/lib/libmbedx509.so\"\n") f)
               (close-port f))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaWeb/MbedTLS.jl")
    (synopsis "Wrapper around the mbed TLS and cryptography C libary")
    (description "@code{julia-mbedtls} is a julia wrapper around mbed TLS.")
    (license license:expat)))

(define-public julia-parsers
  (package
    (name "julia-parsers")
    (version "0.3.7")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaData/Parsers.jl")
             (commit (string-append "v" version))))
       (file-name "Parsers")
       (sha256
        (base32 "01j8cpnhxpxzybqzbvv3h5v0ksysqxmh5fmls6hpza2p3gjg4yrv"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaData/Parsers.jl")
    (synopsis "Fast parsing machinery for basic types in Julia")
    (description "@code{Parsers} is a collection of type parsers and utilities
for Julia")
    (license license:expat)))

(define-public julia-bindeps
  (package
    (name "julia-bindeps")
    (version "0.8.10")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaPackaging/BinDeps.jl")
             (commit (string-append "v" version))))
       (file-name "BinDeps")
       (sha256
        (base32 "1da7z4ii78gaqnjal7c4d1xvicyshiil4ls6xhi9id4q8plmfa2m"))))
    ;; Tries to fetch and build things, we already take care of that manually
    (arguments '(#:tests? #f))
    (propagated-inputs `(("julia-uriparser" ,julia-uriparser)
                         ("julia-sha" ,julia-sha)
                         ("julia-compat" ,julia-compat)))
    
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPackaging/BinDeps.jl")
    (synopsis "Easily build binary dependencies for Julia packages")
    (description "@code{BinDeps} is a package that provides a collection of
tools to build binary dependencies for Julia packages.")
    (license license:expat)))

(define-public julia-customunitranges
  (package
    (name "julia-customunitranges")
    (version "0.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaArrays/CustomUnitRanges.jl")
             (commit (string-append "v" version))))
       (file-name "CustomUnitRanges")
       (sha256
        (base32 "1kbqygg58jxx0kqbgljzvcd1pinaxy6xri2chkz3ng083cld0i8s"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/CustomUnitRanges.jl")
    (synopsis "Package-specific AbstractUnitRange types for julia")
    (description "This Julia package supports the creation of array types with
\"unconventional\" indices, i.e., when the indices may not start at 1.  With
this package, each custom array type can have a corresponding indices range
type, consequently providing a means for consistency in allocation by
similar.")
    (license license:expat)))

(define-public julia-catindices
  (package
    (name "julia-catindices")
    (version "0.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaArrays/CatIndices.jl")
             (commit (string-append "v" version))))
       (file-name "CatIndices")
       (sha256
        (base32 "0n8bci3sd65zfqwzqgy2cd8fvh88xk5qlb2givpmd8w33w5rih7c"))))
    (propagated-inputs `(("julia-offsetarrays" ,julia-offsetarrays)
                         ("julia-customunitranges" ,julia-customunitranges)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/CatIndices.jl")
    (synopsis "Julia package for indices-aware array concatenation and
growth")
    (description "Julia package for concatenating, growing, and shrinking
arrays in ways that allow control over the resulting axes.")
    (license license:expat)))

(define-public julia-offsetarrays
  (package
    (name "julia-offsetarrays")
    (version "0.11.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaArrays/OffsetArrays.jl")
             (commit (string-append "v" version))))
       (file-name "OffsetArrays")
       (sha256
        (base32 "0bbmp26lpzd9m0w93b6hfypc2n04drzdw53s8ghjpx70gbc4nzcy"))))
    ;; tests require Catindices, introducing a circular dependency
    (arguments '(#:tests? #f))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/OffsetArrays.jl")
    (synopsis "Fortran-like arrays with arbitrary, zero or negative starting
indices")
    (description "OffsetArrays provides Julia users with arrays that have
arbitrary indices, similar to those found in some other programming languages
like Fortran.")
    (license license:expat)))

(define-public julia-orderedcollections
  (package
    (name "julia-orderedcollections")
    (version "1.1.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaCollections/OrderedCollections.jl")
             ;; They added Package.toml after the 1.1.0 tag
             (commit "7a789d72a40f4c446f59575f5d77a63df4391a24")))
       (file-name "OrderedCollections")
       (sha256
        (base32 "09b3mlzkxcbc8wn0pji73591865li07q4kvvfzn9x4256mw47riq"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaCollections/OrderedCollections.jl")
    (synopsis "Julia implementation of associative containers that preserve
insertion order")
    (description "This package implements OrderedDicts and OrderedSets, which
are similar to containers in base Julia.  However, during iteration the
Ordered* containers return items in the order in which they were added to the
collection.")
    (license license:expat)))

(define-public julia-datastructures
  (package
    (name "julia-datastructures")
    (version "0.17.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaCollections/DataStructures.jl")
             (commit (string-append "v" version))))
       (file-name "DataStructures")
       (sha256
        (base32 "0l742ac5n2g2nnrbxvkqz1wkj739rmflzd8zyz934dc6a5pwnzrw"))))
    (propagated-inputs
     `(("julia-orderedcollections" ,julia-orderedcollections)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaCollections/DataStructures.jl")
    (synopsis "Julia implementation of Data structures")
    (description "This package implements a variety of data structures,
including:

@enumerate
@item Deque (implemented with an unrolled linked list)
@item CircularBuffer
@item CircularDeque
@item Stack
@item Queue
@item Accumulators and Counters (i.e. Multisets / Bags)
@item Disjoint Sets
@item Binary Heap
@item Mutable Binary Heap
@item Ordered Dicts and Sets
@item Dictionaries with Defaults
@item Trie
@item Linked List and Mutable Linked List
@item Sorted Dict, Sorted Multi-Dict and Sorted Set
@item DataStructures.IntSet
@item Priority Queue
@item Fenwick Tree
@item SparseIntSet
@end enumerate")
    (license license:expat)))

(define-public julia-fixedpointnumbers
  (package
    (name "julia-fixedpointnumbers")
    (version "0.6.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/FixedPointNumbers.jl")
             (commit (string-append "v" version))))
       (file-name "FixedPointNumbers")
       (sha256
        (base32 "033s9gi94xs97kshy2mcx5mvdkigdf4aqgaa6qgq6kz4s6gbpa9r"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaMath/FixedPointNumbers.jl")
    (synopsis "Fixed point types for julia")
    (description "This library implements fixed-point number types.  A
fixed-point number represents a fractional, or non-integral, number.  In
contrast with the more widely known floating-point numbers, with fixed-point
numbers the decimal point doesn't \"float\": fixed-point numbers are
effectively integers that are interpreted as being scaled by a constant
factor.  Consequently, they have a fixed number of digits (bits) after the
decimal (radix) point.")
    (license license:expat)))

(define-public julia-json
  (package
    (name "julia-json")
    (version "0.21.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaIO/JSON.jl")
             (commit (string-append "v" version))))
       (file-name "JSON")
       (sha256
        (base32 "0knmfjhchd3ggy86dsfyb7l4v3fv5dcr207cgp54mj7rj96caqsm"))))
    (propagated-inputs `(("julia-parsers" ,julia-parsers)))
    (inputs `(("julia-offsetarrays" ,julia-offsetarrays)
              ("julia-datastructures" ,julia-datastructures)
              ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaIO/JSON.jl")
    (synopsis "JSON parsing and printing")
    (description "Parsing and printing JSON in pure Julia.")
    (license license:expat)))

(define-public julia-bufferedstreams
  (package
    (name "julia-bufferedstreams")
    (version "1.0.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/BioJulia/BufferedStreams.jl")
             (commit (string-append "v" version))))
       (file-name "BufferedStreams")
       (sha256
        (base32 "0sf4sxbq55mg2pwxyxf0c839z1lk0yxg8nmb7617bfbvw31cp88z"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    ;; tests are freezing, see
    ;; https://travis-ci.org/BioJulia/BufferedStreams.jl/jobs/491050182
    (arguments '(#:tests? #f))
    (build-system julia-build-system)
    (home-page "https://github.com/BioJulia/BufferedStreams.jl")
    (synopsis "Fast composable IO streams")
    (description "@code{BufferedStreams} provides buffering for IO
operations.  It can wrap any IO type automatically making incremental reading
and writing faster.")
    (license license:expat)))

(define-public julia-transcodingstreams
  (package
    (name "julia-transcodingstreams")
    (version "0.9.5")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/bicycle1885/TranscodingStreams.jl")
             (commit (string-append "v" version))))
       (file-name "TranscodingStreams")
       (sha256
        (base32 "0zfr4g4yv08iy96vshn7zn4lh2z5rwd4k1ybvyinp3srl69hxlk9"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (delete 'reset-gzip-timestamps)
         ;; It tries to test other packages
         (add-before 'check 'disable-pkg-test
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (substitute*
                 (string-append
                  (assoc-ref outputs "out") "/share/julia/packages/"
                  (strip-store-file-name source) "/test/runtests.jl")
               (("Pkg.test") "println"))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/bicycle1885/TranscodingStreams.jl")
    (synopsis "Simple, consistent interfaces for any codec")
    (description " @code{TranscodingStreams.jl} is a package for transcoding
data streams, which is:
@enumerate
@item fast: small overhead and specialized
methods,
@item consistent: basic I/O operations you already know will work as
you expect,
@item generic: support any I/O objects like files, buffers, pipes,
@item extensible: you can define a new codec to transcode data
@end enumerate")
    (license license:expat)))

(define-public julia-codeczlib
  (package
    (name "julia-codeczlib")
    (version "0.6.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/bicycle1885/CodecZlib.jl")
             (commit (string-append "v" version))))
       (file-name "CodecZlib")
       (sha256
        (base32 "18j5lhcsgln4ng5ik0y1s194q1a8h4828wwp4ws5vqc9i2spn8mb"))))
    (propagated-inputs `(("julia-transcodingstreams" ,julia-transcodingstreams)
                         ("julia-binaryprovider" ,julia-binaryprovider)
                         ("zlib" ,zlib)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (delete 'reset-gzip-timestamps)
         (add-before 'precompile 'build-deps
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (let ((f (open-file
                       (string-append
                        (assoc-ref outputs "out")
                        "/share/julia/packages/"
                        (string-append
                         (strip-store-file-name source) "/deps/deps.jl"))
                       "w")))
               (display (string-append "const libz = \""
                                       (assoc-ref inputs "zlib")
                                       "/lib/libz.so\"\n") f)
               (display "check_deps() = true\n" f)
               (close-port f))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/bicycle1885/CodecZlib.jl")
    (synopsis "@code{Zlib} codecs for @code{TranscodingStreams}")
    (description "@code{CodecZlib} provides Zlib bindings for the
@code{TranscodingStreams} interface.")
    (license license:expat)))

(define-public julia-http
  (package
    (name "julia-http")
    (version "0.8.6")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaWeb/HTTP.jl")
             (commit (string-append "v" version))))
       (file-name "HTTP")
       (sha256
        (base32 "01s9nszgdinpa3pyra646w2yi4qx0d6hcngsrxx291vr5gnhr7lj"))))
    (propagated-inputs `(("julia-inifile" ,julia-inifile)
                         ("julia-mbedtls" ,julia-mbedtls)
                         ("julia-compat" ,julia-compat)))
    (inputs `(("julia-json" ,julia-json)
              ("julia-bufferedstreams" ,julia-bufferedstreams)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (delete 'reset-gzip-timestamps)
         ;; It tries to test other packages
         (add-before 'check 'disable-pkg-test
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (substitute*
                 (string-append
                  (assoc-ref outputs "out") "/share/julia/packages/"
                  (strip-store-file-name source) "/test/runtests.jl")
               ;; requires network access
               (("\"client.jl\",") "# \"client.jl\",")
               (("\"WebSockets.jl\",") "# \"WebSockets.jl\",")
               (("\"messages.jl\",") "# \"messages.jl\",")
               (("\"server.jl\",") "# \"server.jl\",")
               (("\"aws4.jl\",") "# \"aws4.jl\",")
               (("\"async.jl\",") "# \"asyn.jl\","))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://juliaweb.github.io/HTTP.jl/")
    (synopsis "HTTP for Julia")
    (description "HTTP client and server functionality for Julia.")
    (license license:expat)))

(define-public julia-libexpat
  (package
    (name "julia-libexpat")
    ;; 0.6.0 requires julia 1.3+
    (version "0.5.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaIO/LibExpat.jl")
             (commit (string-append "v" version))))
       (file-name "LibExpat")
       (sha256
        (base32 "1iny18z76bkf3yi6cvpfia7z1j7kn789iy0nwigsj2sb9mfi5x8b"))))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda*
               (#:key outputs source inputs #:allow-other-keys)
             (substitute*
                 (string-append
                  (assoc-ref outputs "out") "/share/julia/packages/"
                  (strip-store-file-name source) "/src/LibExpat.jl")
               (("const libexpat = \"libexpat\"")
                (string-append "const libexpat = \""
                               (assoc-ref inputs "expat")
                               "/lib/libexpat.so\"")))
             #t)))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
                         ("expat" ,expat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaIO/LibExpat.jl")
    (synopsis "Julia interface to the Expat XML parser library")
    (description "Run XPath queries on fully parsed XML tree.")
    (license license:expat)))

(define-public julia-iteratorinterfaceextensions
  (package
    (name "julia-iteratorinterfaceextensions")
    (version "1.0.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url
              "https://github.com/queryverse/IteratorInterfaceExtensions.jl")
             (commit (string-append "v" version))))
       (file-name "IteratorInterfaceExtensions")
       (sha256
        (base32 "1slpay1dhja8f9gy6z7b3psgvgcknn963dvfqqakvg1grk9ppa09"))))
    (build-system julia-build-system)
    (home-page "https://github.com/queryverse/IteratorInterfaceExtensions.jl")
    (synopsis "@code{IteratorInterfaceExtensions} defines a small number of
extensions to the iterator interface")
    (description "@code{IteratorInterfaceExtensions} is a Julia package that
adds @code{isiterable} and @code{getiterator} to the iterator interface.")
    (license license:expat)))

(define-public julia-tabletraits
  (package
    (name "julia-tabletraits")
    (version "1.0.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/queryverse/TableTraits.jl")
             (commit (string-append "v" version))))
       (file-name "TableTraits")
       (sha256
        (base32 "0lzb9xqnhgjbvkscc4p9vw3pzajm3a5a6ayv6byqc53ws8fxqk2v"))))
    (propagated-inputs `(("julia-iteratorinterfaceextensions"
                          ,julia-iteratorinterfaceextensions)))
    (build-system julia-build-system)
    (home-page "https://github.com/queryverse/TableTraits.jl")
    (synopsis "Traits for julia tables")
    (description "@code{TableTraits} defines a generic interface for tabular
data.")
    (license license:expat)))

(define-public julia-dataapi
  (package
    (name "julia-dataapi")
    (version "1.1.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaData/DataAPI.jl")
             (commit (string-append "v" version))))
       (file-name "DataAPI")
       (sha256
        (base32 "0zl9vwkwcd2zar7vn9mhdwysyzkkfmq4ls5cmfs2nqzlfv4bzwbx"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaData/DataAPI.jl")
    (synopsis "Data-focused namespace for packages to share functions")
    (description "This Julia package provides a namespace for data-related
generic function definitions to solve the optional dependency problem;
packages wishing to share and/or extend functions can avoid depending directly
on each other by moving the function definition to @code{DataAPI.jl} and each
package taking a dependency on it.  As such, it is paramount for
@code{DataAPI.jl} to be as minimal as possible, defining only generic function
stubs and very little else.")
    (license license:expat)))

(define-public julia-datavalues
  (package
    (name "julia-datavalues")
    (version "0.4.12")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/queryverse/DataValues.jl")
             (commit (string-append "v" version))))
       (file-name "DataValues")
       (sha256
        (base32 "1x0si392psc6drc1x9vnzln4ai4y483n639yd7wqkn5h1nsxaa1c"))))
    (propagated-inputs `(("julia-datavalueinterfaces"
                          ,julia-datavalueinterfaces)))
    ;; FIXME: Tests are failing and I do not have a clue on why.
    ;; Like: isequal(DataValue{Float64}(5211.46), DataValue{Float64}(5211.46))
    ;; this seems to be fine to me, but it failes.
    (arguments '(#:tests? #f))
    (build-system julia-build-system)
    (home-page "https://github.com/queryverse/DataValues.jl")
    (synopsis "Missing values for Julia")
    (description "This package provides the type DataValue that is used to
represent missing data.")
    (license license:expat)))

(define-public julia-datavalueinterfaces
  (package
    (name "julia-datavalueinterfaces")
    (version "1.0.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/queryverse/DataValueInterfaces.jl")
             (commit (string-append "v" version))))
       (file-name "DataValueInterfaces")
       (sha256
        (base32 "0g2wj6q7jj956nx6g7dk8x7w1c4l2xcmnr1kq5x8s8fild9kslg8"))))
    (build-system julia-build-system)
    (home-page "https://github.com/queryverse/DataValueInterfaces.jl")
    (synopsis "Forward definitions for @code{Datavalues.jl}")
    (description "This package allows a few forward definitions for the
@code{DataValues.jl} package that other packages can utilize for integration
without having to take direct dependencies.")
    (license license:expat)))

(define-public julia-tables
  (package
    (name "julia-tables")
    (version "0.2.11")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaData/Tables.jl")
             (commit (string-append "v" version))))
       (file-name "Tables")
       (sha256
        (base32 "1ccvc0nicvy3yjmn7jnny2d357pzrs12qcf52qfxvb33k851zl8m"))))
    (propagated-inputs
     `(("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)
       ("julia-tabletraits" ,julia-tabletraits)
       ("julia-dataapi" ,julia-dataapi)
       ("julia-datavalueinterfaces" ,julia-datavalueinterfaces)))
    (native-inputs `(("julia-datavalues" ,julia-datavalues)
                     ("julia-queryoperators" ,julia-queryoperators)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaData/Tables.jl")
    (synopsis "Interface for tables in Julia")
    (description "The @code{Tables.jl} package provides simple, yet powerful
interface functions for working with all kinds tabular data through
predictable access patterns.")
    (license license:expat)))

(define-public julia-missings
  (package
    (name "julia-missings")
    (version "0.4.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaData/Missings.jl")
             (commit (string-append "v" version))))
       (file-name "Missings")
       (sha256
        (base32 "1y77c9kml708hp3hq0w7yv6qfd2s53s1108bbpfb841y5nrwxnk8"))))
    (propagated-inputs `(("julia-dataapi" ,julia-dataapi)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaData/Missings.jl")
    (synopsis "Missing value support for Julia")
    (description "Convenience functions for working with missing values in
Julia.")
    (license license:expat)))

(define-public julia-sortingalgorithms
  (package
    (name "julia-sortingalgorithms")
    (version "0.3.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaCollections/SortingAlgorithms.jl")
             (commit (string-append "v" version))))
       (file-name "SortingAlgorithms")
       (sha256
        (base32 "1nz96sccgl6h6aknck59gmy1yrzx356kk9z68svj2g6yialprv1j"))))
    (propagated-inputs `(("julia-datastructures" ,julia-datastructures)))
    ;; (inputs `(("julia-statsbase" ,julia-statsbase)))
    (arguments
     `(#:tests? #f                      ;circular dependency
       #:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "SortingAlgorithms"
              "a2af1166-a08f-5f64-846c-94a0d3cef48c"
              "0.3.1"
              '(("DataStructures" . "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8")))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaCollections/SortingAlgorithms.jl")
    (synopsis "Extra sorting algorithms extending Julia's sorting API")
    (description "The SortingAlgorithms package provides three sorting
algorithms that can be used with Julia's standard sorting API:
@enumerate
@item HeapSort
@item TimSort
@item RadixSort
@end enumerate")
    (license license:expat)))

(define-public julia-statsbase
  (package
    (name "julia-statsbase")
    (version "0.32.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaStats/StatsBase.jl")
             (commit "b9454f979ff8bdbc3ecffe2490cc1331a824e798")))
       (file-name "StatsBase")
       (sha256
        (base32 "1k6zcblpdrdq568lsgna83ld2kj47h2cxn5idp8g41fdm9scph5b"))))
    (propagated-inputs `(("julia-datastructures" ,julia-datastructures)
                         ("julia-sortingalgorithms" ,julia-sortingalgorithms)
                         ("julia-missings" ,julia-missings)
                         ("julia-dataapi" ,julia-dataapi)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaStats/StatsBase.jl")
    (synopsis "Basic statistics for Julia")
    (description "@code{StatsBase.jl} is a Julia package that provides basic
support for statistics.  Particularly, it implements a variety of
statistics-related functions, such as scalar statistics, high-order moment
computation, counting, ranking, covariances, sampling, and empirical density
estimation.")
    (license license:expat)))

(define-public julia-reexport
  (package
    (name "julia-reexport")
    (version "0.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/simonster/Reexport.jl")
             (commit "258a4088bb77ee4821bf2da1c73fd6e4897fd43c")))
       (file-name "Reexport")
       (sha256
        (base32 "0h8pfqwz0g0gywcsr5f7s3z6g7q0mmlb2ynki2nn16r8x4i074nx"))))
    (build-system julia-build-system)
    (home-page "https://github.com/simonster/Reexport.jl")
    (synopsis "Julia macro for re-exporting one module from another")
    (description "@code{Reexport.jl} re-exports symbols defined in another
module from your module, until this functionality is built into Julia.")
    (license license:expat)))

(define-public julia-invertedindices
  (package
    (name "julia-invertedindices")
    (version "1.0.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/mbauman/InvertedIndices.jl")
             (commit (string-append "v" version))))
       (file-name "InvertedIndices")
       (sha256
        (base32 "1179z20yxnkyziip7gn26wr1g3k3ssl1ci7pig3khc900f62di46"))))
    (native-inputs `(("julia-offsetarrays" ,julia-offsetarrays)))
    (build-system julia-build-system)
    (home-page "https://github.com/mbauman/InvertedIndices.jl")
    (synopsis "Simple index type that allows for inverted selections")
    (description "This very small package just exports one type: the
InvertedIndex, or Not for short.  It can wrap any supported index type and may
be used as an index into any AbstractArray subtype, including OffsetArrays.")
    (license license:expat)))

(define-public julia-pooledarrays
  (package
    (name "julia-pooledarrays")
    (version "0.5.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaData/PooledArrays.jl")
             (commit (string-append "v" version))))
       (file-name "PooledArrays")
       (sha256
        (base32 "0sdn965bb93api43dj8dsd32lp3yyh53mp22xr0vfj115x3ym2wj"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaData/PooledArrays.jl")
    (synopsis "Pooled representation of arrays for compression when few
elements are unique")
    (description "This julia package provides a pooled representation of
arrays for purposes of compression when there are few unique elements.")
    (license license:expat)))

(define-public julia-categoricalarrays
  (package
    (name "julia-categoricalarrays")
    (version "0.7.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaData/CategoricalArrays.jl")
             (commit (string-append "v" version))))
       (file-name "CategoricalArrays")
       (sha256
        (base32 "0g12q1gkzm9xc3d6hs8r155p8nnp2hdyghd68vzf9gmqysdn2851"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
                         ("julia-missings" ,julia-missings)
                         ("julia-dataapi" ,julia-dataapi)
                         ("julia-reexport" ,julia-reexport)
                         ("julia-json" ,julia-json)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaData/CategoricalArrays.jl")
    (synopsis "Arrays for working with categorical data (both nominal and
ordinal)")
    (description "This package provides tools for working with categorical
variables, both with unordered (nominal variables) and ordered
categories (ordinal variables), optionally with missing values.")
    (license license:expat)))

(define-public julia-latexstrings
  (package
    (name "julia-latexstrings")
    (version "1.0.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/stevengj/LaTeXStrings.jl")
             (commit (string-append "v" version))))
       (file-name "LaTeXStrings")
       (sha256
        (base32 "07nm5fgz1ksyfh5a2hijr7p4gs08jj3jcn6dir3ihcn6vrvrzjgq"))))
    ;; (arguments
    ;;  `(#:phases
    ;;    (modify-phases %standard-phases
    ;;      (add-before 'precompile 'fix-toml
    ;;        (lambda* (#:key outputs source #:allow-other-keys)
    ;;          (julia-create-package-toml
    ;;           outputs source
    ;;           "LaTeXStrings"
    ;;           "FIXMEE"
    ;;           "1.0.3"
    ;;           '(("Compat" . "34da2185-b29b-5c13-b0c7-acf172513d20")))
    ;;          #t)))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/stevengj/LaTeXStrings.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-dataframes
  (package
    (name "julia-dataframes")
    (version "0.19.4")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaData/DataFrames.jl")
             (commit (string-append "v" version))))
       (file-name "DataFrames")
       (sha256
        (base32 "0400bhrxyz4z9xzqypayzra9xdk84frv76rz7s8p834i1v7ldmkk"))))
    (propagated-inputs
     `(("julia-tables" ,julia-tables)
       ("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)
       ("julia-tabletraits" ,julia-tabletraits)
       ("julia-missings" ,julia-missings)
       ("julia-categoricalarrays" ,julia-categoricalarrays)
       ("julia-invertedindices" ,julia-invertedindices)
       ("julia-compat" ,julia-compat)
       ("julia-pooledarrays" ,julia-pooledarrays)
       ("julia-sortingalgorithms" ,julia-sortingalgorithms)
       ("julia-reexport" ,julia-reexport)
       ("julia-dataapi" ,julia-dataapi)
       ("julia-parsers" ,julia-parsers)))
    (native-inputs `(("julia-latexstrings" ,julia-latexstrings)
                     ("julia-datavalues" ,julia-datavalues)))
    (arguments '(#:tests? #f))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaData/DataFrames.jl")
    (synopsis "In-memory tabular data in Julia")
    (description "Tools for working with tabular data in Julia.")
    (license license:expat)))

(define-public julia-tokenize
  (package
    (name "julia-tokenize")
    (version "0.5.6")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaLang/Tokenize.jl")
             (commit (string-append "v" version))))
       (file-name "Tokenize")
       (sha256
        (base32 "1i05y9wvy5lii082bsn6qqs65nc9lvhw3mvl6jqmpdm5xqxw5mrg"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaLang/Tokenize.jl")
    (synopsis "Tokenization for Julia source code")
    (description "@code{Tokenize.jl} is a Julia package that serves a similar
purpose and API as the tokenize module in Python but for Julia.  This is to
take a string or buffer containing Julia code, perform lexical analysis and
return a stream of tokens.

The goals of this package is to be:
@enumerate
@item Fast
@item Round trippable
@item Non error throwing
@end enumerate
")
    (license license:expat)))

(define-public julia-cstparser
  (package
    (name "julia-cstparser")
    (version "0.6.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/julia-vscode/CSTParser.jl")
             ;; tests fixed after 0.6.2 release
             (commit "b816e3683dcf5369c7868fb8bf932005bcdd286f")))
       (file-name "CSTParser")
       (sha256
        (base32 "0sji2yk0wicm3nvwdcify2pn9qsim6139qqyl98ijyd7zqjlx35j"))))
    (propagated-inputs `(("julia-tokenize" ,julia-tokenize)))
    (build-system julia-build-system)
    (home-page "https://github.com/julia-vscode/CSTParser.jl")
    (synopsis "Concrete syntax tree parser for Julia")
    (description "Parser for Julia using Tokenize that aims to extend the
built-in parser by providing additional meta information along with the
resultant AST.")
    (license license:expat)))

(define-public julia-macrotools
  (package
    (name "julia-macrotools")
    (version "0.5.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/MikeInnes/MacroTools.jl")
             (commit (string-append "v" version))))
       (file-name "MacroTools")
       (sha256
        (base32 "0sspp8na3cj7pni1b3dqzzpv2mkzln4f5w0n0wrh2jvn8rz1fjjx"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
                         ("julia-tokenize" ,julia-tokenize)
                         ("julia-datastructures" ,julia-datastructures)
                         ("julia-cstparser" ,julia-cstparser)))
    (build-system julia-build-system)
    (home-page "https://mikeinnes.github.io/MacroTools.jl/stable/")
    (synopsis "MacroTools provides a library for working with Julia code and
expressions")
    (description "MacroTools provides a library of tools for working with
Julia code and expressions.  This includes a powerful template-matching system
and code-walking tools that let you do deep transformations of code in a few
lines.")
    (license license:expat)))

(define-public julia-lazy
  (package
    (name "julia-lazy")
    (version "0.14.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/MikeInnes/Lazy.jl")
             (commit (string-append "v" version))))
       (file-name "Lazy")
       (sha256
        (base32 "18ywj35yjcskrk7iy3w1aw7a8y1gqm20si9wdig6m7a6718479yr"))))
    (propagated-inputs `(("julia-macrotools" ,julia-macrotools)
                         ("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/MikeInnes/Lazy.jl")
    (synopsis "Lazy evaluated lists in Julia")
    (description "@code{Lazy.jl} provides Julia with the cornerstones of
functional programming - lazily-evaluated lists and a large library of
functions for working with them.")
    (license license:expat)))

(define-public julia-hiccup
  (package
    (name "julia-hiccup")
    (version "0.2.2")
    (source
     (origin
       (method git-fetch)
       (uri
        (git-reference
         (url "https://github.com/JunoLab/Hiccup.jl")
         (commit
          (string-append "v" version))))
       (file-name "Hiccup")
       (sha256
        (base32 "0m6my7d48658x4v0glv1006f0yvqd49f875b74q7kq3y6a9sxy5z"))))
    (propagated-inputs
     `(("julia-macrotools" ,julia-macrotools)
       ("julia-orderedcollections" ,julia-orderedcollections)
       ("julia-lazy" ,julia-lazy)))
    (build-system julia-build-system)
    (home-page "https://github.com/JunoLab/Hiccup.jl")
    (synopsis "Super-simple library designed to make making HTML easy in
Julia")
    (description "HTML Domain Specific Language for Julia, inspired by
Clojure's Hiccup DSL.")
    (license license:expat)))

(define-public julia-requires
  (package
    (name "julia-requires")
    (version "0.5.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/MikeInnes/Requires.jl")
             (commit "b2319cd875118c8da8ca099bcd733246ede13628")))
       (file-name "Requires")
       (sha256
        (base32 "00ksdsdgn8pdr9v7263pdmnqmp14pmn6qpf0bvi8n0g59f2nibi9"))))
    (propagated-inputs `(("julia-macrotools" ,julia-macrotools)))
    (native-inputs `(("julia-colors" ,julia-colors)))
    (build-system julia-build-system)
    (home-page "https://github.com/MikeInnes/Requires.jl")
    (synopsis "Lazy code loading for Julia")
    (description "Requires is a Julia package that will magically make loading
packages faster, maybe.  It supports specifying glue code in packages which
will load automatically when a another package is loaded, so that explicit
dependencies (and long load times) can be avoided.")
    (license license:expat)))

(define-public julia-websockets
  (package
    (name "julia-websockets")
    (version "1.5.2")
    (arguments '(#:tests? #f)) ;; freezes?
    (source
     (origin
       (method git-fetch)
       (uri
        (git-reference
         (url "https://github.com/JuliaWeb/WebSockets.jl")
         (commit
          (string-append "v" version))))
       (file-name "WebSockets")
       (sha256
        (base32 "1fpvskbax88x059lwnl211ps13j8s2jf97agwwr69sir11i0xh51"))))
    (propagated-inputs
     `(("julia-http" ,julia-http)
       ("julia-requires" ,julia-requires)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaWeb/WebSockets.jl")
    (synopsis "WebSockets library for Julia")
    (description "Server and client side Websockets protocol in Julia.
WebSockets is a small overhead message protocol layered over TCP.  It uses
HTTP(S) for establishing the connections.")
    (license license:expat)))

(define-public julia-pidfile
  (package
    (name "julia-pidfile")
    (version "1.1.0")
    (source
     (origin
       (method git-fetch)
       (uri
        (git-reference
         (url "https://github.com/vtjnash/Pidfile.jl")
         ;; Project.toml added after 1.1.0 release
         (commit "b7c9060ad7fc57c9c1341d8a87392e25580b6b71")))
       (file-name "Pidfile")
       (sha256
        (base32 "11pml7ls8dsipbcmngsqgdfwsdza9xjmy1974i5kiik7skhv860x"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (arguments '(#:tests? #f)) ;; freezes?
    (build-system julia-build-system)
    (home-page "https://vtjnash.github.io/Pidfile.jl/")
    (synopsis "Utility for creating advisory pidfiles (lock files)")
    (description "Simple utility tool for creating advisory pidfiles (lock
files).")
    (license license:expat)))

(define-public julia-assetregistry
  (package
    (name "julia-assetregistry")
    (version "0.1.0")
    (source
     (origin
       (method git-fetch)
       (uri
        (git-reference
         (url "https://github.com/JuliaGizmos/AssetRegistry.jl")
         (commit
          (string-append "v" version))))
       (file-name "AssetRegistry")
       (sha256
        (base32 "0xpldj08apvblgng6vndb9311gl6xxbk1f9jha8a661p2zfj0r4b"))))
    (propagated-inputs
     `(("julia-json" ,julia-json)
       ("julia-sha" ,julia-sha)
       ("julia-pidfile" ,julia-pidfile)))
    (build-system julia-build-system)
    (arguments
     `(#:tests? #f
       #:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda*
               (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "AssetRegistry"
              "bf4720bc-e11a-5d0c-854e-bdca1663c893"
              "0.1.0"
              '(("SHA" . "ea8e919c-243c-51af-8825-aaa63cd721ce")
                ("JSON" . "682c06a0-de6a-54ab-a142-c8b1cf79cde6")
                ("Pidfile" . "fa939f87-e72e-5be4-a000-7fc836dbe307")))
             #t)))))
    (home-page "https://github.com/JuliaGizmos/AssetRegistry.jl")
    (synopsis "Serve arbitrary files and folders using a global registry")
    (description "AssetRegistry allows you to serve arbitrary files and
folders, using a global registry.  Now packages like Mux and IJulia can look up
this registry and serve these files while packages like WebIO and InteractBase
can register assets to be served to implement web-based UIs.")
    (license license:expat)))

(define-public julia-mux
  (package
    (name "julia-mux")
    (version "0.7.0")
    (source
     (origin
       (method git-fetch)
       (uri
        (git-reference
         (url "https://github.com/JuliaWeb/Mux.jl")
         (commit
          (string-append "v" version))))
       (file-name "Mux")
       (sha256
        (base32 "1wmgh9iji0smx6vkn9y1kiylgci1ay0jrb968b61h6grwk9gxvlj"))))
    (propagated-inputs
     `(("julia-http" ,julia-http)
       ("julia-hiccup" ,julia-hiccup)
       ("julia-lazy" ,julia-lazy)
       ("julia-websockets" ,julia-websockets)
       ("julia-assetregistry" ,julia-assetregistry)
       ("julia-parsers" ,julia-parsers)
       ("julia-tokenize" ,julia-tokenize)
       ("julia-datastructures" ,julia-datastructures)
       ("julia-cstparser" ,julia-cstparser)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaWeb/Mux.jl")
    (synopsis "Middleware for Julia")
    (description "@code{Mux.jl} gives your Julia web services some closure.
Mux allows you to define servers in terms of highly modular and composable
components called middleware, with the aim of making both simple and complex
servers as simple as possible to throw together.")
    (license license:expat)))

(define-public julia-mustache
  (package
    (name "julia-mustache")
    (version "0.5.13")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/jverzani/Mustache.jl")
             (commit (string-append "v" version))))
       (file-name "Mustache")
       (sha256
        (base32 "02dnn8vjr9byzgs0x637053p6dkywq2jc3k5aanvrqs1pkhcrqyd"))))
    (propagated-inputs `(("julia-tables" ,julia-tables)))
    (build-system julia-build-system)
    (home-page "https://github.com/jverzani/Mustache.jl")
    (synopsis "Port of Mustache.js to Julia")
    (description "Logic-less template syntax.  It can be used for HTML,
config files, source code - anything.  It works by expanding tags in a
template using values provided in a hash or object.")
    (license license:expat)))

(define-public julia-nanmath
  (package
    (name "julia-nanmath")
    (version "0.3.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/mlubin/NaNMath.jl")
             (commit (string-append "v" version))))
       (file-name "NaNMath")
       (sha256
        (base32 "17cp9fnz8ydl684dkkqbsgi4c6xkd9skwrjyscawns9c1fhnzl2l"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "NaNMath"
              "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
              "0.3.2"
              '(("Compat" . "34da2185-b29b-5c13-b0c7-acf172513d20")))
             #t)))))
    (home-page "https://github.com/mlubin/NaNMath.jl")
    (synopsis "Julia math builtins which return NaN and accumulator functions
which ignore NaN")
    (description "Implementations of basic math functions which return NaN
instead of throwing a DomainError.")
    (license license:expat)))

(define-public julia-measures
  (package
    (name "julia-measures")
    (version "0.3.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGraphics/Measures.jl")
             (commit (string-append "v" version))))
       (file-name "Measures")
       (sha256
        (base32 "020yf4a7wmm0jhkpzxgz4bif2l4l0zmrzagz0gc2hrvnz0kp9m3b"))))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "Measures"
              "442fdcdd-2543-5da2-b0f3-8c86c306513e"
              "0.3.0"
              '())
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGraphics/Measures.jl")
    (synopsis "Unified measure and coordinates types")
    (description "This library generalizes and unifies the notion of measures
used in @code{Compose}, @code{Compose3D}, and @code{Escher}.  It allows
building up and representing expressions involving differing types of units
that are then evaluated, resolving them into absolute units.")
    (license license:expat)))

(define-public julia-colortypes
  (package
    (name "julia-colortypes")
    (version "0.8.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGraphics/ColorTypes.jl")
             (commit (string-append "v" version))))
       (file-name "ColorTypes")
       (sha256
        (base32 "0yskbz6598aaa36502jzq59aqqy0daxcrcxcmhk6jnbb5a1psr95"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
                         ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGraphics/ColorTypes.jl")
    (synopsis "Basic color definitions and traits")
    (description "This \"minimalistic\" package serves as the foundation for
working with colors in Julia.  It defines basic color types and their
constructors, and sets up traits and show methods to make them easier to work
with.")
    (license license:expat)))

(define-public julia-jld2
  (package
    (name "julia-jld2")
    (version "0.1.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaIO/JLD2.jl")
             (commit (string-append "v" version))))
       (file-name "JLD2")
       (sha256
        (base32 "0sb7mlnwsa5slcjszrf2jxijxbw1y80m08gdc6gxr586a1xg8vyj"))))
    (propagated-inputs `(("julia-codeczlib" ,julia-codeczlib)
                         ("julia-fileio" ,julia-fileio)
                         ("julia-datastructures" ,julia-datastructures)
                         ("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaIO/JLD2.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-colors
  (package
    (name "julia-colors")
    (version "0.9.6")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGraphics/Colors.jl")
             (commit (string-append "v" version))))
       (file-name "Colors")
       (sha256
        (base32 "1q2plh4iv3xqw7dd8xv4hshiv5xsg4d7dpd58y6zpip1fhpxpgrp"))))
    (propagated-inputs `(("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
                         ("julia-colortypes" ,julia-colortypes)
                         ("julia-reexport" ,julia-reexport)))
    (native-inputs `(("julia-jld2" ,julia-jld2)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGraphics/Colors.jl")
    (synopsis "Color manipulation utilities for Julia")
    (description "This library provides a wide array of functions for dealing
with color.  This includes conversion between colorspaces, measuring distance
between colors, simulating color blindness, parsing colors, and generating
color scales for graphics.")
    (license license:expat)))

(define-public julia-plotutils
  (package
    (name "julia-plotutils")
    (version "0.6.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaPlots/PlotUtils.jl")
             (commit (string-append "v" version))))
       (file-name "PlotUtils")
       (sha256
        (base32 "0g91ap8pw7ipp3fsy0xkh357czhmrvpdfi77hnj3lyjrrvbjc8sh"))))
    (propagated-inputs `(("julia-colors" ,julia-colors)
                         ("julia-reexport" ,julia-reexport)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPlots/PlotUtils.jl")
    (synopsis "Generic helper algorithms for building plotting components")
    (description "@code{PlotUtils.jl} is a julia package that provides helper
algorithms for building plotting components.")
    (license license:expat)))

(define-public julia-staticarrays
  (package
    (name "julia-staticarrays")
    (version "0.11.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaArrays/StaticArrays.jl")
             (commit (string-append "v" version))))
       (file-name "StaticArrays")
       (sha256
        (base32 "1v18yh6g0abg51mna0si2b0wbp28q6slxafrv2sxvjnaams79y3f"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/StaticArrays.jl")
    (synopsis "Statically sized arrays for Julia")
    (description "@code{StaticArrays} provides a framework for implementing
statically sized arrays in Julia, using the abstract type
@code{StaticArray{Size,T,N} <: AbstractArray{T,N}}.  Subtypes of StaticArray
will provide fast implementations of common array and linear algebra
operations.  Note that here \"statically sized\" means that the size can be
determined from the type, and \"static\" does not necessarily imply
immutable.")
    (license license:expat)))

(define-public julia-contour
  (package
    (name "julia-contour")
    (version "0.5.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGeometry/Contour.jl")
             (commit (string-append "v" version))))
       (file-name "Contour")
       (sha256
        (base32 "0l7zi2xshyv81xlp1szm47f6200lnhfylfdrsk7g0xiajr81acpd"))))
    (propagated-inputs `(("julia-staticarrays" ,julia-staticarrays)))
    (build-system julia-build-system)
    (home-page "https://juliageometry.github.io/Contour.jl/stable/")
    (synopsis "Calculating contour curves for 2D scalar fields in Julia")
    (description "Generic implementation of the marching squares algorithm for
tracing contour curves on a scalar 2D field.")
    (license license:expat)))

(define-public julia-itertools
  (package
    (name "julia-itertools")
    (version "1.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaCollections/IterTools.jl")
             (commit (string-append "v" version))))
       (file-name "IterTools")
       (sha256
        (base32 "1iq08xpj1gb2wz2hx7g177clxnxcwlma12dj240xnk7q0g623hbv"))))
    (build-system julia-build-system)
    (home-page "https://juliacollections.github.io/IterTools.jl/stable/")
    (synopsis "Common functional iterator patterns")
    (description "This Julia package provides common functional iterator
patterns like @code{nth}, @code{takenth}, @code{groupby}.")
    (license license:expat)))

(define-public julia-geometrytypes
  (package
    (name "julia-geometrytypes")
    (version "0.7.6")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGeometry/GeometryTypes.jl")
             (commit "9294dcba10e7fbb4b6f504b6c56d3fcbc3bc5ca7")))
       (file-name "GeometryTypes")
       (sha256
        (base32 "1skg4rx0a0ripm68ahj926xsqyd7zqkqlqij02l16n0x1k1cvbj4"))))
    (propagated-inputs `(("julia-staticarrays" ,julia-staticarrays)
                         ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
                         ("julia-itertools" ,julia-itertools)
                         ("julia-colortypes" ,julia-colortypes)))
    (build-system julia-build-system)
    (home-page "https://juliageometry.github.io/GeometryTypes.jl/stable/")
    (synopsis "Geometry types for Julia")
    (description "Geometry primitives and operations building up on
FixedSizeArrays.")
    (license license:expat)))

(define-public julia-gr
  (package
    (name "julia-gr")
    (version "0.41.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/jheinen/GR.jl")
             (commit (string-append "v" version))))
       (file-name "GR")
       (sha256
        (base32 "0ciklxny3g3j87z00xf2hlshiy7h5zbdcf9fpwhb8xy6qci61rd1"))))
    (propagated-inputs `(("gr" ,gr)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda*
               (#:key outputs source inputs #:allow-other-keys)
             (substitute*
                 (string-append (assoc-ref outputs "out")
                                "/share/julia/packages/"
                                (strip-store-file-name source) "/src/GR.jl")
               (("const libGR = \"libGR.so\"")
                (string-append "const libGR = \""
                               (assoc-ref inputs "gr")
                               "/lib/libGR.so\""))
               (("const libGR3 = \"libGR3.so\"")
                (string-append "const libGR3 = \""
                               (assoc-ref inputs "gr")
                               "/lib/libGR3.so\""))
               ((" = grdir")
                (string-append " = \""
                               (assoc-ref inputs "gr")
                               "\"")))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/jheinen/GR.jl")
    (synopsis "Plotting for Julia based on GR, a framework for visualisation
applications")
    (description "This Julia package provides an interface to the GR
visualization framework.")
    (license license:expat)))

(define-public julia-plotthemes
  (package
    (name "julia-plotthemes")
    (version "0.4.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaPlots/PlotThemes.jl")
             (commit (string-append "v" version))))
       (file-name "PlotThemes")
       (sha256
        (base32 "0q6s3bwds1k1xcryj0y33l6lw0bl9kj6ljd0ph7rii445b7a9sk4"))))
    (propagated-inputs `(("julia-plotutils" ,julia-plotutils)
                         ("julia-requires" ,julia-requires)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPlots/PlotThemes.jl")
    (synopsis "PlotThemes is a package to spice up the plots made with
@code{Plots.jl}")
    (description "Custom plotting themes for @code{Plots.jl}, including both
light and dark themes.")
    (license license:expat)))

(define-public julia-ffmpeg
  (package
    (name "julia-ffmpeg")
    (version "0.2.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaIO/FFMPEG.jl")
             (commit (string-append "v" version))))
       (file-name "FFMPEG")
       (sha256
        (base32 "1rnb7n5gzn7bsiz09fqapw4fcqc1p5bjcjw4ha3kxcs70w4by52x"))))
    (arguments
     `(#:tests? #f                       ; missing libdl import, can be fixed
       #:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (let ((f (open-file
                       (string-append
                        (assoc-ref outputs "out")
                        "/share/julia/packages/"
                        (string-append
                         (strip-store-file-name source) "/deps/deps.jl"))
                       "w")))
               (display (string-append "const libavcodec = \""
                                       (assoc-ref inputs "ffmpeg")
                                       "/lib/libavcodec.so\"\n") f)
               (display (string-append "const libavformat = \""
                                       (assoc-ref inputs "ffmpeg")
                                       "/lib/libavformat.so\"\n") f)
               (display (string-append "const libavcodec = \""
                                       (assoc-ref inputs "ffmpeg")
                                       "/lib/libavcodec.so\"\n") f)
               (display (string-append "const libavutil = \""
                                       (assoc-ref inputs "ffmpeg")
                                       "/lib/libavutil.so\"\n") f)
               (display (string-append "const libswscale = \""
                                       (assoc-ref inputs "ffmpeg")
                                       "/lib/libswscale.so\"\n") f)
               (display (string-append "const libavdevice = \""
                                       (assoc-ref inputs "ffmpeg")
                                       "/lib/libavdevice.so\"\n") f)
               (display (string-append "const libavfilter = \""
                                       (assoc-ref inputs "ffmpeg")
                                       "/lib/libavfilter.so\"\n") f)
               (display (string-append "const ffmpeg = \""
                                       (assoc-ref inputs "ffmpeg")
                                       "/bin/ffmpeg\"\n") f)
               (close-port f))
             (substitute*
                 (string-append (assoc-ref
                                 outputs "out") "/share/julia/packages/"
                                 (string-append (strip-store-file-name
                                                 source) "/src/FFMPEG.jl"))
               (("const libpath = joinpath(@__DIR__, \"..\", \"deps\", \"usr\", \"lib\")")
                (string-append "const libpath = \""
                               (assoc-ref inputs "ffmpeg")
                               "/lib")))
             #t)))))
    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
                         ("ffmpeg" ,ffmpeg)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaIO/FFMPEG.jl")
    (synopsis "Wrapper for the ffmpeg executable in Julia")
    (description "Low level ffmpeg API used to get ffmpeg binaries and
executables.")
    (license license:expat)))

(define-public julia-recipesbase
  (package
    (name "julia-recipesbase")
    (version "0.7.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaPlots/RecipesBase.jl")
             (commit (string-append "v" version))))
       (file-name "RecipesBase")
       (sha256
        (base32 "18dkzvnx6jcqvjaqx592bbxv5wgsl75japq56ij2s8p6gc868lvs"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPlots/RecipesBase.jl")
    (synopsis "Base package for defining transformation recipes on user types
for Plots.jl")
    (description "This package implements handy macros @code{@@recipe} and
@code{@@series} which will define a custom transformation and attach attributes
for user types.  Its design is an attempt to simplify and generalize the
summary and display of types and data from external packages.  With no extra
dependencies and minimal code, package authors can describe visualization
routines that can be used as components in more complex visualizations.")
    (license license:expat)))

(define-public julia-showoff
  (package
    (name "julia-showoff")
    (version "0.2.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGraphics/Showoff.jl")
             (commit "8502c2ec11f93c4f50c609ff4168aab31154b39d")))
       (file-name "Showoff")
       (sha256
        (base32 "10iydva8vqlfv4i5jw31q9pc7877syd0bfz2djg93xdy90l4c617"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGraphics/Showoff.jl")
    (synopsis "Nicely format an array of n things for tables and plots")
    (description "Showoff provides an interface for consistently formatting an
array of n things, e.g. numbers, dates, unitful values.")
    (license license:expat)))

(define-public julia-plots
  (package
    (name "julia-plots")
    (version "0.27.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaPlots/Plots.jl")
             (commit (string-append "v" version))))
       (file-name "Plots")
       (sha256
        (base32 "0cqg464g9wd2chgn4jjb7ylp0f6kk3hbvhzm2i2530qw2z9aaky6"))))
    (propagated-inputs `(("julia-reexport" ,julia-reexport)
                         ("julia-json" ,julia-json)
                         ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
                         ("julia-nanmath" ,julia-nanmath)
                         ("julia-statsbase" ,julia-statsbase)
                         ("julia-measures" ,julia-measures)
                         ("julia-plotutils" ,julia-plotutils)
                         ("julia-contour" ,julia-contour)
                         ("julia-requires" ,julia-requires)
                         ("julia-geometrytypes" ,julia-geometrytypes)
                         ("julia-plotthemes" ,julia-plotthemes)
                         ("julia-gr" ,julia-gr)
                         ("julia-ffmpeg" ,julia-ffmpeg)
                         ("julia-recipesbase" ,julia-recipesbase)
                         ("julia-showoff" ,julia-showoff)))
    (native-inputs `(("julia-imagemagick" ,julia-imagemagick)))
    (build-system julia-build-system)
    (home-page "http://docs.juliaplots.org/latest/")
    (synopsis "Powerful convenience for Julia visualizations and data analysis")
    (description "Plots is a plotting API and toolset.  My goals with the
package are:
@enumerate
@item @strong{Powerful}.  Do more with less.  Complex visualizations become easy
@item @strong{Intuitive}.  Stop reading so much documentation
@item @strong{Concise}.  Less code means fewer mistakes
@item @strong{Flexible}.  Produce your favorite plots from your favorite package
@item @strong{Consistent}.  Don't commit to one graphics package
@item @strong{Lightweight}.  Very few dependencies
@item @strong{Smart}.  Attempts to figure out what you want it to do
@end enumerate")
    (license license:expat)))

(define-public julia-codetracking
  (package
    (name "julia-codetracking")
    (version "0.5.8")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/timholy/CodeTracking.jl")
             (commit (string-append "v" version))))
       (file-name "CodeTracking")
       (sha256
        (base32 "0w1kwhzmvn5snxj28l7syx1f3hzdd03zb6fni7xx29ghccp00zww"))))
    (arguments '(#:tests? #f))
    (build-system julia-build-system)
    (home-page "https://github.com/timholy/CodeTracking.jl")
    (synopsis "It's editing-time, do you know where your methods are?")
    (description "@code{CodeTracking} is a minimal package designed to work
with @code{Revise.jl}.  Its main purpose is to support packages that need to
interact with code that might move around as it gets edited.")
    (license license:expat)))

(define-public julia-juliainterpreter
  (package
    (name "julia-juliainterpreter")
    (version "0.7.4")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaDebug/JuliaInterpreter.jl")
             (commit (string-append "v" version))))
       (file-name "JuliaInterpreter")
       (sha256
        (base32 "0j4rp2wd5vqgz7ggnzyr0whvsqy8nmpngfwl1pfx2p22p2r4anbm"))))
    (propagated-inputs `(("julia-codetracking" ,julia-codetracking)))
    (native-inputs `(("julia-tensors" ,julia-tensors)))
    (build-system julia-build-system)
    (home-page "https://juliadebug.github.io/JuliaInterpreter.jl/stable/")
    (synopsis "Interpreter for Julia code")
    (description "This package implements an interpreter for Julia
code.  Normally, Julia compiles your code when you first execute it; using
JuliaInterpreter you can avoid compilation and execute the expressions that
define your code directly.  Interpreters have a number of applications,
including support for stepping debuggers.")
    (license license:expat)))

(define-public julia-loweredcodeutils
  (package
    (name "julia-loweredcodeutils")
    (version "0.3.8")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaDebug/LoweredCodeUtils.jl")
             (commit (string-append "v" version))))
       (file-name "LoweredCodeUtils")
       (sha256
        (base32 "00kyn5javyylkdpd8cmv9qifgh7yw0klskf5wvq4ab9jadfjq6za"))))
    (propagated-inputs `(("julia-juliainterpreter" ,julia-juliainterpreter)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaDebug/LoweredCodeUtils.jl")
    (synopsis "Tools for manipulating Julia's lowered code")
    (description "This package performs operations on Julia's lowered AST.")
    (license license:expat)))

(define-public julia-revise
  (package
    (name "julia-revise")
    (version "2.2.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/timholy/Revise.jl")
             (commit (string-append "v" version))))
       (file-name "Revise")
       (sha256
        (base32 "0x7739m2i0qzhhx85kdxgma62m86fzxjzay1spp3dp0vdwr65d0d"))))
    (propagated-inputs
     `(("julia-codetracking" ,julia-codetracking)
       ("julia-loweredcodeutils" ,julia-loweredcodeutils)
       ("julia-juliainterpreter" ,julia-juliainterpreter)
       ("julia-orderedcollections" ,julia-orderedcollections)))
    (build-system julia-build-system)
    (home-page "https://timholy.github.io/Revise.jl/stable/")
    (synopsis "Automatically update function definitions in a running Julia
session")
    (description "@code{Revise.jl} allows you to modify code and use the changes
without restarting Julia.  With Revise, you can be in the middle of a session
and then update packages, switch git branches, and/or edit the source code in
the editor of your choice; any changes will typically be incorporated into the
very next command you issue from the REPL.  This can save you the overhead of
restarting Julia, loading packages, and waiting for code to JIT-compile.")
    (license license:expat)))

(define-public julia-tabletraitsutils
  (package
    (name "julia-tabletraitsutils")
    (version "1.0.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/queryverse/TableTraitsUtils.jl")
             (commit (string-append "v" version))))
       (file-name "TableTraitsUtils")
       (sha256
        (base32 "0axmrznfmii7c909mcgr2zpzlddj62j1dhnss6d2gl9ar5mw5cl9"))))
    (propagated-inputs `(("julia-datavalues" ,julia-datavalues)
                         ("julia-tabletraits" ,julia-tabletraits)
                         ("julia-missings" ,julia-missings)
                         ("julia-iteratorinterfaceextensions"
                          ,julia-iteratorinterfaceextensions)))
    (build-system julia-build-system)
    (home-page "https://github.com/queryverse/TableTraitsUtils.jl")
    (synopsis "Utilities for implementing the @code{TableTraits.jl}
interfaces")
    (description "@code{TableTraitsUtils.jl} provides default implementations
of the TableTraits.jl interface.")
    (license license:expat)))

(define-public julia-iterabletables
  (package
    (name "julia-iterabletables")
    (version "0.11.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/queryverse/IterableTables.jl")
             (commit "2683c006134613131c1f747c0f0fa40ec6e49bf0")))
       (file-name "IterableTables")
       (sha256
        (base32 "1ifhlvrq16nki11pa6sqys9fna0v91659snp0x0y2sb1q2y2lv4g"))))
    (propagated-inputs
     `(("julia-datavalues" ,julia-datavalues)
       ("julia-requires" ,julia-requires)
       ("julia-tabletraits" ,julia-tabletraits)
       ("julia-tabletraitsutils" ,julia-tabletraitsutils)
       ("julia-iteratorinterfaceextensions"
        ,julia-iteratorinterfaceextensions)))
    (native-inputs
     `(("julia-dataframes" ,julia-dataframes)
       ("julia-statsmodels" ,julia-statsmodels)
       ("julia-statsmodels" ,julia-glm)))
    ;; requires timeseries
    (arguments '(#:tests? #f))
    (build-system julia-build-system)
    (home-page "https://github.com/queryverse/IterableTables.jl")
    (synopsis "Implementations of the @code{TableTraits.jl} interface for
various packages")
    (description "Iterable tables is a generic interface for tabular data.  A
large number of packages are compatible with this interface.")
    (license license:expat)))

(define-public julia-tableshowutils
  (package
    (name "julia-tableshowutils")
    (version "0.2.5")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/queryverse/TableShowUtils.jl")
             (commit "0515a2cc615d55c2c5412e8d84740ea01fa4f7aa")))
       (file-name "TableShowUtils")
       (sha256
        (base32 "1mbniba5llf4f0k57wwd2a0i5c77d1sry66xaz9h9w5b2lhx7cdy"))))
    (propagated-inputs `(("julia-json" ,julia-json)
                         ("julia-datavalues" ,julia-datavalues)))
    (build-system julia-build-system)
    (home-page "https://github.com/queryverse/TableShowUtils.jl")
    (synopsis "Package that provides helpers for implementing show for
TableTraits.jl types")
    (description "This package provides some common helper functions that make
it easier to implement various @code{Base.show} functions for types that
participate in the TableTraits.jl ecosystem.  Most users will probably not
have any direct use for this package.")
    (license license:expat)))

(define-public julia-queryoperators
  (package
    (name "julia-queryoperators")
    (version "0.9.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/queryverse/QueryOperators.jl")
             (commit (string-append "v" version))))
       (file-name "QueryOperators")
       (sha256
        (base32 "0phia28rwz49bdiyakpag3isnk9wiqmzigfcnyb42mymx65x8841"))))
    (propagated-inputs `(("julia-datavalues" ,julia-datavalues)
                         ("julia-datastructures" ,julia-datastructures)
                         ("julia-tableshowutils" ,julia-tableshowutils)
                         ("julia-iteratorinterfaceextensions"
                          ,julia-iteratorinterfaceextensions)))
    (build-system julia-build-system)
    (home-page "https://github.com/queryverse/QueryOperators.jl")
    (synopsis "This package contains the query operators that are exposed to
in Query.jl")
    (description "This package contains the underlying query operators that
are exposed to users in @code{Query.jl}.")
    (license license:expat)))

(define-public julia-query
  (package
    (name "julia-query")
    (version "0.12.1")
    (source
     (origin
       (method git-fetch)
       (uri
        (git-reference
         (url "https://github.com/queryverse/Query.jl")
         (commit
          (string-append "v" version))))
       (file-name "Query")
       (sha256
        (base32 "0pcc03f3vlx1i2llbv3jc8h0hc91jsf66lnrzaibz9ifm0lyda9r"))))
    (propagated-inputs
     `(("julia-macrotools" ,julia-macrotools)
       ("julia-queryoperators" ,julia-queryoperators)
       ("julia-iterabletables" ,julia-iterabletables)
       ("julia-datavalues" ,julia-datavalues)))
    (build-system julia-build-system)
    (home-page "https://github.com/queryverse/Query.jl")
    (synopsis "Query almost anything in julia")
    (description "Query is a package for querying julia data sources.  It can
filter, project, join and group data from any iterable data source, including
all the sources supported in @code{IterableTables.jl}.")
    (license license:expat)))

(define-public julia-fileio
  (package
    (name "julia-fileio")
    (version "1.0.7")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaIO/FileIO.jl")
             (commit (string-append "v" version))))
       (file-name "FileIO")
       (sha256
        (base32 "0dwsklxzc4nhsii9hhjp1h3cbf9n5abipj44jf3i0zncid06aanv"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaIO/FileIO.jl")
    (synopsis "Main Package for IO, loading all different kind of files")
    (description "FileIO aims to provide a common framework for detecting file
formats and dispatching to appropriate readers/writers.  The two core
functions in this package are called @code{load} and @code{save}, and offer
high-level support for formatted files (in contrast with julia's low-level
read and write).  To avoid name conflicts, packages that provide support for
standard file formats through functions named load and save are encouraged to
extend the definitions here.")
    (license license:expat)))

(define-public julia-nullables
  (package
    (name "julia-nullables")
    (version "0.0.8")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaAttic/Nullables.jl")
             (commit (string-append "v" version))))
       (file-name "Nullables")
       (sha256
        (base32 "00mdnk5hrl04wyw7g8dwybnxzn2wh0l52pa7398l3wggak2iqx1b"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda*
               (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "Nullables"
              "4d1e1d77-625e-5b40-9113-a560ec7a8ecd"
              "0.0.8"
              '(("Compat" . "34da2185-b29b-5c13-b0c7-acf172513d20")))
             #t)))))
    (home-page "https://github.com/JuliaAttic/Nullables.jl")
    (synopsis "Nullable type for Julia")
    (description "This package provides the Nullable type from Julia.  It also
defines the unsafe_get and isnull functions, and all methods previously
implemented in Julia Base: @code{get}, @code{eltype}, @code{convert},
@code{promote}, @code{show}, @code{map}, @code{broadcast}, @code{filter},
@code{isequal}, @code{isless} and @code{hash}.")
    (license license:expat)))

(define-public julia-specialfunctions
  (package
    (name "julia-specialfunctions")
    (version "0.8.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/SpecialFunctions.jl")
             (commit (string-append "v" version))))
       (file-name "SpecialFunctions")
       (sha256
        (base32 "05kz4x06wcp785ivy8v6z69qcfxsjw86npf52xjic9a8rnnlcqj4"))))
    (propagated-inputs `(("julia-bindeps" ,julia-bindeps)
                         ("julia-binaryprovider" ,julia-binaryprovider)
                         ("openspecfun" ,openspecfun)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (let ((f (open-file
                       (string-append
                        (assoc-ref outputs "out")
                        "/share/julia/packages/"
                        (string-append
                         (strip-store-file-name source) "/deps/deps.jl"))
                       "w")))
               (display (string-append "const openspecfun = \""
                                       (assoc-ref inputs "openspecfun")
                                       "/lib/libopenspecfun.so\"\n") f)
               (display "check_deps() = true\n" f)
               (close-port f))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://juliamath.github.io/SpecialFunctions.jl/stable/")
    (synopsis "Special mathematical functions in Julia")
    (description "Special mathematical functions in Julia, including Bessel,
Hankel, Airy, error, Dawson, sine and cosine integrals, eta, zeta, digamma,
inverse digamma, trigamma, and polygamma functions.  Most of these functions
were formerly part of Base in early versions of Julia.")
    (license license:expat)))

;; FIXME: Might require binary!
(define-public julia-quadmath
  (package
    (name "julia-quadmath")
    (version "0.5.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/Quadmath.jl")
             (commit (string-append "v" version))))
       (file-name "Quadmath")
       (sha256
        (base32 "0gq0zxkqwv9z8w0635zcp86q7q67vgc91b6f4xrr3miq2fiy44q3"))))
    (propagated-inputs `(("julia-requires" ,julia-requires)
                         ("julia-specialfunctions" ,julia-specialfunctions)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaMath/Quadmath.jl")
    (synopsis "Float128 and libquadmath for the Julia language")
    (description "This is a Julia interface to libquadmath, providing a
Float128 type corresponding to the IEEE754 binary128 floating point format.")
    (license license:expat)))

(define-public julia-genericschur
  (package
    (name "julia-genericschur")
    (version "0.3.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/RalphAS/GenericSchur.jl")
             (commit (string-append "v" version))))
       (file-name "GenericSchur")
       (sha256
        (base32 "1hr8zkanbrysqzr61rwhbv1a306zfcfrjjw96whrxy7fm4qf9j6v"))))
    ;; Tests are using functions not exported in system lapack like:
    ;; dlatme_, slatme_, zlatmr_, dlatmr_...  according to lapack
    ;; documentation those functions are used to test lapack programs.  In
    ;; GenericSchur, They are used only inside tests. Maybe lapack can be
    ;; fixed to include those?
    (arguments '(#:tests? #f))
    (build-system julia-build-system)
    (home-page "https://github.com/RalphAS/GenericSchur.jl")
    (synopsis "Julia package for Schur decomposition of matrices with
generic element types")
    (description "Schur decomposition for matrices of generic element types
in Julia.  The Schur decomposition is the workhorse for eigensystem analysis
of dense non-symmetric matrices.")
    (license license:expat)))

(define-public julia-genericsvd
  (package
    (name "julia-genericsvd")
    (version "0.2.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaLinearAlgebra/GenericSVD.jl")
             (commit (string-append "v" version))))
       (file-name "GenericSVD")
       (sha256
        (base32 "1qhyyls9m1k8hwf7fhkbd0ksn2r50n4l25f0v6gahjah5yqdz6bq"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (native-inputs `(("julia-quaternions" ,julia-quaternions)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaLinearAlgebra/GenericSVD.jl")
    (synopsis "Singular Value Decomposition for generic number types")
    (description "Implements Singular Value Decomposition for generic
number types, such as BigFloat, Complex{BigFloat} or Quaternions.  It
internally overloads several Base functions such that existing methods (svd,
svdfact and svdvals) should work directly.")
    (license license:expat)))

(define-public julia-polynomials
  (package
    (name "julia-polynomials")
    (version "0.5.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/Polynomials.jl")
             (commit (string-append "v" version))))
       (file-name "Polynomials")
       (sha256
        (base32 "1ax4q27fkl1w12by159wbzk7wvyb6c2jayg5kvhgpdq9g500pidw"))))
    (propagated-inputs `(("julia-recipesbase" ,julia-recipesbase)))
    (native-inputs `(("julia-specialfunctions" ,julia-specialfunctions)))
    (build-system julia-build-system)
    (home-page "https://juliamath.github.io/Polynomials.jl/stable/")
    (synopsis "Polynomial manipulations in Julia")
    (description "Basic arithmetic, integration, differentiation, evaluation,
and root finding over dense univariate polynomials.")
    (license license:expat)))

(define-public julia-doublefloats
  (package
    (name "julia-doublefloats")
    (version "0.9.13")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/DoubleFloats.jl")
             (commit (string-append "v" version))))
       (file-name "DoubleFloats")
       (sha256
        (base32 "0h4644y5hqppf426dw3c1j8bpbv3mq3c9500as8fqk11c5f075ah"))))
    (propagated-inputs `(("julia-quadmath" ,julia-quadmath)
                         ("julia-requires" ,julia-requires)
                         ("julia-polynomials" ,julia-polynomials)
                         ("julia-genericschur" ,julia-genericschur)
                         ("julia-genericsvd" ,julia-genericsvd)))
    (arguments '(#:tests? #f))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaMath/DoubleFloats.jl")
    (synopsis "Math with more good bits")
    (description "Julia math with 85+ accurate bits.  Extended precision float
and complex types.")
    (license license:expat)))

(define-public julia-weakrefstrings
  (package
    (name "julia-weakrefstrings")
    (version "0.6.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaData/WeakRefStrings.jl")
             (commit (string-append "v" version))))
       (file-name "WeakRefStrings")
       (sha256
        (base32 "00sfqhw2niarfmpn8i3dmv5dfhyj3bylvwp4yrq77b560g997khh"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaData/WeakRefStrings.jl")
    (synopsis "String type for Julia that allows efficient string
representation and transfer")
    (description "Minimal String type for Julia that allows for efficient
string representation and transfer.")
    (license license:expat)))

(define-public julia-textparse
  (package
    (name "julia-textparse")
    (version "0.9.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaComputing/TextParse.jl")
             (commit (string-append "v" version))))
       (file-name "TextParse")
       (sha256
        (base32 "1vzmn4gfhicif5vhzz0h3mv1qgpsmjfq4rz7rhbmkdqbwjfphfw2"))))
    (propagated-inputs `(("julia-nullables" ,julia-nullables)
                         ("julia-codeczlib" ,julia-codeczlib)
                         ("julia-doublefloats" ,julia-doublefloats)
                         ("julia-weakrefstrings" ,julia-weakrefstrings)
                         ("julia-pooledarrays" ,julia-pooledarrays)
                         ("julia-datastructures" ,julia-datastructures)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaComputing/TextParse.jl")
    (synopsis "Fast text parsing tools")
    (description "TextParse uses Julia's generated functions to generate
efficient specialized parsers for text files.  Parsing packages can use
TextParse as a framework for implementing parsers for other formats.")
    (license license:expat)))

(define-public julia-csvfiles
  (package
    (name "julia-csvfiles")
    (version "0.16.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/queryverse/CSVFiles.jl")
             (commit (string-append "v" version))))
       (file-name "CSVFiles")
       (sha256
        (base32 "09g045lfc1cszp5lc6l5p12y9qlhrx894s5vd88wy5cmic4250jl"))))
    (propagated-inputs
     `(("julia-codeczlib" ,julia-codeczlib)
       ("julia-iterabletables" ,julia-iterabletables)
       ("julia-fileio" ,julia-fileio)
       ("julia-textparse" ,julia-textparse)
       ("julia-datavalues" ,julia-datavalues)
       ("julia-tabletraitsutils" ,julia-tabletraitsutils)
       ("julia-tabletraits" ,julia-tabletraits)
       ("julia-tableshowutils" ,julia-tableshowutils)
       ("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)
       ("julia-http" ,julia-http)))
    (arguments '(#:tests? #f))
    (build-system julia-build-system)
    (home-page "https://github.com/queryverse/CSVFiles.jl")
    (synopsis "FileIO.jl integration for CSV files")
    (description "This package provides load and save support for CSV Files
under the @code{FileIO.jl} package.")
    (license license:expat)))

(define-public julia-abstracttrees
  (package
    (name "julia-abstracttrees")
    (version "0.2.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/Keno/AbstractTrees.jl")
             (commit (string-append "v" version))))
       (file-name "AbstractTrees")
       (sha256
        (base32 "0w05zar1hlyqqx7zlzh05h78mjs9vsgaifn5z390crrhb1bgw4bj"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/Keno/AbstractTrees.jl")
    (synopsis "Abstract julia interfaces for working with trees")
    (description "This package provides several utilities for working with
tree-like data structures.  Most importantly, it defines the children method
that any package that contains such a datastructure may import and extend in
order to take advantage of any generic tree algorithm in this package (or
other packages compatible with this package).")
    (license license:expat)))

(define-public julia-gumbo
  (package
    (name "julia-gumbo")
    (version "0.5.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaWeb/Gumbo.jl")
             (commit (string-append "v" version))))
       (file-name "Gumbo")
       (sha256
        (base32 "1wsdrqz3jj684paanmpla9kvpdcv7sbsw2967kljykvb4plvsx95"))))
    (propagated-inputs `(("julia-sha" ,julia-sha)
                         ("julia-abstracttrees" ,julia-abstracttrees)
                         ("julia-binaryprovider" ,julia-binaryprovider)
                         ("julia-compat" ,julia-compat)
                         ("gumbo-parser", gumbo-parser)))
    (build-system julia-build-system)
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (let ((f (open-file
                       (string-append
                        (assoc-ref outputs "out")
                        "/share/julia/packages/"
                        (string-append
                         (strip-store-file-name source) "/deps/deps.jl"))
                       "w")))
               (display (string-append "const libgumbo = \""
                                       (assoc-ref inputs "gumbo-parser")
                                       "/lib/libgumbo.so\"\n") f)
               (close-port f))
             #t)))))
    (home-page "https://github.com/JuliaWeb/Gumbo.jl")
    (synopsis "Julia wrapper around Google's gumbo C library for parsing
HTML")
    (description "@code{Gumbo.jl} is a Julia wrapper around Google's gumbo
library for parsing HTML.")
    (license license:expat)))

(define-public julia-cascadia
  (package
    (name "julia-cascadia")
    (version "0.4.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/Algocircle/Cascadia.jl")
             (commit (string-append "v" version))))
       (file-name "Cascadia")
       (sha256
        (base32 "0jfz2p94y9l62fa6si9hfb7czhj26i9n1p7gzb9vz1x32v2q2gdp"))))
    (propagated-inputs `(("julia-gumbo" ,julia-gumbo)
                         ("julia-abstracttrees" ,julia-abstracttrees)))
    (build-system julia-build-system)
    (home-page "https://github.com/Algocircle/Cascadia.jl")
    (synopsis "CSS Selector library in Julia")
    (description "A CSS Selector library in Julia, inspired by, and mostly a
direct translation of, the Cascadia CSS Selector library, written in Go,")
    (license license:expat)))

(define-public julia-graphics
  (package
    (name "julia-graphics")
    (version "0.4.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGraphics/Graphics.jl")
             (commit (string-append "v" version))))
       (file-name "Graphics")
       (sha256
        (base32 "03d98j49fn7zkhxki5n1b1br9p9hs380dpdp0a480m7yh1c45091"))))
    (propagated-inputs `(("julia-colors" ,julia-colors)
                         ("julia-nanmath" ,julia-nanmath)
                         ("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "Graphics"
              "a2bd30eb-e257-5431-a919-1863eab51364"
              "0.4.0"
              '(("Compat" . "34da2185-b29b-5c13-b0c7-acf172513d20")
                ("Colors" . "5ae59095-9a9b-59fe-a467-6f913c188581")
                ("NaNMath" . "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3")))
             #t)))))
    (home-page "https://github.com/JuliaGraphics/Graphics.jl")
    (synopsis "Holding place for Julia Base graphics")
    (description "Holding place for Julia Base graphics.")
    (license license:expat)))

(define-public julia-cairo
  (package
    (name "julia-cairo")
    (version "0.8.0")
    (source
     (origin
       (method git-fetch)
       (uri
        (git-reference
         (url "https://github.com/JuliaGraphics/Cairo.jl")
         (commit
          (string-append "v" version))))
       (file-name "Cairo")
       (sha256
        (base32 "1z69qd91cl90nac0m9dyf48k0r4qylck6xaql7z4bkfmxrgiv7g5"))))
    (propagated-inputs
     `(("julia-graphics" ,julia-graphics)
       ("julia-colors" ,julia-colors)
       ("julia-bindeps" ,julia-bindeps)
       ("glib" ,glib)
       ("cairo" ,cairo)
       ("pango" ,pango)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda*
               (#:key outputs source inputs #:allow-other-keys)
             (let
                 ((f (open-file (string-append
                                 (assoc-ref outputs "out")
                                 "/share/julia/packages/"
                                 (strip-store-file-name source)
                                 "/deps/deps.jl") "w")))
               (display
                (string-append "const libcairo = \""
                               (assoc-ref inputs "cairo")
                               "/lib/libcairo.so\"\n") f)
               (display
                (string-append "const libpango = \""
                               (assoc-ref inputs "pango")
                               "/lib/libpango-1.0.so\"\n") f)
               (display
                (string-append "const libpangocairo = \""
                               (assoc-ref inputs "pango")
                               "/lib/libpangocairo-1.0.so\"\n") f)
               (display
                (string-append "const libpangoft = \""
                               (assoc-ref inputs "pango")
                               "/lib/libpangoft2-1.0.so\"\n") f)
               (display
                (string-append "const libgobject = \""
                               (assoc-ref inputs "glib")
                               "/lib/libgobject-2.0.so\"\n") f)
               (display "check_deps() = true\n" f)
               (close-port f))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGraphics/Cairo.jl")
    (synopsis "Bindings to the Cairo graphics library")
    (description "Julia adaptation to Cairo, a 2D graphics library with
support for multiple output devices.")
    (license license:expat)))

(define-public julia-gtk
  (package
    (name "julia-gtk")
    (version "0.18.0")
    (source
     (origin
       (method git-fetch)
       (uri
        (git-reference
         (url "https://github.com/JuliaGraphics/Gtk.jl")
         (commit
          (string-append "v" version))))
       (file-name "Gtk")
       (sha256
        (base32 "17a6kwpnhivsxi19dbd97a531sk343aam0bc5hyj2wnn830wd7bs"))))
    (propagated-inputs
     `(("julia-bindeps" ,julia-bindeps)
       ("julia-cairo" ,julia-cairo)
       ("julia-reexport" ,julia-reexport)
       ("julia-compat" ,julia-compat)
       ("julia-graphics" ,julia-graphics)
       ("glib" ,glib)
       ("gtk+" ,gtk+)
       ("gdk-pixbuf" ,gdk-pixbuf)))
    (build-system julia-build-system)
    (arguments
     `(#:tests? #f ;; tries to open display
       #:phases
       (modify-phases %standard-phases
         ;; Precompilation tries to open display
         (delete 'precompile)
         (add-after 'install 'build-deps
           (lambda*
               (#:key outputs source inputs #:allow-other-keys)
             (substitute*
                 (string-append
                  (assoc-ref outputs "out")
                  "/share/julia/packages/"
                  (string-append
                   (strip-store-file-name source)
                   "/deps/ext_glib.jl"))
               (("\"libgobject-2.0\"")
                (string-append "\""
                               (assoc-ref inputs "glib")
                               "/lib/libgobject-2.0.so\""))
               (("\"libglib-2.0\"")
                (string-append "\""
                               (assoc-ref inputs "glib")
                               "/lib/libglib-2.0.so\"")))
             (substitute*
                 (string-append
                  (assoc-ref outputs "out")
                  "/share/julia/packages/"
                  (string-append
                   (strip-store-file-name source)
                   "/deps/ext.jl"))
               (("\"libgtk-3\"")
                (string-append "\""
                               (assoc-ref inputs "gtk+")
                               "/lib/libgtk-3.so\""))
               (("\"libgdk-3\"")
                (string-append "\""
                               (assoc-ref inputs "gtk+")
                               "/lib/libgtk-3.so\""))
               (("\"libgdk_pixbuf-2.0\"")
                (string-append "\""
                               (assoc-ref inputs "gdk-pixbuf")
                               "/lib/libgdk_pixbuf-2.0.so\""))
               (("\"libgio-2.0\"")
                (string-append "\""
                               (assoc-ref inputs "glib")
                               "/lib/libgio-2.0.so\"")))
             #t)))))
    (home-page "https://juliagraphics.github.io/Gtk.jl/latest/")
    (synopsis "Julia interface to Gtk windowing toolkit")
    (description "Julia interface to Gtk+2 and Gtk+3 GUI Library.")
    (license license:expat)))

(define-public julia-formatting
  (package
    (name "julia-formatting")
    (version "0.4.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaIO/Formatting.jl")
             (commit (string-append "v" version))))
       (file-name "Formatting")
       (sha256
        (base32 "1argq98ndj9wm5pdf31sshmzqihwk0mx8f3f9cslfs1qzwbc18p2"))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaIO/Formatting.jl")
    (synopsis "Julia package to provide Python-like formatting support")
    (description "This package offers Python-style general formatting and
c-style numerical formatting (for speed).")
    (license license:expat)))

(define-public julia-combinatorics
  (package
    (name "julia-combinatorics")
    (version "0.7.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/Combinatorics.jl")
             (commit (string-append "v" version))))
       (file-name "Combinatorics")
       (sha256
        (base32 "12xvm76b5wi5g1z5ka1qnyzy4yylx6ii8q6zjbjqvkryxgacnb5a"))))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "Combinatorics"
              "861a8166-3701-5b0c-9a16-15d98fcdc6aa"
              "0.7.0"
              '(("Polynomials" . "f27b6e38-b328-58d1-80ce-0feddd5e7a45")))
             #t)))))
    (propagated-inputs `(("julia-polynomials" ,julia-polynomials)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaMath/Combinatorics.jl")
    (synopsis "Combinatorics library for Julia")
    (description "A combinatorics library for Julia, focusing mostly on
enumerative combinatorics and permutations.  As overflows are expected even for
low values, most of the functions always return BigInt.")
    (license license:expat)))

(define-public julia-namedarrays
  (package
    (name "julia-namedarrays")
    (version "0.9.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/davidavdav/NamedArrays.jl")
             (commit (string-append "v" version))))
       (file-name "NamedArrays")
       (sha256
        (base32 "0b68myb5fiik18j4zmvgikd5v27chs7h5lm4fphgf02b4h6rb2b5"))))
    (propagated-inputs `(("julia-invertedindices" ,julia-invertedindices)
                         ("julia-combinatorics" ,julia-combinatorics)
                         ("julia-requires" ,julia-requires)
                         ("julia-datastructures" ,julia-datastructures)))
    (build-system julia-build-system)
    (home-page "https://github.com/davidavdav/NamedArrays.jl")
    (synopsis "Julia type that implements a drop-in replacement of Array with
named dimensions")
    (description "Julia type that implements a drop-in wrapper for
AbstractArray type, providing named indices and dimensions.")
    (license license:expat)))

(define-public julia-freqtables
  (package
    (name "julia-freqtables")
    (version "0.3.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/nalimilan/FreqTables.jl")
             (commit "1bc6c71d52c1e866916ca27e4775d064368efeae")))
       (file-name "FreqTables")
       (sha256
        (base32 "1v3w2ml8kjsagc2vclx5apf427hvljd56pk63c68n1akzv0cbfgh"))))
    (propagated-inputs `(("julia-tables" ,julia-tables)
                         ("julia-namedarrays" ,julia-namedarrays)
                         ("julia-categoricalarrays" ,julia-categoricalarrays)))
    (build-system julia-build-system)
    (home-page "https://github.com/nalimilan/FreqTables.jl")
    (synopsis "Frequency tables in Julia")
    (description "This package allows computing one- or multi-way frequency
tables (a.k.a. contingency or pivot tables) from any type of vector or
array.  It includes support for CategoricalArray and DataFrame, as well as for
weighted counts.")
    (license license:expat)))

(define-public julia-quadgk
  (package
    (name "julia-quadgk")
    (version "2.1.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/QuadGK.jl")
             (commit (string-append "v" version))))
       (file-name "QuadGK")
       (sha256
        (base32 "16s8x0gdj8kj9hrhswh3p7s88xda2vbfks4pxgrrnr5vhncvppjw"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
                         ("julia-datastructures" ,julia-datastructures)))
    (build-system julia-build-system)
    (home-page "https://juliamath.github.io/QuadGK.jl/stable/")
    (synopsis "Adaptive 1d numerical Gauss–Kronrod integration in Julia")
    (description "This package provides support for one-dimensional numerical
integration in Julia using adaptive Gauss-Kronrod quadrature.  The code was
originally part of Base Julia.")
    (license license:expat)))

(define-public julia-arpack
  (package
    (name "julia-arpack")
    (version "0.3.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaLinearAlgebra/Arpack.jl")
             (commit (string-append "v" version))))
       (file-name "Arpack")
       (sha256
        (base32 "1sy69jzfwygnfzabbgxjyyy7bncg4769v0wmpbakghcsajxk9h9a"))))
    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)))
    (native-inputs `(("arpack-ng" ,arpack-ng)))
    (arguments
     `(#:tests? #f                      ;; FIXME: strange error?
       #:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (let ((f (open-file
                       (string-append
                        (assoc-ref outputs "out")
                        "/share/julia/packages/"
                        (strip-store-file-name source)
                        "/deps/deps.jl") "w")))
               (display (string-append "const libarpack = \""
                                       (assoc-ref inputs "arpack-ng")
                                       "/lib/libarpack.so\"\n") f)
               (close-port f))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://julialinearalgebra.github.io/Arpack.jl/stable/")
    (synopsis "Julia bindings for @code{ARPACK}")
    (description "This package provides bindings to @code{ARPACK}, which can
be used to perform iterative solutions for eigensystems (using eigs) or
singular value decompositions (using svds).")
    (license license:expat)))

(define-public julia-suitesparse
  (package
    (name "julia-suitesparse")
    (version "0.1.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaLinearAlgebra/SuiteSparse.jl")
             (commit (string-append "v" version))))
       (file-name "SuiteSparse")
       (sha256
        (base32 "0j1i6nxyc32bn9f7w68mmqh9p89f62zhi10lkvq1nqw6r299za4x"))))
    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)))
    (native-inputs `(("suitesparse" ,suitesparse)
                     ("suitesparse-wrapper" ,suitesparse-wrapper)))
    (arguments
     ;; srand
     `(#:tests? #f
       #:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (let ((f (open-file
                       (string-append
                        (assoc-ref outputs "out")
                        "/share/julia/packages/"
                        (strip-store-file-name source)
                        "/deps/deps.jl") "w"))
                   (suitesparse (assoc-ref inputs "suitesparse")))
               (map (lambda (lib)
                      (display
                       (string-append "const " lib "= \""
                                      suitesparse "/lib/" lib ".so\"\n") f))
                    '("libsuitesparseconfig"
                      "libamd" "libbtf" "libcamd"
                      "libccolamd" "libcolamd" "libcholmod"
                      "libldl" "libklu"
                      "libumfpack"
                      "librbio" "libspqr"))
               (display
                (string-append "const libsuitesparse_wrapper = \""
                               (assoc-ref inputs "suitesparse-wrapper")
                               "/lib/libsuitesparse_wrapper.so\"\n") f)
               (close-port f))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://julialinearalgebra.github.io/SuiteSparse.jl/latest/")
    (synopsis "SuiteSparse wrappers in Julia")
    (description "Julia Wrapper to the SuiteSparse library")
    (license license:expat)))

(define-public julia-pdmats
  (package
    (name "julia-pdmats")
    (version "0.9.10")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaStats/PDMats.jl")
             (commit (string-append "v" version))))
       (file-name "PDMats")
       (sha256
        (base32 "1zppgfvrc7qzclcib2dap38caab6mckqikmxzgf0adxfavpxm6b8"))))
    (propagated-inputs `(("julia-arpack" ,julia-arpack)
                         ("julia-suitesparse" ,julia-suitesparse)))
    (build-system julia-build-system)
    (arguments '(#:tests? #f))
    (home-page "https://github.com/JuliaStats/PDMats.jl")
    (synopsis "Uniform Interface for positive definite matrices of various structures")
    (description "Positive definite matrices are widely used in machine learning and probabilistic modeling, especially in applications related to graph analysis and Gaussian models.  It is not uncommon that positive definite matrices used in practice have special structures (e.g. diagonal), which can be exploited to accelerate computation.

PDMats.jl supports efficient computation on positive definite matrices of various structures.  In particular, it provides uniform interfaces to use positive definite matrices of various structures for writing generic algorithms, while ensuring that the most efficient implementation is used in actual computation.")
    (license license:expat)))

(define-public julia-abstractffts
  (package
    (name "julia-abstractffts")
    (version "0.4.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/AbstractFFTs.jl")
             (commit (string-append "v" version))))
       (file-name "AbstractFFTs")
       (sha256
        (base32 "1w1aybkfs941z6ifzh6d2b3m3a30da3xqvrqhv7d97gqhw4f6j9x"))))
    (build-system julia-build-system)
    (home-page "https://juliamath.github.io/AbstractFFTs.jl/stable/")
    (synopsis "Julia framework for implementing FFTs")
    (description "A general framework for fast Fourier transforms (FFTs) in Julia.")
    (license license:expat)))

(define-public julia-fftw
  (package
    (name "julia-fftw")
    (version "1.0.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/FFTW.jl")
             (commit (string-append "v" version))))
       (file-name "FFTW")
       (sha256
        (base32 "1sa5qvd3gskd0yl4kq4ics8gbb1jvcyn5r6mbqc0wi8q0dnvbwjy"))))
    (propagated-inputs `(("julia-arpack" ,julia-arpack)
                         ("julia-suitesparse" ,julia-suitesparse)
                         ("julia-reexport" ,julia-reexport)
                         ("julia-abstractffts" ,julia-abstractffts)))
    (native-inputs `(("fftw" ,fftw)
                     ("fftwf" ,fftwf)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (let ((f (open-file
                       (string-append
                        (assoc-ref outputs "out")
                        "/share/julia/packages/"
                        (strip-store-file-name source)
                        "/deps/deps.jl") "w")))
               (display
                (string-append "const libfftw3 = \""
                               (assoc-ref inputs "fftw")
                               "/lib/libfftw3_threads.so\"\n") f)
               (display
                (string-append "const libfftw3f = \""
                               (assoc-ref inputs "fftwf")
                               "/lib/libfftw3f_threads.so\"\n") f)
               (display
                (string-append "check_deps() = nothing\n") f)
               (close-port f))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://juliamath.github.io/FFTW.jl/stable/")
    (synopsis "Julia bindings to the FFTW library for fast Fourier transforms")
    (description "This package provides Julia bindings to the FFTW library for fast Fourier transforms (FFTs), as well as functionality useful for signal processing.")
    (license license:expat)))

(define-public julia-rmath
  (package
    (name "julia-rmath")
    (version "0.5.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaStats/Rmath.jl")
             (commit (string-append "v" version))))
       (file-name "Rmath")
       (sha256
        (base32 "1jzcq3l6p3wzjkjrnax2m3nlyrgnxp3g8m23p3jg1bxqpfdsxq33"))))
    (propagated-inputs `(("julia-specialfunctions" ,julia-specialfunctions)))
    (native-inputs `(("rmath" ,rmath-julia)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "Rmath"
              "79098fc4-a85e-5d69-aa6a-4863f24498fa"
              "0.5.0"
              '(("SpecialFunctions" . "276daf66-3868-5448-9aa4-cd146d93841b")
                ("Random" . "9a3f8284-a2c9-5f02-9a11-845980a1fd5c")))
             #t))
         (add-before 'precompile 'build-deps
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (let ((f (open-file
                       (string-append
                        (assoc-ref outputs "out")
                        "/share/julia/packages/"
                        (strip-store-file-name source)
                        "/deps/deps.jl") "w")))
               (display
                (string-append "const libRmath = \""
                               (assoc-ref inputs "rmath")
                               "/lib/libRmath-julia.so\"\n") f)
               (close-port f))
             #t)))))
    (build-system julia-build-system)
    (home-page "")
    (synopsis "Specifying, fitting, and evaluating statistical models in Julia")
    (description "This package provides common abstractions and utilities for specifying, fitting, and evaluating statistical models.")
    (license license:expat)))

(define-public julia-statsfuns
  (package
    (name "julia-statsfuns")
    (version "0.8.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaStats/StatsFuns.jl")
             (commit (string-append "v" version))))
       (file-name "StatsFuns")
       (sha256
        (base32 "1lrhkd4g5zywxnamcsg51ppyx2jwcrp66g7s58v8q3082py49385"))))
    (propagated-inputs `(("julia-specialfunctions" ,julia-specialfunctions)
                         ("julia-rmath" ,julia-rmath)))
    (arguments
     `(#:tests? #f
       #:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "StatsFuns"
              "4c63d2b9-4356-54db-8cca-17b64c39e42c"
              "0.8.0"
              '(("SpecialFunctions" . "276daf66-3868-5448-9aa4-cd146d93841b")
                ("Rmath" . "79098fc4-a85e-5d69-aa6a-4863f24498fa")))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaStats/StatsFuns.jl")
    (synopsis "Mathematical functions related to statistics")
    (description "This package provides a collection of mathematical constants
and numerical functions for statistical computing.")
    (license license:expat)))

(define-public julia-distributions
  (package
    (name "julia-distributions")
    (version "0.21.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaStats/Distributions.jl")
             (commit (string-append "v" version))))
       (file-name "Distributions")
       (sha256
        (base32 "1wsw6m5h36jm5j716zwmxk4bripsl2bi47555086rbc147sp854p"))))
    (propagated-inputs `(("julia-quadgk" ,julia-quadgk)
                         ("julia-pdmats" ,julia-pdmats)
                         ("julia-statsfuns" ,julia-statsfuns)
                         ("julia-specialfunctions" ,julia-specialfunctions)
                         ("julia-fftw" ,julia-fftw)
                         ("julia-statsbase" ,julia-statsbase)))
    (native-inputs `(("julia-json" ,julia-json)
                     ("julia-forwarddiff" ,julia-forwarddiff)
                     ("julia-calculus" ,julia-calculus)))
    (arguments '(#:tests? #f))          ; needs finitedifferences
    (build-system julia-build-system)
    (home-page "https://juliastats.github.io/Distributions.jl/stable/")
    (synopsis "Julia package for probability distributions and associated functions")
    (description "Julia package for probability distributions and associated functions.  Particularly, Distributions implements:
@enumerate
@item Moments (e.g mean, variance, skewness, kurtosis), entropy, and other properties
@item Probability density/mass functions (pdf) and their logarithm (logpdf)
@item Moment generating functions and characteristic functions
@item Sampling from population or from a distribution
@item Maximum likelihood estimation
@end enumerate")
    (license license:expat)))

(define-public julia-arrayinterface
  (package
    (name "julia-arrayinterface")
    (version "1.2.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaDiffEq/ArrayInterface.jl")
             (commit (string-append "v" version))))
       (file-name "ArrayInterface")
       (sha256
        (base32 "1gpwcbf0bfcmna8p6rrr43d6s35mbmx0qp3nwdhdqcmri7hs0l40"))))
    (arguments '(#:tests? #f))          ; recursive
    (propagated-inputs `(("julia-requires" ,julia-requires)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaDiffEq/ArrayInterface.jl")
    (synopsis "Designs for new Base array interface primitives
deeper nestings indices")
    (description "The purpose of this library is to solidify extensions to the
current AbstractArray interface which are put to use in package ecosystems
like @code{DifferentialEquations.jl}.")
    (license license:expat)))

(define-public julia-unitful
  (package
    (name "julia-unitful")
    (version "0.17.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/PainterQubits/Unitful.jl")
             (commit (string-append "v" version))))
       (file-name "Unitful")
       (sha256
        (base32 "1laar1qlm5j11b6ghgcahlm7q09gzvfrav3pdfwjdyqzd2dyj4pc"))))
    (build-system julia-build-system)
    (home-page "https://github.com/PainterQubits/Unitful.jl")
    (synopsis "")
    (description "")
    (license license:expat)))


(define-public julia-recursivearraytools
  (package
    (name "julia-recursivearraytools")
    (version "1.0.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaDiffEq/RecursiveArrayTools.jl")
             (commit (string-append "v" version))))
       (file-name "RecursiveArrayTools")
       (sha256
        (base32 "0jjk17ql11pp3k11vria0scm30bnjn2v8bzqys13ai7l308bmxk0"))))
    (propagated-inputs `(("julia-requires" ,julia-requires)
                         ("julia-recipesbase" ,julia-recipesbase)
                         ("julia-staticarrays" ,julia-staticarrays)
                         ("julia-arrayinterface" ,julia-arrayinterface)))
    (native-inputs `(("julia-unitful" ,julia-unitful)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/OffsetArrays.jl")
    (synopsis "Tools for easily handling objects like arrays of arrays and
deeper nestings indices")
    (description "@code{RecursiveArrayTools.jl} is a set of tools for dealing
with recursive arrays like arrays of arrays.")
    (license license:expat)))

(define-public julia-shiftedarrays
  (package
    (name "julia-shiftedarrays")
    (version "0.5.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/piever/ShiftedArrays.jl")
             (commit (string-append "v" version))))
       (file-name "ShiftedArrays")
       (sha256
        (base32 "1s3pjkrmp07icfymby44bwizb6kqgksyj6hqnpbq150l4fg08n0n"))))
    (propagated-inputs `(("julia-offsetarrays" ,julia-offsetarrays)
                         ("julia-recursivearraytools" ,julia-recursivearraytools)))
    (build-system julia-build-system)
    (arguments '(#:tests? #f))          ; does not find offsetarrays
    (home-page "")
    (synopsis "Lazy shifted arrays for data analysis in Julia")
    (description "This package implementats shifted arrays in Julia.  A
ShiftedArray is a lazy view of an Array, shifted on some or all of his
indexing dimensions by some constant values.")
    (license license:expat)))

(define-public julia-statsmodels
  (package
    (name "julia-statsmodels")
    (version "0.6.6")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaStats/StatsModels.jl")
             (commit (string-append "v" version))))
       (file-name "StatsModels")
       (sha256
        (base32 "07s4fv4vcr2ibgchxbmyqshw94z2aaifw460masz8alhb25x6p25"))))
    (propagated-inputs `(("julia-specialfunctions" ,julia-specialfunctions)
                         ("julia-datastructures" ,julia-datastructures)
                         ("julia-categoricalarrays" ,julia-categoricalarrays)
                         ("julia-shiftedarrays" ,julia-shiftedarrays)
                         ("julia-statsbase" ,julia-statsbase)
                         ("julia-tables" ,julia-tables)))
    (native-inputs `(("julia-dataframes" ,julia-dataframes)))
    (build-system julia-build-system)
    (home-page "https://juliastats.github.io/StatsModels.jl/stable/")
    (synopsis "Specifying, fitting, and evaluating statistical models in Julia")
    (description "This package provides common abstractions and utilities for specifying, fitting, and evaluating statistical models.")
    (license license:expat)))

(define-public julia-glm
  (package
    (name "julia-glm")
    (version "1.3.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaStats/GLM.jl")
             (commit (string-append "v" version))))
       (file-name "GLM")
       (sha256
        (base32 "027r8fil2qwjivdcgfpidkgvqb5gga6axxc77kf4vaj7ybvgp9zs"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
                         ("julia-distributions" ,julia-distributions)
                         ("julia-reexport" ,julia-reexport)
                         ("julia-specialfunctions" ,julia-specialfunctions)
                         ("julia-statsbase" ,julia-statsbase)
                         ("julia-statsfuns" ,julia-statsfuns)
                         ("julia-statsmodels" ,julia-statsmodels)))
    (arguments '(#:tests? #f))
    (build-system julia-build-system)
    (home-page "https://juliastats.github.io/GLM.jl/stable/")
    (synopsis "Generalized linear models in Julia")
    (description "Linear and generalized linear models in Julia.")
    (license license:expat)))

(define-public julia-namedcolors
  (package
    (name "julia-namedcolors")
    (version "0.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGraphics/NamedColors.jl")
             (commit (string-append "v" version))))
       (file-name "NamedColors")
       (sha256
        (base32 "13n68gdl51g7md0hfxs3ckpwb1ngvjwgngqcadg3dalir9q8ldyf"))))
    (propagated-inputs `(("julia-colortypes" ,julia-colortypes)
                         ("julia-colors" ,julia-colors)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGraphics/NamedColors.jl")
    (synopsis "More color names than you ever knew you wanted")
    (description "@code{Colors.jl} supports about 660 colors as named
colorants.  @code{NamedColors.jl} supports about 4,000.  Honestly, the named
colors in @code{Colors.jl}, and/or its capacity to generate good palettes, are
far more useful.")
    (license license:expat)))

(define-public julia-primes
  (package
    (name "julia-primes")
    (version "0.4.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/Primes.jl")
             ;; Project.toml added after 0.4.0 release
             (commit "187ec9e8ea5fdd358ccd6e8547d8e1f383335be9")))
       (file-name "Primes")
       (sha256
        (base32 "0ypfqzqmvc64x8pv1b7l1hqhfwy5b5zy3q0sk3xvs7ic13hdjncw"))))
    (build-system julia-build-system)
    (home-page "https://juliamath.github.io/Primes.jl/stable/")
    (synopsis "Prime numbers in Julia")
    (description "Julia functions for computing prime numbers.")
    (license license:expat)))

(define-public julia-abstractalgebra
  (package
    (name "julia-abstractalgebra")
    ;; 0.7.1 exists but is incompatible with julia-polynomialfactors
    (version "0.6.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/Nemocas/AbstractAlgebra.jl")
             (commit (string-append "v" version))))
       (file-name "AbstractAlgebra")
       (sha256
        (base32 "1xjx05p10lrx0v5b6jcwv8mbzk39p4fh4yvdj53r286bbry4lj52"))))
    (build-system julia-build-system)
    (home-page "https://nemocas.github.io/AbstractAlgebra.jl/stable/")
    (synopsis "Generic abstract algebra functionality in pure Julia (no C dependencies)")
    (description "AbstractAlgebra is a pure Julia package for computational
abstract algebra.  It grew out of the Nemo project and provides all of the
abstract types and generic implementations that Nemo relies on.")
    (license license:expat)))

(define-public julia-polynomialfactors
  (package
    (name "julia-polynomialfactors")
    (version "0.3.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/jverzani/PolynomialFactors.jl")
             (commit (string-append "v" version))))
       (file-name "PolynomialFactors")
       (sha256
        (base32 "1bpv1xx0k4kdybwr14gccjp2y1a0mh0zgmw7dd38i6aahpy9dpm4"))))
    (propagated-inputs `(("julia-combinatorics" ,julia-combinatorics)
                         ("julia-primes" ,julia-primes)
                         ("julia-abstractalgebra" ,julia-abstractalgebra)))
    (build-system julia-build-system)
    (home-page "https://github.com/jverzani/PolynomialFactors.jl")
    (synopsis "Julia code for factorization of polynomials over the integers")
    (description "A package for factoring polynomials with integer or rational
coefficients over the integers.")
    (license license:expat)))

(define-public julia-roots
  (package
    (name "julia-roots")
    (version "0.8.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/Roots.jl")
             (commit (string-append "v" version))))
       (file-name "Roots")
       (sha256
        (base32 "12cbzi3ni1j8w88y3nfxii9ypr82l16g08b9p349axdq98dzrvl4"))))
    (propagated-inputs `(("julia-polynomialfactors" ,julia-polynomialfactors)
                         ("julia-primes" ,julia-primes)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaMath/Roots.jl")
    (synopsis "Root finding functions for Julia")
    (description "This package contains simple routines for finding roots of
continuous scalar functions of a single real variable.  The find_zerofunction
provides the primary interface.  It supports various algorithms through the
specification of a method. ")
    (license license:expat)))

(define-public julia-hypothesistests
  (package
    (name "julia-hypothesistests")
    (version "0.8.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaStats/HypothesisTests.jl")
             (commit (string-append "v" version))))
       (file-name "HypothesisTests")
       (sha256
        (base32 "1srcsr6c64npirldsgcywlxw70vcb8hs19m27f23cgsmz7rj3ann"))))
    (propagated-inputs `(("julia-rmath" ,julia-rmath)
                         ("julia-statsbase" ,julia-statsbase)
                         ("julia-roots" ,julia-roots)
                         ("julia-distributions" ,julia-distributions)
                         ("julia-combinatorics" ,julia-combinatorics)))
    (build-system julia-build-system)
    (home-page "https://juliastats.github.io/HypothesisTests.jl/stable/")
    (synopsis "Hypothesis tests for Julia")
    (description "@code{HypothesisTests.jl} is a Julia package that implements
a wide range of hypothesis tests.")
    (license license:expat)))

(define-public julia-observables
  (package
    (name "julia-observables")
    (version "0.2.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGizmos/Observables.jl")
             (commit (string-append "v" version))))
       (file-name "Observables")
       (sha256
        (base32 "16qjjagaa6dvi3fhqyljhxg07r5cjz6d1h8yl38x3c11ilrvdy50"))))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "Observables"
              "510215fc-4207-5dde-b226-833fc4488ee2"
              "0.2.3" '())
             #t)))))
    (build-system julia-build-system)
    (home-page "https://juliagizmos.github.io/Observables.jl/stable/")
    (synopsis "Observables in Julia")
    (description "Observables are like @code{Refs} but you can listen to changes.")
    (license license:expat)))

;;; CONTINUE FROM HERE!
(define-public julia-widgets
  (package
    (name "julia-widgets")
    (version "0.6.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/piever/Widgets.jl")
             (commit (string-append "v" version))))
       (file-name "Widgets")
       (sha256
        (base32 "075hvnc79ig3ipi55gk313z62zwdhg3id5jh596icxfjxmyg05aj"))))
    (propagated-inputs `(("julia-observables" ,julia-observables)
                         ("julia-orderedcollections" ,julia-orderedcollections)
                         ("julia-colors" ,julia-colors)))
    (build-system julia-build-system)
    (home-page "https://github.com/piever/Widgets.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-woodburymatrices
  (package
    (name "julia-woodburymatrices")
    (version "0.4.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/timholy/WoodburyMatrices.jl")
             (commit (string-append "v" version))))
       (file-name "WoodburyMatrices")
       (sha256
        (base32 "1n15m02f65bczd00vaqd6q2n3614m0ar2z45dcsslxm9259m36ff"))))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "WoodburyMatrices"
              "efce3f68-66dc-5838-9240-27a6d6f5f9b6"
              "0.4.1"
              '(("LinearAlgebra" . "37e2e46d-f89d-539d-b4ee-838fcccc9c8e")
                ("SparseArrays" . "2f01184e-e22b-5df5-ae63-d93ebab69eaf")))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/timholy/WoodburyMatrices.jl")
    (synopsis "Support for the Woodbury matrix identity for Julia")
    (description "This package provides support for the Woodbury matrix
identity for the Julia programming language.  This is a generalization of the
Sherman-Morrison formula. Note that the Woodbury matrix identity is notorious
for floating-point roundoff errors, so be prepared for a certain amount of
inaccuracy in the result.")
    (license license:expat)))

(define-public julia-axisalgorithms
  (package
    (name "julia-axisalgorithms")
    (version "1.0.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/timholy/AxisAlgorithms.jl")
             (commit (string-append "v" version))))
       (file-name "AxisAlgorithms")
       (sha256
        (base32 "00x85lnfln7xkfnirpplzyi8r6q92nfqwya8il156bf7b1pa20gk"))))
    (propagated-inputs `(("julia-woodburymatrices" ,julia-woodburymatrices)
                         ("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/timholy/AxisAlgorithms.jl")
    (synopsis "Efficient filtering and linear algebra routines for
multidimensional arrays")
    (description "AxisAlgorithms is a collection of filtering and linear
algebra algorithms for multidimensional arrays.  For algorithms that would
typically apply along the columns of a matrix, you can instead pick an
arbitrary axis (dimension).")
    (license license:expat)))

(define-public julia-ratios
  (package
    (name "julia-ratios")
    (version "0.3.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/timholy/Ratios.jl")
             (commit (string-append "v" version))))
       (file-name "Ratios")
       (sha256
        (base32 "08gdjbgqpac8b5k5ycdyhsnmcjdrafijawi5hyk9bq5bsyjx1xa1"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "Ratios"
              "c84ed2f1-dad5-54f0-aa8e-dbefe2724439"
              "0.3.1"
              '(("Compat" . "34da2185-b29b-5c13-b0c7-acf172513d20")))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/timholy/Ratios.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-interpolations
  (package
    (name "julia-interpolations")
    (version "0.12.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/Interpolations.jl")
             (commit (string-append "v" version))))
       (file-name "Interpolations")
       (sha256
        (base32 "082svwfz765rrk2vnx3czz78sqk4cmksiyn0afz2zssq7xwk0jfr"))))
    (propagated-inputs `(("julia-ratios" ,julia-ratios)
                         ("julia-axisalgorithms" ,julia-axisalgorithms)
                         ("julia-staticarrays" ,julia-staticarrays)
                         ("julia-woodburymatrices" ,julia-woodburymatrices)
                         ("julia-offsetarrays" ,julia-offsetarrays)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaMath/Interpolations.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-parameters
  (package
    (name "julia-parameters")
    (version "0.12.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/mauro3/Parameters.jl")
             (commit (string-append "v" version))))
       (file-name "Parameters")
       (sha256
        (base32 "0a5lnqvh3gaqir0qkd37cavrpkpqswqakaw7qk7bzfy9gb8nbf5m"))))
    (propagated-inputs `(("julia-orderedcollections" ,julia-orderedcollections)))
    (build-system julia-build-system)
    (home-page "https://mauro3.github.io/Parameters.jl/stable/")
    (synopsis "Types with default field values, keyword constructors
and (un-)pack macros")
    (description "This is a package I use to handle numerical-model parameters, thus the name.  However, it should be useful otherwise too.  It has two main features:
@enumerate
@item keyword type constructors with default values for structs and NamedTuples,
@item unpacking and packing of composite types and dicts.
@end enumerate")
    (license license:expat)))

(define-public julia-calculus
  (package
    (name "julia-calculus")
    (version "0.5.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/Calculus.jl")
             (commit (string-append "v" version))))
       (file-name "Calculus")
       (sha256
        (base32 "1nwgvdyczbaqmp0v02xzh20jzhxjsb9487pk193ha1xjjnnkg3gs"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaMath/Calculus.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-bandedmatrices
  (package
    (name "julia-bandedmatrices")
    (version "0.12.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMatrices/BandedMatrices.jl.git")
             (commit (string-append "v" version))))
       (file-name "BandedMatrices")
       (sha256
        (base32 "0b38zw8ya3mxd4nq29gii2bp9sj83gx20hikxynfdcb99307wv2j"))))
    (propagated-inputs `(("julia-fillarrays" ,julia-fillarrays)
                         ("julia-lazyarrays" ,julia-lazyarrays)
                         ("julia-matrixfactorizations" ,julia-matrixfactorizations)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaMatrices/BandedMatrices.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-matrixfactorizations
  (package
   (name "julia-matrixfactorizations")
   (version "0.2.0")
   (source
      (origin
        (method git-fetch)
        (uri (git-reference
          (url "https://github.com/JuliaMatrices/MatrixFactorizations.jl.git")
          (commit (string-append "v" version))))
        (file-name "MatrixFactorizations")
        (sha256
             (base32 "1zy1ryc1dbs51whsmdpra3z94v8x1z954avnp1gjpkvh9ijld88m"))))
   (propagated-inputs `())
   (build-system julia-build-system)
   (home-page "https://github.com/JuliaMatrices/MatrixFactorizations.jl.git")
   (synopsis "")
   (description "")
   (license license:expat)))

(define-public julia-blockarrays
  (package
   (name "julia-blockarrays")
   (version "0.10.0")
   (source
      (origin
        (method git-fetch)
        (uri (git-reference
          (url "https://github.com/JuliaArrays/BlockArrays.jl.git")
          (commit (string-append "v" version))))
        (file-name "BlockArrays")
        (sha256
             (base32 "1n5dnh3xapaj820szwrc3mjajl1bz283wnq9wz7fy2gn7xjirc9s"))))
   (propagated-inputs `())
   (build-system julia-build-system)
   (home-page "https://github.com/JuliaArrays/BlockArrays.jl.git")
   (synopsis "")
   (description "")
   (license license:expat)))

(define-public julia-blockbandedmatrices
  (package
    (name "julia-blockbandedmatrices")
    (version "0.5.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMatrices/BlockBandedMatrices.jl.git")
             (commit (string-append "v" version))))
       (file-name "BlockBandedMatrices")
       (sha256
        (base32 "009qlmdlpsvygr69p1qvy0bbpwryz1waqbgk4ygahjpp21lvy4si"))))
    (propagated-inputs `(("julia-matrixfactorizations" ,julia-matrixfactorizations)
                         ("julia-blockarrays" ,julia-blockarrays)
                         ("julia-fillarrays" ,julia-fillarrays)
                         ("julia-bandedmatrices" ,julia-bandedmatrices)
                         ("julia-lazyarrays" ,julia-lazyarrays)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaMatrices/BlockBandedMatrices.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))


(define-public julia-diffeqdifftools
  (package
    (name "julia-diffeqdifftools")
    (version "1.3.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaDiffEq/DiffEqDiffTools.jl")
             (commit (string-append "v" version))))
       (file-name "DiffEqDiffTools")
       (sha256
        (base32 "130qs3iaganzsr04x9qdxnn1bxmwjjrh0i0af5q0kv4i1wj2c6dk"))))
    (propagated-inputs `(("julia-arrayinterface" ,julia-arrayinterface)
                         ("julia-staticarrays" ,julia-staticarrays)))
    (native-inputs `(("julia-blockbandedmatrices" ,julia-blockbandedmatrices)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaDiffEq/DiffEqDiffTools.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-diffresults
  (package
    (name "julia-diffresults")
    (version "0.0.4")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaDiff/DiffResults.jl")
             (commit (string-append "v" version))))
       (file-name "DiffResults")
       (sha256
        (base32 "1rs6ln6vimby0xxs938xpq6wgkgysbmylbkvfh8mhnif3nkksyps"))))
    (propagated-inputs `(("julia-staticarrays" ,julia-staticarrays)
                         ("julia-compat" ,julia-compat)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "DiffResults"
              "163ba53b-c6d8-5494-b064-1a9d43ac40c5"
              "0.0.4"
              '(("StaticArrays" . "90137ffa-7385-5640-81b9-e52037218182")
                ("Compat" . "34da2185-b29b-5c13-b0c7-acf172513d20")))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaDiff/DiffResults.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-diffrules
  (package
    (name "julia-diffrules")
    (version "0.0.10")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaDiff/DiffRules.jl")
             (commit (string-append "v" version))))
       (file-name "DiffRules")
       (sha256
        (base32 "1qr8q84bnchhmm1nmg172nyvy3d10h6qbz7mpnarl96jv1cl9vfd"))))
    (propagated-inputs `(("julia-specialfunctions" ,julia-specialfunctions)))
    (arguments
     `(#:tests? #f                      ;does not find nanmath
       #:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "DiffRules"
              "b552c78f-8df3-52c6-915a-8e097449b14b"
              "0.0.10"
              '(("NaNMath" . "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3")
                ("SpecialFunctions" . "276daf66-3868-5448-9aa4-cd146d93841b")))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaDiff/DiffRules.jl")
    (synopsis "")
    (description "This Julia package provides the @code{@@cse} macro, which
performs common subexpression elimination.")
    (license license:expat)))

(define-public julia-commonsubexpressions
  (package
    (name "julia-commonsubexpressions")
    (version "0.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/rdeits/CommonSubexpressions.jl")
             (commit (string-append "v" version))))
       (file-name "CommonSubexpressions")
       (sha256
        (base32 "008dgw4drdkn5aickgcy2irv3q90aririw125fk8r6p1dkavvihl"))))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "CommonSubexpressions"
              "bbf7d656-a473-5ed7-a52c-81e309532950"
              "0.2.0"
              '())
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/rdeits/CommonSubexpressions.jl")
    (synopsis "Naïve combined subexpression elimination in Julia")
    (description "")
    (license license:expat)))

(define-public julia-dualnumbers
  (package
    (name "julia-dualnumbers")
    (version "0.6.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaDiff/DualNumbers.jl")
             ;; Project.toml added after 0.6.2 release
             (commit "677e2d52bfadc365f2b3f43b51c1dc66d284a9fa")))
       (file-name "DualNumbers")
       (sha256
        (base32 "1ll9avzmsradq1b59bcq8isdbb9gsn01xfk854yks3cns136rjbr"))))
    (propagated-inputs `(("julia-nanmath" ,julia-nanmath)
                         ("julia-calculus" ,julia-calculus)
                         ("julia-specialfunctions" ,julia-specialfunctions)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaDiff/DualNumbers.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-quaternions
  (package
    (name "julia-quaternions")
    (version "0.4.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGeometry/Quaternions.jl")
             (commit (string-append "v" version))))
       (file-name "Quaternions")
       (sha256
        (base32 "19vhm0fddbp29xim6k7c55awwfdlzrdbc8nwgcpbgmczfvygz2iz"))))
    (propagated-inputs `(("julia-dualnumbers" ,julia-dualnumbers)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGeometry/Quaternions.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-difftests
  (package
   (name "julia-difftests")
   (version "0.1.0")
   (source
      (origin
        (method git-fetch)
        (uri (git-reference
          (url "https://github.com/JuliaDiff/DiffTests.jl.git")
          (commit (string-append "v" version))))
        (file-name "DiffTests")
        (sha256
             (base32 "1isqixhr3rc3jqpgq29j2wl7mf83szias7hmf1z3qj4933ags5n2"))))
   (propagated-inputs `())
   (build-system julia-build-system)
   (home-page "https://github.com/JuliaDiff/DiffTests.jl.git")
   (synopsis "")
   (description "")
   (license license:expat)))

(define-public julia-forwarddiff
  (package
    (name "julia-forwarddiff")
    (version "0.10.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaDiff/ForwardDiff.jl")
             (commit (string-append "v" version))))
       (file-name "ForwardDiff")
       (sha256
        (base32 "0mdmf5ksmiyfdnl7p8rlnw5xdkp13sh81jhqgvvcd4shphq0hhs2"))))
    (propagated-inputs `(("julia-diffresults" ,julia-diffresults)
                         ("julia-diffrules" ,julia-diffrules)
                         ("julia-nanmath" ,julia-nanmath)
                         ("julia-specialfunctions" ,julia-specialfunctions)
                         ("julia-staticarrays" ,julia-staticarrays)
                         ("julia-commonsubexpressions" ,julia-commonsubexpressions)))
    (native-inputs `(("julia-calculus" ,julia-calculus)
                     ("julia-difftests" ,julia-difftests)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaDiff/ForwardDiff.jl")
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "ForwardDiff"
              "f6369f11-7733-5829-9624-2563aa707210"
              "0.6.2"
              '(("Random" . "9a3f8284-a2c9-5f02-9a11-845980a1fd5c")
                ("StaticArrays" . "90137ffa-7385-5640-81b9-e52037218182")
                ("DiffResults" . "163ba53b-c6d8-5494-b064-1a9d43ac40c5")
                ("DiffRules" . "b552c78f-8df3-52c6-915a-8e097449b14b")
                ("NaNMath" . "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3")
                ("SpecialFunctions" . "276daf66-3868-5448-9aa4-cd146d93841b")
                ("CommonSubexpressions" . "bbf7d656-a473-5ed7-a52c-81e309532950")))
             #t)))))
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-tensors
  (package
   (name "julia-tensors")
   (version "1.2.0")
   (source
      (origin
        (method git-fetch)
        (uri (git-reference
          (url "https://github.com/KristofferC/Tensors.jl.git")
          (commit (string-append "v" version))))
        (file-name "Tensors")
        (sha256
             (base32 "1csc4rydm9q498bj2az2rjar3x7dqv9g4807bl67dpmgz4yvsxzd"))))
   (propagated-inputs `(("julia-forwarddiff" ,julia-forwarddiff)))
   (build-system julia-build-system)
   (home-page "https://github.com/KristofferC/Tensors.jl.git")
   (synopsis "")
   (description "")
   (license license:expat)))

(define-public julia-nlsolversbase
  (package
    (name "julia-nlsolversbase")
    (version "7.5.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaNLSolvers/NLSolversBase.jl")
             (commit (string-append "v" version))))
       (file-name "NLSolversBase")
       (sha256
        (base32 "1sm6h1qmfh1w0nqpcf61b7zfd2w97h0p7j9apq23ha2cddnvyzck"))))
    (propagated-inputs `(("julia-calculus" ,julia-calculus)
                         ("julia-diffeqdifftools" ,julia-diffeqdifftools)
                         ("julia-diffresults" ,julia-diffresults)
                         ("julia-forwarddiff" ,julia-forwarddiff)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaNLSolvers/NLSolversBase.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-linesearches
  (package
    (name "julia-linesearches")
    (version "7.0.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaNLSolvers/LineSearches.jl")
             (commit (string-append "v" version))))
       (file-name "LineSearches")
       (sha256
        (base32 "17nk85w29bn3by31mhifq66b0mniji6ys1mh83ffzswgrzzqlbd8"))))
    (propagated-inputs `(("julia-parameters" ,julia-parameters)
			 ("julia-nanmath" ,julia-nanmath)
			 ("julia-nlsolversbase" ,julia-nlsolversbase)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "LineSearches"
              "d3d80556-e9d4-5f37-9878-2ab0fcc64255"
              "7.0.1"
              '(("NaNMath" . "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3")
                ("Parameters" . "d96e819e-fc66-5662-9728-84c9c7592b0a")
                ("NLSolversBase" . "d41bc354-129a-5804-8e4c-c37616107c6c")
                ("Printf" . "de0858da-6303-5e67-8744-51eddeeeb8d7")
                ("LinearAlgebra" . "37e2e46d-f89d-539d-b4ee-838fcccc9c8e")))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaNLSolvers/LineSearches.jl")
    (synopsis "Line search methods for optimization and root-finding")
    (description "This package provides an interface to line search algorithms
implemented in Julia.")
    (license license:expat)))

(define-public julia-positivefactorizations
  (package
    (name "julia-positivefactorizations")
    (version "0.2.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/timholy/PositiveFactorizations.jl")
             (commit (string-append "v" version))))
       (file-name "PositiveFactorizations")
       (sha256
        (base32 "1aia57g1rb6qx0a92ysqs1cdkdp5374b9qway89vqdnd3rzhpj59"))))
    (propagated-inputs `())
    (build-system julia-build-system)
    (home-page "https://github.com/timholy/PositiveFactorizations.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-fillarrays
  (package
    (name "julia-fillarrays")
    (version "0.7.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaArrays/FillArrays.jl")
             (commit (string-append "v" version))))
       (file-name "FillArrays")
       (sha256
        (base32 "06hlps7pkslfzs9czg7543ai2i84qvwvlqcghibmj7dajivr3rg1"))))
    (propagated-inputs `())
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/FillArrays.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-lazyarrays
  (package
    (name "julia-lazyarrays")
    (version "0.12.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaArrays/LazyArrays.jl.git")
             (commit (string-append "v" version))))
       (file-name "LazyArrays")
       (sha256
        (base32 "1z8ipn6iwcj15ksl07x2h6majkyjilhc7y14ddndj031yhl61ass"))))
    (propagated-inputs `(("julia-staticarrays" ,julia-staticarrays)
                         ("julia-fillarrays" ,julia-fillarrays)
                         ("julia-macrotools" ,julia-macrotools)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/LazyArrays.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-optim
  (package
    (name "julia-optim")
    (version "0.19.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaNLSolvers/Optim.jl")
	     (commit (string-append "v" version))))
       (file-name "Optim")
       (sha256
	(base32 "19znkh3xk801j2zj938897s3zfnd55vqqz2k401a2dqgdgzshfi8"))))
    (propagated-inputs `(("julia-parameters" ,julia-parameters)
			 ("julia-linesearches" ,julia-linesearches)
			 ("julia-nlsolversbase" ,julia-nlsolversbase)
			 ("julia-diffeqdifftools" ,julia-diffeqdifftools)
			 ("julia-positivefactorizations" ,julia-positivefactorizations)
			 ("julia-forwarddiff" ,julia-forwarddiff)
			 ("julia-fillarrays" ,julia-fillarrays)
			 ("julia-compat" ,julia-compat)
			 ("julia-calculus" ,julia-calculus)
			 ("julia-nanmath" ,julia-nanmath)
			 ("julia-statsbase" ,julia-statsbase)))
    (build-system julia-build-system)
    (home-page "https://julianlsolvers.github.io/Optim.jl/stable/")
    (synopsis "Optimization functions for Julia")
    (description "Univariate and multivariate optimization in Julia.")
    (license license:expat)))

(define-public julia-docstringextensions
  (package
    (name "julia-dostringextensions")
    (version "0.8.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaDocs/DocStringExtensions.jl")
             (commit (string-append "v" version))))
       (file-name "DocStringExtensions")
       (sha256
        (base32 "01w7z5q7gzasg66b9k6kmjm2f7iqxb2c9ilvi3cbh9pbkr1bqvwx"))))
    (build-system julia-build-system)
    (home-page "https://juliadocs.github.io/DocStringExtensions.jl/stable/")
    (synopsis "Extensions for Julia's docsystem.")
    (description "This package provides a collection of useful extensions for
Julia's built-in docsystem.")
    (license license:expat)))

(define-public julia-kerneldensity
  (package
    (name "julia-kerneldensity")
    (version "0.5.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaStats/KernelDensity.jl")
             ;; Project.toml added after 0.5.1 release
             (commit "b87a4bc46a961efd65a955a492924df4957ca6cb")))
       (file-name "KernelDensity")
       (sha256
        (base32 "15lcgpcyh1cjsknhr4p2afyw1ivqga42z1aa02gc5xagd09p6fq2"))))
    (propagated-inputs `(("julia-optim" ,julia-optim)
                         ("julia-statsbase" ,julia-statsbase)
                         ("julia-distributions" ,julia-distributions)
                         ("julia-interpolations" ,julia-interpolations)
                         ("julia-fftw" ,julia-fftw)
                         ("julia-docstringextensions" ,julia-docstringextensions)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaStats/KernelDensity.jl")
    (synopsis "Kernel density estimators for Julia")
    (description "This Julia package provides kernel density estimators.")
    (license license:expat)))

(define-public julia-distances
  (package
    (name "julia-distances")
    (version "0.8.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaStats/Distances.jl")
             (commit (string-append "v" version))))
       (file-name "Distances")
       (sha256
        (base32 "00sdi3lyx0hiwlfb920k094yv6c27jskiivplfrk4d2w230fbrs4"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaStats/Distances.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-nearestneighbors
  (package
    (name "julia-nearestneighbors")
    (version "0.4.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/KristofferC/NearestNeighbors.jl")
             (commit (string-append "v" version))))
       (file-name "NearestNeighbors")
       (sha256
        (base32 "1wadybw6g0556n3x7nrlw7vnsspd2dzp459h4c4khy9nzmmz4b59"))))
    (propagated-inputs `(("julia-staticarrays" ,julia-staticarrays)
                         ("julia-distances" ,julia-distances)))
    (build-system julia-build-system)
    (home-page "https://github.com/KristofferC/NearestNeighbors.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-clustering
  (package
    (name "julia-clustering")
    (version "0.13.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaStats/Clustering.jl")
             (commit (string-append "v" version))))
       (file-name "Clustering")
       (sha256
        (base32 "0hv7zwqxvdhbfhgh1fi7yklwmqd2nq84shkyvfjch46jxlrgvyx6"))))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (delete 'reset-gzip-timestamps))))
    (propagated-inputs `(("julia-statsbase" ,julia-statsbase)
                         ("julia-nearestneighbors" ,julia-nearestneighbors)
                         ("julia-distances" ,julia-distances)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaStats/Clustering.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-statsplots
  (package
    (name "julia-statsplots")
    (version "0.12.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaPlots/StatsPlots.jl")
	     (commit (string-append "v" version))))
       (file-name "StatsPlots")
       (sha256
	(base32 "1s40274sy5r44by98rfrfraq0nzdh6l8h3y2x3q41dx2wzkfk0hd"))))
    (propagated-inputs `(("julia-clustering" ,julia-clustering)
                         ("julia-datastructures" ,julia-datastructures)
			 ("julia-datavalues" ,julia-datavalues)
                         ("julia-distributions" ,julia-distributions)
                         ("julia-interpolations" ,julia-interpolations)
                         ("julia-kerneldensity" ,julia-kerneldensity)
                         ("julia-observables" ,julia-observables)
                         ("julia-plots" ,julia-plots)
                         ("julia-recipesbase" ,julia-recipesbase)
                         ("julia-reexport" ,julia-reexport)
                         ("julia-statsbase" ,julia-statsbase)
			 ("julia-tables" ,julia-tables)
			 ("julia-widgets" ,julia-widgets)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPlots/StatsPlots.jl")
    (synopsis "Statistical plotting recipes for @code{Plots.jl}")
    (description "This package is a drop-in replacement for @code{Plots.jl}
that contains many statistical recipes for concepts and types introduced in
the JuliaStats organization.")
    (license license:expat)))

(define-public julia-structarrays
  (package
    (name "julia-structarrays")
    (version "0.4.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/piever/StructArrays.jl")
             (commit (string-append "v" version))))
       (file-name "StructArrays")
       (sha256
        (base32 "0qhnnqrjvh510y2rkhlr8kmx5nhv4jc86nfbzryhv8qzv6hazyql"))))
    (propagated-inputs `(("julia-requires" ,julia-requires)
                         ("julia-pooledarrays" ,julia-pooledarrays)))
    (build-system julia-build-system)
    (home-page "https://github.com/piever/StructArrays.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-learnbase
  (package
    (name "julia-learnbase")
    (version "0.2.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaML/LearnBase.jl")
             (commit (string-append "v" version))))
       (file-name "LearnBase")
       (sha256
        (base32 "1cmckvprj2z7kdalw44wb56j20xskqq5cb2bfhswnmxv0pd1aqkv"))))
    (propagated-inputs `(("julia-statsbase" ,julia-statsbase)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "LearnBase"
              "7f8f8fb0-2700-5f03-b4bd-41f8cfc144b6"
              "0.2.2"
              '(("StatsBase" . "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91")
                ("LinearAlgebra" . "37e2e46d-f89d-539d-b4ee-838fcccc9c8e")))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaML/LearnBase.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-onlinestatsbase
  (package
    (name "julia-onlinestatsbase")
    (version "1.0.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/joshday/OnlineStatsBase.jl")
             (commit (string-append "v" version))))
       (file-name "OnlineStatsBase")
       (sha256
        (base32 "05b2j2dafg36kzlrxs62za14vfhw2yh38qp9jd8ldcv56dqw3zya"))))
    (propagated-inputs `(("julia-learnbase" ,julia-learnbase)))
    (build-system julia-build-system)
    (home-page "https://github.com/joshday/OnlineStatsBase.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-indexedtables
  (package
    (name "julia-indexedtables")
    (version "0.12.4")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaComputing/IndexedTables.jl")
             (commit (string-append "v" version))))
       (file-name "IndexedTables")
       (sha256
        (base32 "05vxg23gsabflivk2vgv5hh6ak30zqy6jnhn92ywx46v2bswk3c6"))))
    (propagated-inputs `(("julia-tabletraitsutils" ,julia-tabletraitsutils)
                         ("julia-datavalues" ,julia-datavalues)
                         ("julia-iteratorinterfaceextensions" ,julia-iteratorinterfaceextensions)
                         ("julia-weakrefstrings" ,julia-weakrefstrings)
                         ("julia-dataapi" ,julia-dataapi)
                         ("julia-tables" ,julia-tables)
                         ("julia-structarrays" ,julia-structarrays)
                         ("julia-onlinestatsbase" ,julia-onlinestatsbase)
                         ("julia-pooledarrays" ,julia-pooledarrays)
                         ("julia-tabletraits" ,julia-tabletraits)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaComputing/IndexedTables.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-loess
  (package
    (name "julia-loess")
    (version "0.5.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaStats/Loess.jl")
             (commit (string-append "v" version))))
       (file-name "Loess")
       (sha256
        (base32 "1smdpn6asxgq2kq4xp4xqglm6ldry4sqkl7gi8gajgfffvsj6ndn"))))
    (propagated-inputs `(("julia-itertools" ,julia-itertools)
                         ("julia-distances" ,julia-distances)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaStats/Loess.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-groupederrors
  (package
    (name "julia-groupederrors")
    (version "0.2.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/piever/GroupedErrors.jl")
	     (commit (string-append "v" version))))
       (file-name "GroupedErrors")
       (sha256
	(base32 "1nwck5vq9q8nw96szwlcy6aa06jjnvddchp13rhbrn54qb4k7kcs"))))
    (propagated-inputs `(("julia-datavalues" ,julia-datavalues)
                         ("julia-indexedtables" ,julia-indexedtables)
                         ("julia-iterabletables" ,julia-iterabletables)
                         ("julia-kerneldensity" ,julia-kerneldensity)
                         ("julia-lazy" ,julia-lazy)
                         ("julia-loess" ,julia-loess)
                         ("julia-macrotools" ,julia-macrotools)
                         ("julia-shiftedarrays" ,julia-shiftedarrays)
                         ("julia-statsbase" ,julia-statsbase)
			 ("julia-tabletraits" ,julia-tabletraits)
			 ("julia-tabletraitsutils" ,julia-tabletraitsutils)))
    (build-system julia-build-system)
    (home-page "https://github.com/piever/GroupedErrors.jl")
    (synopsis "")
    (description "")
    (license license:expat)))


(define-public julia-unicodeplots
  (package
    (name "julia-unicodeplots")
    (version "1.1.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/Evizero/UnicodePlots.jl")
             (commit (string-append "v" version))))
       (file-name "UnicodePlots")
       (sha256
        (base32 "03hhcx0xrhv1gsdc9ajp9j107zhgkx25c89n40w40i9hahp0gal2"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
                         ("julia-statsbase" ,julia-statsbase)))
    (build-system julia-build-system)
    (arguments `(#:tests? #f))                    ;FIXME: add missing deps
    (home-page "https://github.com/Evizero/UnicodePlots.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-textwrap
  (package
   (name "julia-textwrap")
   (version "0.3.0")
   (source
      (origin
        (method git-fetch)
        (uri (git-reference
          (url "https://github.com/carlobaldassi/TextWrap.jl")
          (commit (string-append "v" version))))
        (file-name "TextWrap")
        (sha256
             (base32 "1sx0rrsd3bm8rj4a4yx40r9rbcbz77n50f9l5gpld98h0r99vp73"))))
   (propagated-inputs `(("julia-compat" ,julia-compat)))
   (build-system julia-build-system)
   (home-page "https://github.com/carlobaldassi/TextWrap.jl")
   (synopsis "")
   (description "")
   (license license:expat)))

(define-public julia-argparse
  (package
   (name "julia-argparse")
   (version "0.6.2")
   (source
      (origin
        (method git-fetch)
        (uri (git-reference
          (url "https://github.com/carlobaldassi/ArgParse.jl")
          (commit (string-append "v" version))))
        (file-name "ArgParse")
        (sha256
             (base32 "0fa1gfdxb646slm5j979l31yjhn0mqad1rpggkby1v0vjkn3gci8"))))
   (propagated-inputs `(("julia-compat" ,julia-compat)
("julia-textwrap" ,julia-textwrap)))
   (build-system julia-build-system)
   (home-page "https://github.com/carlobaldassi/ArgParse.jl")
   (synopsis "")
   (description "")
   (license license:expat)))

;; (define-public julia-packagecompiler
;;   (package
;;     (name "julia-packagecompiler")
;;     (version "0.6.4")
;;     (source
;;      (origin
;;        (method git-fetch)
;;        (uri (git-reference
;;              (url "https://github.com/JuliaLang/PackageCompiler.jl")
;;              (commit (string-append "v" version))))
;;        (file-name "PackageCompiler")
;;        (sha256
;;         (base32 "1nd99md5sbga348k9qy2zdqa2r37vpq0x8yq8r8fpsdx33zigdav"))))
;;     (propagated-inputs `(("binutils" ,binutils)))
;;     (native-inputs `(("gcc" ,gcc-toolchain)
;;                      ("julia-offsetarrays" ,julia-offsetarrays)
;;                      ("julia-json" ,julia-json)
;;                      ("julia-datastructures" ,julia-datastructures)
;;                      ("julia-colortypes" ,julia-colortypes)
;;                      ("julia-unicodeplots" ,julia-unicodeplots)
;;                      ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
;;                      ("julia-argparse" ,julia-argparse)))
;;     (arguments
;;      `(#:tests? #f
;;        #:phases
;;        (modify-phases %standard-phases
;;          ;; normpath(abspath(joinpath(@__DIR__, "..", "sysimg")))
;;          (add-before 'precompile 'fix-sysimg-dir
;;            (lambda* (#:key outputs source inputs #:allow-other-keys)
;;              (substitute*
;;                  (string-append
;;                   (assoc-ref outputs "out")
;;                   "/share/julia/packages/"
;;                   (string-append
;;                    (strip-store-file-name source)
;;                    "/src/PackageCompiler.jl"))
;;                (("base_path = ") "base_path = \"/tmp/packagecompiler/\" # ")
;;                (("    packages = ") "    packages = \"/tmp/packages/\" # "))
;;              #t))
;;          (add-before 'precompile 'build-deps
;;            (lambda* (#:key outputs source inputs #:allow-other-keys)
;;              (let ((f (open-file
;;                        (string-append
;;                         (assoc-ref outputs "out")
;;                         "/share/julia/packages/"
;;                         (strip-store-file-name source)
;;                         "/deps/deps.jl") "w")))
;;                (display
;;                 (string-append "const gcc = \""
;;                                (assoc-ref inputs "gcc")
;;                                "/bin/gcc\"\n") f)
;;                (close-port f))
;;              #t)))))
;;     (build-system julia-build-system)
;;     (home-page "https://github.com/JuliaLang/PackageCompiler.jl")
;;     (synopsis "")
;;     (description "")
;;     (license license:expat)))

(define-public julia-intervalsets
  (package
    (name "julia-intervalsets")
    (version "0.3.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaMath/IntervalSets.jl")
             (commit (string-append "v" version))))
       (file-name "IntervalSets")
       (sha256
        (base32 "08p3w3sr7jxa3i4b2jf88aqk3861sap9b4pzk33fr3yxklyabahm"))))
    (propagated-inputs `())
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaMath/IntervalSets.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-packing
  (package
    (name "julia-packing")
    (version "0.3.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGeometry/Packing.jl")
             (commit (string-append "v" version))))
       (file-name "Packing")
       (sha256
        (base32 "11cp3lflwbkw8ip6adq6gn2cp742ir95ccxp94mb24w6i8s76qah"))))
    (propagated-inputs `(("julia-geometrytypes" ,julia-geometrytypes)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGeometry/Packing.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-signeddistancefields
  (package
    (name "julia-signeddistancefields")
    (version "0.4.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGraphics/SignedDistanceFields.jl")
             (commit (string-append "v" version))))
       (file-name "SignedDistanceFields")
       (sha256
        (base32 "1a4imbxsjrvb3vzjbwyg7h6sbcmm5zb7a8w5w153vz753kfd3l99"))))
    (propagated-inputs `())
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGraphics/SignedDistanceFields.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-freetype
  (package
    (name "julia-freetype")
    (version "2.1.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGraphics/FreeType.jl")
             (commit (string-append "v" version))))
       (file-name "FreeType")
       (sha256
        (base32 "0qz4n29pi6xjxn8vlkcg2h100micvs6xsabs9yxqxyhal5aj4ssh"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
                         ("julia-binaryprovider" ,julia-binaryprovider)
                         ("freetype" ,freetype)))
    (arguments
     `(#:tests? #f                      ; no tests defined
       #:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'build-deps
           (lambda* (#:key outputs source inputs #:allow-other-keys)
             (let ((f (open-file
                       (string-append
                        (assoc-ref outputs "out")
                        "/share/julia/packages/"
                        (strip-store-file-name source)
                        "/deps/deps.jl") "w")))
               (display
                (string-append "const libfreetype = \""
                               (assoc-ref inputs "freetype")
                               "/lib/libfreetype.so\"\n") f)
               (display
                (string-append "check_deps() = nothing\n") f)
               (close-port f))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGraphics/FreeType.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-colorbrewer
  (package
    (name "julia-colorbrewer")
    (version "0.4.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/timothyrenner/ColorBrewer.jl")
             ;; in this release, they forgot the patch version
             (commit (string-append "v" "0.4"))))
       (file-name "ColorBrewer")
       (sha256
        (base32 "1l1m87czqhs70qlqwwq4dfjxrndlrzf7m68r8qjp4376aljnng8f"))))
    (propagated-inputs `(("julia-json" ,julia-json)
                         ("julia-colors" ,julia-colors)))
    (build-system julia-build-system)
    (home-page "https://github.com/timothyrenner/ColorBrewer.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-unicodefun
  (package
    (name "julia-unicodefun")
    (version "0.4.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/SimonDanisch/UnicodeFun.jl")
             (commit (string-append "v" version))))
       (file-name "UnicodeFun")
       (sha256
        (base32 "045m1p9py2l1zv7dhkvr5l533b2as0vabb9x4pa9d8p7jnzn3l67"))))
    (propagated-inputs `())
    (build-system julia-build-system)
    (home-page "https://github.com/SimonDanisch/UnicodeFun.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-colorvectorspace
  (package
    (name "julia-colorvectorspace")
    (version "0.7.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGraphics/ColorVectorSpace.jl")
             (commit (string-append "v" version))))
       (file-name "ColorVectorSpace")
       (sha256
        (base32 "1y7fxsdy2v92a0cf223cxml3z0dfc947pw7n8qgiq8a2a80jag14"))))
    (propagated-inputs `(("julia-colortypes" ,julia-colortypes)
                         ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
                         ("julia-compat" ,julia-compat)
                         ("julia-statsbase" ,julia-statsbase)
                         ("julia-colors" ,julia-colors)
                         ("julia-specialfunctions" ,julia-specialfunctions)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGraphics/ColorVectorSpace.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-freetypeabstraction
  (package
    (name "julia-freetypeabstraction")
    (version "0.4.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGraphics/FreeTypeAbstraction.jl")
             (commit (string-append "v" version))))
       (file-name "FreeTypeAbstraction")
       (sha256
        (base32 "1iwvp36rwlgnx680y1kqicp3ihrsrdk978wssfqp6pp2jhaf11p5"))))
    (propagated-inputs `(("julia-freetype" ,julia-freetype)
                         ("julia-staticarrays" ,julia-staticarrays)
                         ("julia-colorvectorspace" ,julia-colorvectorspace)
                         ("julia-colors" ,julia-colors)))
    ;; Cannot find fonts...
    (arguments `(#:tests? #f))
    
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGraphics/FreeTypeAbstraction.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-fontconfig
  (package
    (name "julia-fontconfig")
    (version "0.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGraphics/Fontconfig.jl")
             (commit (string-append "v" version))))
       (file-name "Fontconfig")
       (sha256
        (base32 "1xcc86f95f4ii3qqwdifmczayxn3a0ihkiyp062728kwg96p4wlw"))))
    (propagated-inputs `(("julia-bindeps" ,julia-bindeps)
                         ("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGraphics/Fontconfig.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-docstringextensions
  (package
    (name "julia-docstringextensions")
    (version "0.8.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaDocs/DocStringExtensions.jl")
             (commit (string-append "v" version))))
       (file-name "DocStringExtensions")
       (sha256
        (base32 "0kdk9fxl54g07p3zyxkjqcz3p66sygri3gi2dhcbysdmn1b7b8ay"))))
    (propagated-inputs `())
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaDocs/DocStringExtensions.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-paddedviews
  (package
    (name "julia-paddedviews")
    (version "0.4.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaArrays/PaddedViews.jl")
             (commit (string-append "v" version))))
       (file-name "PaddedViews")
       (sha256
        (base32 "0ccgdsf834x3jzv73ckcx1nwbjcmrdhqlhm64qi519jcdmv0k91z"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
                         ("julia-offsetarrays" ,julia-offsetarrays)))
    (arguments
     `(#:tests? #f
       #:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda*
               (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "PaddedViews"
              "5432bcbf-9aad-5242-b902-cca2824c8663"
              "0.4.2"
              '(;; ("SHA" . "ea8e919c-243c-51af-8825-aaa63cd721ce")
                ))
             #t)))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/PaddedViews.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-mappedarrays
  (package
    (name "julia-mappedarrays")
    (version "0.2.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaArrays/MappedArrays.jl")
             (commit (string-append "v" version))))
       (file-name "MappedArrays")
       (sha256
        (base32 "0kz8ca5xzjzq2h0ay9zgk952skgl0w7k0z3k921rm0lmdlhl1cfx"))))
    (arguments `(#:tests? #f))
    ;; does not find colortypes
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (native-inputs `(("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
                     ("julia-offsetarrays" ,julia-offsetarrays)
                     ("julia-colortypes" ,julia-colortypes)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/MappedArrays.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-imagecore
  (package
    (name "julia-imagecore")
    (version "0.8.5")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaImages/ImageCore.jl")
             (commit (string-append "v" version))))
       (file-name "ImageCore")
       (sha256
        (base32 "0lngnmnf1ldrvq42qcqh2r9n3sdgs5m3203m2clvfff9bvpmycwl"))))
    (propagated-inputs `(("julia-colortypes" ,julia-colortypes)
                         ("julia-paddedviews" ,julia-paddedviews)
                         ("julia-mappedarrays" ,julia-mappedarrays)
                         ("julia-colors" ,julia-colors)
                         ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
                         ("julia-graphics" ,julia-graphics)
                         ("julia-offsetarrays" ,julia-offsetarrays)
                         ("julia-reexport" ,julia-reexport)
                         ("julia-fftw" ,julia-fftw)))
    (arguments '(#:tests? #f))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaImages/ImageCore.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-imagemagick
  (package
    (name "julia-imagemagick")
    (version "0.7.5")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaIO/ImageMagick.jl")
             (commit (string-append "v" version))))
       (file-name "ImageMagick")
       (sha256
        (base32 "1xi539ygskgb2rfz8a4hvy7ahsxqfm4y1p1kqski1wq44gp92af0"))))
    (propagated-inputs `(("julia-fileio" ,julia-fileio)
                         ("julia-colortypes" ,julia-colortypes)
                         ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
                         ("julia-compat" ,julia-compat)
                         ("julia-imagecore" ,julia-imagecore)
                         ("zlib" ,zlib)
                         ("libjpeg" ,libjpeg)
                         ("libpng" ,libpng)
                         ("libtiff" ,libtiff)
                         ("imagemagick" ,imagemagick)))
    (arguments
     `(#:tests? #f
       #:phases
       (modify-phases %standard-phases
      ;; Precompilation tries to open display
      (delete 'precompile)
      (add-after 'install 'build-deps
        (lambda* (#:key outputs source inputs #:allow-other-keys)
          (let ((f (open-file
                    (string-append
                     (assoc-ref outputs "out")
                     "/share/julia/packages/"
                     (strip-store-file-name source)
                     "/deps/deps.jl") "w")))
            (display
             (string-append "const libz = \""
                            (assoc-ref inputs "zlib")
                            "/zlib.so\"\n") f)
            (display
             (string-append "const libjpeg = \""
                            (assoc-ref inputs "libjpeg")
                            "/lib/libjpeg.so\"\n") f)
            (display
             (string-append "const libpng16 = \""
                            (assoc-ref inputs "libpng")
                            "/lib/libpng.so\"\n") f)
            (display
             (string-append "const libtiff = \""
                            (assoc-ref inputs "libtiff")
                            "/lib/libtiff.so\"\n") f)
            (display
             (string-append "const libtiffxx = \""
                            (assoc-ref inputs "libtiff")
                            "/lib/libtiffxx.so\"\n") f)
            (display
             (string-append "const libMagickWand = \""
                            (assoc-ref inputs "imagemagick")
                            "/lib/libMagickWand.so\"\n") f)
            (display
             (string-append "check_deps() = nothing\n") f)
            (close-port f))
          #t)))))    
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaIO/ImageMagick.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-abstractplotting
  (package
    (name "julia-abstractplotting")
    (version "0.9.10")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaPlots/AbstractPlotting.jl")
             (commit (string-append "v" version))))
       (file-name "AbstractPlotting")
       (sha256
        (base32 "1ix65v1f8vz8sc5hxla7s9hrchlsx04csm0bs02s9gzyzj4czkf4"))))
    (propagated-inputs `(("julia-fileio" ,julia-fileio)
                         ("julia-observables" ,julia-observables)
                         ("julia-contour" ,julia-contour)
                         ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
                         ("julia-showoff" ,julia-showoff)
                         ("julia-plotutils" ,julia-plotutils)
                         ("julia-intervalsets" ,julia-intervalsets)
                         ("julia-packing" ,julia-packing)
                         ("julia-signeddistancefields" ,julia-signeddistancefields)
                         ("julia-freetype" ,julia-freetype)
                         ("julia-colortypes" ,julia-colortypes)
                         ("julia-geometrytypes" ,julia-geometrytypes)
                         ("julia-colorbrewer" ,julia-colorbrewer)
                         ("julia-colors" ,julia-colors)
                         ("julia-staticarrays" ,julia-staticarrays)
                         ("julia-unicodefun" ,julia-unicodefun)
                         ("julia-freetypeabstraction" ,julia-freetypeabstraction)
                         ("julia-fontconfig" ,julia-fontconfig)
                         ("julia-docstringextensions" ,julia-docstringextensions)
                         ("julia-ffmpeg" ,julia-ffmpeg)
                         ("julia-imagemagick" ,julia-imagemagick)
                         ("julia-structarrays" ,julia-structarrays)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPlots/AbstractPlotting.jl")
    (synopsis "")
    (description "")
    (license license:expat)))


(define-public julia-statsmakie
  (package
    (name "julia-statsmakie")
    (version "0.0.6")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaPlots/StatsMakie.jl.git")
	     (commit (string-append "v" version))))
       (file-name "StatsMakie")
       (sha256
	(base32 "1ppxl7bf1x0wf0xsdx1w8kga9pz5cclmka55f7darvrxszb10xfx"))))
    (propagated-inputs `(("julia-observables" ,julia-observables)
			 ("julia-intervalsets" ,julia-intervalsets)
			 ("julia-distributions" ,julia-distributions)
			 ("julia-namedarrays" ,julia-namedarrays)
			 ("julia-kerneldensity" ,julia-kerneldensity)
			 ("julia-statsbase" ,julia-statsbase)
			 ("julia-tables" ,julia-tables)
			 ("julia-abstractplotting" ,julia-abstractplotting)
			 ("julia-loess" ,julia-loess)
			 ("julia-freqtables" ,julia-freqtables)
			 ("julia-fileio" ,julia-fileio)
			 ("julia-widgets" ,julia-widgets)
			 ("julia-orderedcollections" ,julia-orderedcollections)
			 ("julia-structarrays" ,julia-structarrays)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPlots/StatsMakie.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-indirectarrays
  (package
    (name "julia-indirectarrays")
    (version "0.5.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaArrays/IndirectArrays.jl.git")
	     (commit (string-append "v" version))))
       (file-name "IndirectArrays")
       (sha256
	(base32 "09gpndb8fc550wv07j4s5vv91rl5x880szlr9zjw18jshrcma4qc"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/IndirectArrays.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-rangearrays
  (package
    (name "julia-rangearrays")
    (version "0.3.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaArrays/RangeArrays.jl.git")
	     (commit (string-append "v" version))))
       (file-name "RangeArrays")
       (sha256
	(base32 "1k040qnxkjf81h352mc7vri6xgw3zkjcq3d8h5188zlc9lspl4qg"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/RangeArrays.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-axisarrays
  (package
    (name "julia-axisarrays")
    (version "0.3.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaArrays/AxisArrays.jl.git")
	     (commit (string-append "v" version))))
       (file-name "AxisArrays")
       (sha256
	(base32 "17qvs2gxn8nmsaxwcjb0vjnig1f04jm33q92ciaaxv8wsw9xqcb0"))))
    (propagated-inputs `(("julia-intervalsets" ,julia-intervalsets)
			 ("julia-rangearrays" ,julia-rangearrays)
			 ("julia-itertools" ,julia-itertools)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/AxisArrays.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-simpletraits
  (package
    (name "julia-simpletraits")
    (version "0.9.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/mauro3/SimpleTraits.jl.git")
	     (commit (string-append "v" version))))
       (file-name "SimpleTraits")
       (sha256
	(base32 "14wgwqpw1nynkc277zdj4gih529mk4qgkqz9inw00h56f85sdc7d"))))
    (propagated-inputs `(("julia-macrotools" ,julia-macrotools)))
    (build-system julia-build-system)
    (home-page "https://github.com/mauro3/SimpleTraits.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-imageaxes
  (package
    (name "julia-imageaxes")
    (version "0.6.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaImages/ImageAxes.jl.git")
	     (commit (string-append "v" version))))
       (file-name "ImageAxes")
       (sha256
	(base32 "06xknlgzg4k98z0vnc67fxbbrxfkw50xri5psbxr098jkgx6ap5a"))))
    (propagated-inputs `(("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
			 ("julia-imagecore" ,julia-imagecore)
			 ("julia-axisarrays" ,julia-axisarrays)
			 ("julia-colors" ,julia-colors)
			 ("julia-reexport" ,julia-reexport)
			 ("julia-simpletraits" ,julia-simpletraits)
			 ("julia-mappedarrays" ,julia-mappedarrays)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaImages/ImageAxes.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-rotations
  (package
    (name "julia-rotations")
    (version "0.12.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/FugroRoames/Rotations.jl.git")
	     (commit (string-append "v" version))))
       (file-name "Rotations")
       (sha256
	(base32 "15qqpbgf7pkh95s2l3sdrzvvvr63rcwv33xb42328z25yvhp7p1h"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
			 ("julia-staticarrays" ,julia-staticarrays)
			 ("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/FugroRoames/Rotations.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-coordinatetransformations
  (package
    (name "julia-coordinatetransformations")
    (version "0.5.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/FugroRoames/CoordinateTransformations.jl.git")
	     (commit (string-append "v" version))))
       (file-name "CoordinateTransformations")
       (sha256
	(base32 "1jm121pmj851gq9i74qsbkkgyak6ggiw9d33znhhwzibkj1yaviz"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
			 ("julia-rotations" ,julia-rotations)
			 ("julia-staticarrays" ,julia-staticarrays)
			 ("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/FugroRoames/CoordinateTransformations.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-identityranges
  (package
    (name "julia-identityranges")
    (version "0.3.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaArrays/IdentityRanges.jl.git")
	     (commit (string-append "v" version))))
       (file-name "IdentityRanges")
       (sha256
	(base32 "1m5fg0vdr1nlmq228b3i2a5xa36xkqhc763sbp8pqbzi0ih1niv5"))))
    (propagated-inputs `(("julia-offsetarrays" ,julia-offsetarrays)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/IdentityRanges.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-imagetransformations
  (package
    (name "julia-imagetransformations")
    (version "0.8.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaImages/ImageTransformations.jl.git")
	     (commit (string-append "v" version))))
       (file-name "ImageTransformations")
       (sha256
	(base32 "00f86zb2s57iz148krxk04j07ji1r623f81z5f7a346lqi2kv0kh"))))
    (propagated-inputs `(("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
			 ("julia-colortypes" ,julia-colortypes)
			 ("julia-offsetarrays" ,julia-offsetarrays)
			 ("julia-imagecore" ,julia-imagecore)
			 ("julia-staticarrays" ,julia-staticarrays)
			 ("julia-colorvectorspace" ,julia-colorvectorspace)
			 ("julia-coordinatetransformations" ,julia-coordinatetransformations)
			 ("julia-colors" ,julia-colors)
			 ("julia-interpolations" ,julia-interpolations)
			 ("julia-identityranges" ,julia-identityranges)
			 ("julia-axisalgorithms" ,julia-axisalgorithms)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaImages/ImageTransformations.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-fftviews
  (package
    (name "julia-fftviews")
    (version "0.3.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaArrays/FFTViews.jl.git")
	     (commit (string-append "v" version))))
       (file-name "FFTViews")
       (sha256
	(base32 "101803202xrp645c1rpx3axzcd75wgmkdcnyl5wd9zpn2id9az1g"))))
    (propagated-inputs `(("julia-fftw" ,julia-fftw)
			 ("julia-customunitranges" ,julia-customunitranges)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/FFTViews.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-tilediteration
  (package
    (name "julia-tilediteration")
    (version "0.2.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaArrays/TiledIteration.jl.git")
	     (commit (string-append "v" version))))
       (file-name "TiledIteration")
       (sha256
	(base32 "1lql8b7isrv8hbgy88125ry2vxd6ixcchh10zz47vdj27r5g6m9w"))))
    (propagated-inputs `(("julia-offsetarrays" ,julia-offsetarrays)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaArrays/TiledIteration.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-computationalresources
  (package
    (name "julia-computationalresources")
    (version "0.3.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/timholy/ComputationalResources.jl.git")
	     (commit (string-append "v" version))))
       (file-name "ComputationalResources")
       (sha256
	(base32 "0x44imamg9khfpbwyirlfiiqkj0k40nn53lr4fnqmm3ljzkhx2hp"))))
    (propagated-inputs `())
    (build-system julia-build-system)
    (home-page "https://github.com/timholy/ComputationalResources.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-imagefiltering
  (package
    (name "julia-imagefiltering")
    (version "0.6.5")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaImages/ImageFiltering.jl.git")
	     (commit (string-append "v" version))))
       (file-name "ImageFiltering")
       (sha256
	(base32 "0fhmm750cn8p7h9d4c44g85290xnwrbd09x68aivmwr37lsxrnmy"))))
    (propagated-inputs `(("julia-fftw" ,julia-fftw)
			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
			 ("julia-offsetarrays" ,julia-offsetarrays)
			 ("julia-fftviews" ,julia-fftviews)
			 ("julia-mappedarrays" ,julia-mappedarrays)
			 ("julia-tilediteration" ,julia-tilediteration)
			 ("julia-datastructures" ,julia-datastructures)
			 ("julia-colorvectorspace" ,julia-colorvectorspace)
			 ("julia-colors" ,julia-colors)
			 ("julia-imagecore" ,julia-imagecore)
			 ("julia-computationalresources" ,julia-computationalresources)
			 ("julia-catindices" ,julia-catindices)
			 ("julia-staticarrays" ,julia-staticarrays)
			 ("julia-requires" ,julia-requires)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaImages/ImageFiltering.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-meshio
  (package
    (name "julia-meshio")
    (version "0.3.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaIO/MeshIO.jl.git")
	     (commit (string-append "v" version))))
       (file-name "MeshIO")
       (sha256
	(base32 "1y21jrg3xpmiqcdb9l497fxyfc7gsw5mfh7fak3hpi3hx7l6092s"))))
    (propagated-inputs `(("julia-fileio" ,julia-fileio)
			 ("julia-colortypes" ,julia-colortypes)
			 ("julia-geometrytypes" ,julia-geometrytypes)
			 ("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaIO/MeshIO.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-moderngl
  (package
    (name "julia-moderngl")
    (version "1.1.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaGL/ModernGL.jl.git")
	     (commit (string-append "v" version))))
       (file-name "ModernGL")
       (sha256
	(base32 "0q2gdh0a3mqdljiywr9q4shrd0mjp740d8w52rfq44zs89c0gl5y"))))
    (propagated-inputs `())
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGL/ModernGL.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-glfw
  (package
    (name "julia-glfw")
    (version "3.1.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaGL/GLFW.jl.git")
	     (commit (string-append "v" version))))
       (file-name "GLFW")
       (sha256
	(base32 "0iajxwv2sqj5prnxypgzv0c6c0pa5qfxp7q71h50kr8wql3dm54r"))))
    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGL/GLFW.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-glmakie
  (package
    (name "julia-glmakie")
    (version "0.0.8")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaPlots/GLMakie.jl.git")
	     (commit (string-append "v" version))))
       (file-name "GLMakie")
       (sha256
	(base32 "0p84krs32p0rjg4rp57m78bkn19h5fxh03c3hnk1k5pm9d1c9aqx"))))
    (propagated-inputs `(("julia-imagefiltering" ,julia-imagefiltering)
			 ("julia-meshio" ,julia-meshio)
			 ("julia-observables" ,julia-observables)
			 ("julia-intervalsets" ,julia-intervalsets)
			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
			 ("julia-itertools" ,julia-itertools)
			 ("julia-indirectarrays" ,julia-indirectarrays)
			 ("julia-freetype" ,julia-freetype)
			 ("julia-axisarrays" ,julia-axisarrays)
			 ("julia-colortypes" ,julia-colortypes)
			 ("julia-colorvectorspace" ,julia-colorvectorspace)
			 ("julia-abstractplotting" ,julia-abstractplotting)
			 ("julia-imagemagick" ,julia-imagemagick)
			 ("julia-moderngl" ,julia-moderngl)
			 ("julia-geometrytypes" ,julia-geometrytypes)
			 ("julia-colors" ,julia-colors)
			 ("julia-fileio" ,julia-fileio)
			 ("julia-imagecore" ,julia-imagecore)
			 ("julia-staticarrays" ,julia-staticarrays)
			 ("julia-glfw" ,julia-glfw)
			 ("julia-freetypeabstraction" ,julia-freetypeabstraction)
			 ("julia-imageaxes" ,julia-imageaxes)
			 ("julia-imagetransformations" ,julia-imagetransformations)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPlots/GLMakie.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-media
  (package
    (name "julia-media")
    (version "0.5.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JunoLab/Media.jl.git")
	     (commit (string-append "v" version))))
       (file-name "Media")
       (sha256
	(base32 "05jq9j3vs8yfj2lwz3sh1vk5rha06xdcikp9s2q3dn316vryy6di"))))
    (propagated-inputs `(("julia-macrotools" ,julia-macrotools)))
    (build-system julia-build-system)
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (add-before 'precompile 'fix-toml
           (lambda* (#:key outputs source #:allow-other-keys)
             (julia-create-package-toml
              outputs source
              "Media"
              "e89f7d12-3494-54d1-8411-f7d8b9ae1f27"
              "0.5.0"
              '())
             #t)))))
    
    (home-page "https://github.com/JunoLab/Media.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-juno
  (package
    (name "julia-juno")
    (version "0.7.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JunoLab/Juno.jl.git")
	     (commit (string-append "v" version))))
       (file-name "Juno")
       (sha256
	(base32 "176b7c3pli9w8nmj3b4d5nw7n0pimxb3kzab6ij946a2wmaq4p2c"))))
    (propagated-inputs `(("julia-media" ,julia-media)))
    (build-system julia-build-system)
    (home-page "https://github.com/JunoLab/Juno.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-functionalcollections
  (package
    (name "julia-functionalcollections")
    (version "0.5.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaCollections/FunctionalCollections.jl.git")
	     (commit (string-append "v" version))))
       (file-name "FunctionalCollections")
       (sha256
	(base32 "1lvb7xaqg1w5cqq1z5jv4fcyagb2psq9k8i7k7n2pz1qf7rwfgcd"))))
    (propagated-inputs `())
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaCollections/FunctionalCollections.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-webio
  (package
    (name "julia-webio")
    (version "0.8.11")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaGizmos/WebIO.jl.git")
	     (commit (string-append "v" version))))
       (file-name "WebIO")
       (sha256
	(base32 "1w5nbigvh0gn5iss2m7x450cfw7863dl1lp63hlic64xh6gj14xw"))))
    (propagated-inputs `(("julia-widgets" ,julia-widgets)
			 ("julia-compat" ,julia-compat)
			 ("julia-json" ,julia-json)
			 ("julia-observables" ,julia-observables)
			 ("julia-functionalcollections" ,julia-functionalcollections)
			 ("julia-requires" ,julia-requires)
			 ("julia-websockets" ,julia-websockets)
			 ("julia-assetregistry" ,julia-assetregistry)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGizmos/WebIO.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-jsexpr
  (package
    (name "julia-jsexpr")
    (version "0.5.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaGizmos/JSExpr.jl.git")
	     (commit (string-append "v" version))))
       (file-name "JSExpr")
       (sha256
	(base32 "0rg5x3sc1h0cl0i6k9pffpi5mwvshn2519xhancmaijjzr6ph792"))))
    (propagated-inputs `(("julia-observables" ,julia-observables)
			 ("julia-macrotools" ,julia-macrotools)
			 ("julia-json" ,julia-json)
			 ("julia-webio" ,julia-webio)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGizmos/JSExpr.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-knockout
  (package
    (name "julia-knockout")
    (version "0.2.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaGizmos/Knockout.jl.git")
	     (commit (string-append "v" version))))
       (file-name "Knockout")
       (sha256
	(base32 "1kwr982n0789yqgq1wdrx8lz4h5c58wldgzfn6am87fllkgbna5l"))))
    (propagated-inputs `(("julia-json" ,julia-json)
			 ("julia-jsexpr" ,julia-jsexpr)
			 ("julia-observables" ,julia-observables)
			 ("julia-webio" ,julia-webio)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGizmos/Knockout.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-cssutil
  (package
    (name "julia-cssutil")
    (version "0.1.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaGizmos/CSSUtil.jl.git")
	     (commit (string-append "v" version))))
       (file-name "CSSUtil")
       (sha256
	(base32 "1dvlwkpbjwwggyx5sh3645sz02yd9h067pcymcam5k4sprx4qdwx"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)
			 ("julia-measures" ,julia-measures)
			 ("julia-json" ,julia-json)
			 ("julia-colors" ,julia-colors)
			 ("julia-webio" ,julia-webio)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGizmos/CSSUtil.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-interactbase
  (package
    (name "julia-interactbase")
    (version "0.10.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/piever/InteractBase.jl.git")
	     (commit (string-append "v" version))))
       (file-name "InteractBase")
       (sha256
	(base32 "087bgg4cx0ag8bgar0lcddiq00f99s95wd0bfj84p01finn8h7fd"))))
    (propagated-inputs `(("julia-json" ,julia-json)
			 ("julia-knockout" ,julia-knockout)
			 ("julia-jsexpr" ,julia-jsexpr)
			 ("julia-colors" ,julia-colors)
			 ("julia-orderedcollections" ,julia-orderedcollections)
			 ("julia-widgets" ,julia-widgets)
			 ("julia-observables" ,julia-observables)
			 ("julia-cssutil" ,julia-cssutil)
			 ("julia-webio" ,julia-webio)))
    (build-system julia-build-system)
    (home-page "https://github.com/piever/InteractBase.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-interact
  (package
    (name "julia-interact")
    (version "0.10.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaGizmos/Interact.jl.git")
	     (commit (string-append "v" version))))
       (file-name "Interact")
       (sha256
	(base32 "0gslw9673jy348lbpi0ypgd116jv0yi1lddlq2lg7ljqyasgygx4"))))
    (propagated-inputs `(("julia-observables" ,julia-observables)
			 ("julia-reexport" ,julia-reexport)
			 ("julia-orderedcollections" ,julia-orderedcollections)
			 ("julia-json" ,julia-json)
			 ("julia-interactbase" ,julia-interactbase)
			 ("julia-widgets" ,julia-widgets)
			 ("julia-knockout" ,julia-knockout)
			 ("julia-cssutil" ,julia-cssutil)
			 ("julia-webio" ,julia-webio)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGizmos/Interact.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-imagedistances
  (package
    (name "julia-imagedistances")
    (version "0.2.4")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaImages/ImageDistances.jl.git")
	     (commit (string-append "v" version))))
       (file-name "ImageDistances")
       (sha256
	(base32 "110pwgjcr1gf0c033svbj367y2mix3415xgkkcc8c0f2amgx7hjy"))))
    (propagated-inputs `(("julia-distances" ,julia-distances)
			 ("julia-imagecore" ,julia-imagecore)
			 ("julia-colorvectorspace" ,julia-colorvectorspace)
			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
			 ("julia-colors" ,julia-colors)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaImages/ImageDistances.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-imagemetadata
  (package
    (name "julia-imagemetadata")
    (version "0.7.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaImages/ImageMetadata.jl.git")
	     (commit (string-append "v" version))))
       (file-name "ImageMetadata")
       (sha256
	(base32 "1rc75w6njz9bi1lvw7jsv4h9inkyma3i9r1b5i7ni091vmy9bciy"))))
    (propagated-inputs `(("julia-axisarrays" ,julia-axisarrays)
			 ("julia-imagecore" ,julia-imagecore)
			 ("julia-colorvectorspace" ,julia-colorvectorspace)
			 ("julia-imageaxes" ,julia-imageaxes)
			 ("julia-indirectarrays" ,julia-indirectarrays)
			 ("julia-colors" ,julia-colors)
			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
			 ("julia-axisarrays" ,julia-axisarrays)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaImages/ImageMetadata.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-imagemorphology
  (package
    (name "julia-imagemorphology")
    (version "0.2.4")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaImages/ImageMorphology.jl.git")
	     (commit (string-append "v" version))))
       (file-name "ImageMorphology")
       (sha256
	(base32 "19miab4kaj1lfwlzwaysnxw3xq8yrn9n1fws7lsj3k05w66xkvgz"))))
    (propagated-inputs `(("julia-imagecore" ,julia-imagecore)
			 ("julia-colors" ,julia-colors)
			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaImages/ImageMorphology.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-imageshow
  (package
    (name "julia-imageshow")
    (version "0.2.1")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaImages/ImageShow.jl.git")
	     (commit (string-append "v" version))))
       (file-name "ImageShow")
       (sha256
	(base32 "0fj003rbpbd5djmdzyl5scizhk6yzxs88g6vkg8b82rzmcgvkzf1"))))
    (propagated-inputs `(("julia-colortypes" ,julia-colortypes)
			 ("julia-offsetarrays" ,julia-offsetarrays)
			 ("julia-fileio" ,julia-fileio)
			 ("julia-imagecore" ,julia-imagecore)
			 ("julia-colors" ,julia-colors)
			 ("julia-requires" ,julia-requires)
			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaImages/ImageShow.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-images
  (package
    (name "julia-images")
    (version "0.18.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaImages/Images.jl.git")
	     (commit (string-append "v" version))))
       (file-name "Images")
       (sha256
	(base32 "0pq87qc25jb6ykbv0d7fnqb73xc0bb1dqcgi9ysisrqlnncwdgdq"))))
    (propagated-inputs `(("julia-staticarrays" ,julia-staticarrays)
			 ("julia-tilediteration" ,julia-tilediteration)
			 ("julia-offsetarrays" ,julia-offsetarrays)
			 ("julia-imagedistances" ,julia-imagedistances)
			 ("julia-imagecore" ,julia-imagecore)
			 ("julia-axisarrays" ,julia-axisarrays)
			 ("julia-imageaxes" ,julia-imageaxes)
			 ("julia-indirectarrays" ,julia-indirectarrays)
			 ("julia-mappedarrays" ,julia-mappedarrays)
			 ("julia-imagefiltering" ,julia-imagefiltering)
			 ("julia-reexport" ,julia-reexport)
			 ("julia-imagemetadata" ,julia-imagemetadata)
			 ("julia-imagetransformations" ,julia-imagetransformations)
			 ("julia-imagemorphology" ,julia-imagemorphology)
			 ("julia-graphics" ,julia-graphics)
			 ("julia-colorvectorspace" ,julia-colorvectorspace)
			 ("julia-colortypes" ,julia-colortypes)
			 ("julia-fileio" ,julia-fileio)
			 ("julia-colors" ,julia-colors)
			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
			 ("julia-imageshow" ,julia-imageshow)
			 ("julia-statsbase" ,julia-statsbase)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaImages/Images.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-factcheck
  (package
    (name "julia-factcheck")
    (version "0.4.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaAttic/FactCheck.jl.git")
	     (commit (string-append "v" version))))
       (file-name "FactCheck")
       (sha256
	(base32 "0y7kx01l252sspyrh3jsrjd5hlzg9w504c01vaszg7376ncng5fj"))))
    (propagated-inputs `(("julia-compat" ,julia-compat)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaAttic/FactCheck.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-reactive
  (package
    (name "julia-reactive")
    (version "0.8.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaGizmos/Reactive.jl.git")
	     (commit (string-append "v" version))))
       (file-name "Reactive")
       (sha256
	(base32 "0a5s1axxdqkvi1w375h215jjmmyq72a0pyjqrbpvr1zikplmzwdc"))))
    (propagated-inputs `(("julia-datastructures" ,julia-datastructures)
			 ("julia-compat" ,julia-compat)
			 ("julia-factcheck" ,julia-factcheck)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGizmos/Reactive.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-glabstraction
  (package
    (name "julia-glabstraction")
    (version "0.6.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaGL/GLAbstraction.jl.git")
	     (commit (string-append "v" version))))
       (file-name "GLAbstraction")
       (sha256
	(base32 "0qab851kp32hw2d13xpg3ryihy0qzmbbldirc4ns5330ickbhzgr"))))
    (propagated-inputs `(("julia-fileio" ,julia-fileio)
			 ("julia-colortypes" ,julia-colortypes)
			 ("julia-geometrytypes" ,julia-geometrytypes)
			 ("julia-glfw" ,julia-glfw)
			 ("julia-moderngl" ,julia-moderngl)
			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
			 ("julia-staticarrays" ,julia-staticarrays)
			 ("julia-reactive" ,julia-reactive)
			 ("julia-quaternions" ,julia-quaternions)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGL/GLAbstraction.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-glwindow
  (package
    (name "julia-glwindow")
    (version "0.7.2")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaGL/GLWindow.jl.git")
	     (commit (string-append "v" version))))
       (file-name "GLWindow")
       (sha256
	(base32 "0wmgc2znn6hms47vf56lckpilz67hqgd2rbdkj0mi9mlcgjrr7x2"))))
    (propagated-inputs `(("julia-geometrytypes" ,julia-geometrytypes)
			 ("julia-staticarrays" ,julia-staticarrays)
			 ("julia-fileio" ,julia-fileio)
			 ("julia-colortypes" ,julia-colortypes)
			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
			 ("julia-reactive" ,julia-reactive)
			 ("julia-glfw" ,julia-glfw)
			 ("julia-moderngl" ,julia-moderngl)
			 ("julia-glabstraction" ,julia-glabstraction)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGL/GLWindow.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-glvisualize
  (package
    (name "julia-glvisualize")
    (version "0.7.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaGL/GLVisualize.jl.git")
	     (commit (string-append "v" version))))
       (file-name "GLVisualize")
       (sha256
	(base32 "126qwx56b18952qkxaq4dr71a7xrmir7smczcsrhszlwy0swqmlf"))))
    (propagated-inputs `(("julia-unicodefun" ,julia-unicodefun)
			 ("julia-colorvectorspace" ,julia-colorvectorspace)
			 ("julia-colors" ,julia-colors)
			 ("julia-glabstraction" ,julia-glabstraction)
			 ("julia-quaternions" ,julia-quaternions)
			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
			 ("julia-reactive" ,julia-reactive)
			 ("julia-signeddistancefields" ,julia-signeddistancefields)
			 ("julia-freetype" ,julia-freetype)
			 ("julia-images" ,julia-images)
			 ("julia-moderngl" ,julia-moderngl)
			 ("julia-geometrytypes" ,julia-geometrytypes)
			 ("julia-fileio" ,julia-fileio)
			 ("julia-glfw" ,julia-glfw)
			 ("julia-glwindow" ,julia-glwindow)
			 ("julia-indirectarrays" ,julia-indirectarrays)
			 ("julia-axisarrays" ,julia-axisarrays)
			 ("julia-imageaxes" ,julia-imageaxes)
			 ("julia-itertools" ,julia-itertools)
			 ("julia-staticarrays" ,julia-staticarrays)
			 ("julia-freetypeabstraction" ,julia-freetypeabstraction)
			 ("julia-packing" ,julia-packing)
			 ("julia-meshio" ,julia-meshio)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGL/GLVisualize.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-abstractnumbers
  (package
    (name "julia-abstractnumbers")
    (version "0.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/SimonDanisch/AbstractNumbers.jl.git")
	     (commit (string-append "v" version))))
       (file-name "AbstractNumbers")
       (sha256
	(base32 "1ahpmvd4g5czgpaww8r8m05dfpha0n26rdpc9vanzvcxh3m221v6"))))
    (propagated-inputs `(("julia-specialfunctions" ,julia-specialfunctions)))
    (build-system julia-build-system)
    (home-page "https://github.com/SimonDanisch/AbstractNumbers.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-makie
  (package
    (name "julia-makie")
    (version "0.9.5")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
	     (url "https://github.com/JuliaPlots/Makie.jl.git")
	     (commit (string-append "v" version))))
       (file-name "Makie")
       (sha256
	(base32 "01751q72vah48jvnql6c4yjygffgm08rsgzilv5g0sx9229anzfl"))))
    (propagated-inputs `(("julia-statsmakie" ,julia-statsmakie)
			 ("julia-showoff" ,julia-showoff)
			 ("julia-intervalsets" ,julia-intervalsets)
			 ("julia-primes" ,julia-primes)
			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
			 ("julia-itertools" ,julia-itertools)
			 ("julia-indirectarrays" ,julia-indirectarrays)
			 ("julia-plotutils" ,julia-plotutils)
			 ("julia-axisarrays" ,julia-axisarrays)
			 ("julia-colortypes" ,julia-colortypes)
			 ("julia-colorvectorspace" ,julia-colorvectorspace)
			 ("julia-colors" ,julia-colors)
			 ("julia-imagecore" ,julia-imagecore)
			 ("julia-imageaxes" ,julia-imageaxes)
			 ("julia-imagetransformations" ,julia-imagetransformations)
			 ("julia-glmakie" ,julia-glmakie)
			 ("julia-abstractplotting" ,julia-abstractplotting)
			 ("julia-fileio" ,julia-fileio)
			 ("julia-imagemagick" ,julia-imagemagick)
			 ("julia-juno" ,julia-juno)
			 ("julia-interact" ,julia-interact)
			 ("julia-images" ,julia-images)
			 ("julia-hiccup" ,julia-hiccup)
			 ("julia-glabstraction" ,julia-glabstraction)
			 ("julia-glvisualize" ,julia-glvisualize)
			 ("julia-media" ,julia-media)
			 ("julia-quaternions" ,julia-quaternions)
			 ("julia-abstractnumbers" ,julia-abstractnumbers)
			 ("julia-glwindow" ,julia-glwindow)))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPlots/Makie.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-adapt
  (package
   (name "julia-adapt")
   (version "1.0.0")
   (source
      (origin
        (method git-fetch)
        (uri (git-reference
          (url "https://github.com/JuliaGPU/Adapt.jl.git")
          (commit (string-append "v" version))))
        (file-name "Adapt")
        (sha256
             (base32 "0wpcsck9gi5imqp9yzhxllkfdw5fjy8iszhzzpkp7vld24zc4li0"))))
   (propagated-inputs `())
   (build-system julia-build-system)
   (home-page "https://github.com/JuliaGPU/Adapt.jl.git")
   (synopsis "")
   (description "")
   (license license:expat)))

(define-public julia-crayons
  (package
   (name "julia-crayons")
   (version "4.0.0")
   (source
      (origin
        (method git-fetch)
        (uri (git-reference
          (url "https://github.com/KristofferC/Crayons.jl.git")
          (commit (string-append "v" version))))
        (file-name "Crayons")
        (sha256
             (base32 "1sl20zpyk5kpdbal3jzmw76w5r02cigi7gdlpnc06cz2ciz8131i"))))
   (propagated-inputs `())
   (build-system julia-build-system)
   (home-page "https://github.com/KristofferC/Crayons.jl.git")
   (synopsis "")
   (description "")
   (license license:expat)))

(define-public julia-timeroutputs
  (package
   (name "julia-timeroutputs")
   (version "0.5.0")
   (source
      (origin
        (method git-fetch)
        (uri (git-reference
              (url "https://github.com/KristofferC/TimerOutputs.jl.git")
              ;; Project.toml after 0.5.0 release
              (commit "72e57014edda8a6f4237a7ab29dfeb0eeba7dc19")))
        (file-name "TimerOutputs")
        (sha256
             (base32 "10ca1dp51b7s5a1iq7003ys67yxnx0v6js00hz0gd6lwmgc8kxhv"))))
   (propagated-inputs `(("julia-crayons" ,julia-crayons)))
   (build-system julia-build-system)
   (home-page "https://github.com/KristofferC/TimerOutputs.jl.git")
   (synopsis "")
   (description "")
   (license license:expat)))

(define-public julia-nnlib
  (package
    (name "julia-nnlib")
    (version "0.6.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/FluxML/NNlib.jl.git")
             (commit (string-append "v" version))))
       (file-name "NNlib")
       (sha256
        (base32 "15vk98x2wj7vgzp5s96yddd6hrayq1g5s1ifd73m33kfwsmgykjq"))))
    ;; FIXME: some tests must be enabled with: NNLIB_TEST_FUZZING=true
    (propagated-inputs `(("julia-timeroutputs" ,julia-timeroutputs)
                         ("julia-requires" ,julia-requires)))
    (build-system julia-build-system)
    (home-page "https://github.com/FluxML/NNlib.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-zipfile
  (package
    (name "julia-zipfile")
    (version "0.8.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/fhs/ZipFile.jl.git")
             (commit (string-append "v" version))))
       (file-name "ZipFile")
       (sha256
        (base32 "0f09l02nvcp4r99id3l4ll5vrmjj28ixb83bcispcj7cks8il42h"))))
    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)))
    (build-system julia-build-system)
    (home-page "https://github.com/fhs/ZipFile.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-cudaapi
  (package
    (name "julia-cudaapi")
    (version "1.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaGPU/CUDAapi.jl.git")
             (commit (string-append "v" version))))
       (file-name "CUDAapi")
       (sha256
        (base32 "02wj7dqwvjwpdcpvaimhdil6q4iw06g6af32g90m83lr33226njc"))))
    (arguments `(#:tests? #f))          ; We don't have a cuda package, but
                                        ; cudaapi is required by flux even if
                                        ; you do not want to use the gpu. We
                                        ; should make a custom one with
                                        ; disabled tests
    (propagated-inputs `())
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaGPU/CUDAapi.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-cuarrays
  (package
   (name "julia-cuarrays")
   (version "1.2.1")
   (source
      (origin
        (method git-fetch)
        (uri (git-reference
          (url "https://github.com/JuliaGPU/CuArrays.jl.git")
          (commit (string-append "v" version))))
        (file-name "CuArrays")
        (sha256
             (base32 "0p1yg8icypg383kp2fb1xshp0l7xqkf7b5xlrrx9dd7sdawrak5j"))))
   (propagated-inputs `())
   (build-system julia-build-system)
   (home-page "https://github.com/JuliaGPU/CuArrays.jl.git")
   (synopsis "")
   (description "")
   (license license:expat)))

(define-public julia-tracker
  (package
    (name "julia-tracker")
    (version "0.2.3")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/FluxML/Tracker.jl.git")
             (commit (string-append "v" version))))
       (file-name "Tracker")
       (sha256
        (base32 "0dysrr99sp7gsqb9ksxpbf2w3izl5rxk404nj43clkmm2ldmxy15"))))
    (propagated-inputs `(("julia-forwarddiff" ,julia-forwarddiff)
                         ("julia-diffrules" ,julia-diffrules)
                         ("julia-macrotools" ,julia-macrotools)
                         ("julia-specialfunctions" ,julia-specialfunctions)
                         ("julia-nnlib" ,julia-nnlib)
                         ("julia-requires" ,julia-requires)
                         ("julia-adapt" ,julia-adapt)
                         ("julia-nanmath" ,julia-nanmath)))
    (build-system julia-build-system)
    (home-page "https://github.com/FluxML/Tracker.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-flux
  (package
    (name "julia-flux")
    (version "0.9.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/FluxML/Flux.jl.git")
             (commit (string-append "v" version))))
       (file-name "Flux")
       (sha256
        (base32 "1hawaznk1ppl3c515f53ha16dlm3hycmrvxkgvw0vk9xa08h5x77"))))
    (propagated-inputs `(("julia-statsbase" ,julia-statsbase)
                         ("julia-codeczlib" ,julia-codeczlib)
                         ("julia-colors" ,julia-colors)
                         ("julia-adapt" ,julia-adapt)
                         ("julia-nnlib" ,julia-nnlib)
                         ("julia-abstracttrees" ,julia-abstracttrees)
                         ("julia-zipfile" ,julia-zipfile)
                         ("julia-reexport" ,julia-reexport)
                         ("julia-cudaapi" ,(package (inherit julia-cudaapi)
                                                    (arguments
                                                     '(#:tests? #f))))
                         ;; ("julia-cuarrays" ,julia-cuarrays)
                         ("julia-juno" ,julia-juno)
                         ("julia-tracker" ,julia-tracker)
                         ("julia-sha" ,julia-sha)
                         ("julia-macrotools" ,julia-macrotools)))
    (build-system julia-build-system)
    (home-page "https://github.com/FluxML/Flux.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-numericio
  (package
   (name "julia-numericio")
   (version "0.3.1")
   (source
      (origin
        (method git-fetch)
        (uri (git-reference
          (url "https://github.com/ma-laforge/NumericIO.jl.git")
          (commit (string-append "v" version))))
        (file-name "NumericIO")
        (sha256
             (base32 "1gfqzbraap9pdj59369wq4nc1ms4qrcx4cmlff4nh5dn5xzrjm51"))))
   (propagated-inputs `())
   (build-system julia-build-system)
   (home-page "https://github.com/ma-laforge/NumericIO.jl.git")
   (synopsis "")
   (description "")
   (license license:expat)))

(define-public julia-inspectdr
  (package
    (name "julia-inspectdr")
    (version "0.3.6")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/ma-laforge/InspectDR.jl")
             (commit (string-append "v" version))))
       (file-name "InspectDR")
       (sha256
        (base32 "07s322w8cc6lflg611bcw036f6j0kf80nr8i23vk2fvpvqwkyybi"))))
    (propagated-inputs `(("julia-numericio" ,julia-numericio)
                         ("julia-colors" ,julia-colors)
                         ("julia-gtk" ,julia-gtk)
                         ("julia-cairo" ,julia-cairo)
                         ("julia-graphics" ,julia-graphics)))
    (build-system julia-build-system)
    (arguments '(#:tests? #f
                 #:phases
                 (modify-phases %standard-phases
                   ;; Precompilation tries to open display
                   (delete 'precompile))))
    (home-page "https://github.com/ma-laforge/InspectDR.jl")
    (synopsis "")
    (description "")
    (license license:expat)))

(define-public julia-filepathsbase
  (package
   (name "julia-filepathsbase")
   (version "0.7.0")
   (source
      (origin
        (method git-fetch)
        (uri (git-reference
          (url "https://github.com/rofinn/FilePathsBase.jl.git")
          (commit (string-append "v" version))))
        (file-name "FilePathsBase")
        (sha256
             (base32 "1z6v69vpnc6vc2438d0s14gwyl9n1wxsmqfjcrinl9wmif21akk4"))))
   (propagated-inputs `())
   (build-system julia-build-system)
   (home-page "https://github.com/rofinn/FilePathsBase.jl.git")
   (synopsis "")
   (description "")
   (license license:expat)))

(define-public julia-csv
  (package
    (name "julia-csv")
    (version "0.5.14")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/JuliaData/CSV.jl.git")
             (commit (string-append "v" version))))
       (file-name "CSV")
       (sha256
        (base32 "1xjn7zr54jb49mc8xa5yi392cfcczzy16rzc2fjbrw64l4rxzd3z"))))
    (propagated-inputs `(("julia-lazyarrays" ,julia-lazyarrays)
                         ("julia-filepathsbase" ,julia-filepathsbase)
                         ("julia-tables" ,julia-tables)
                         ("julia-weakrefstrings" ,julia-weakrefstrings)
                         ("julia-dataframes" ,julia-dataframes)
                         ("julia-categoricalarrays" ,julia-categoricalarrays)
                         ("julia-parsers" ,julia-parsers)
                         ("julia-pooledarrays" ,julia-pooledarrays)))
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (delete 'reset-gzip-timestamps))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaData/CSV.jl.git")
    (synopsis "")
    (description "")
    (license license:expat)))