;;; 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 compression)
  #:use-module (gnu packages xml)
  #:use-module (gnu packages tls))

(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-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-sha
  (package
    (name "julia-sha")
    (version "0.5.7")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/staticfloat/SHA.jl")
             (commit (string-append "v" version))))
       (file-name "SHA")
       (sha256
        (base32 "10a09kg9z0m8rvwmlgsna6p342kyvizx2axdqc6pzyhraddr8jrp"))))
    (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
     `(#:phases
       ;; wants to download things with curl/wget
       (modify-phases %standard-phases (delete 'precompile))))
    (build-system julia-build-system)
    (home-page "https://github.com/JuliaPackaging/BinaryProvider.jl.git")
    (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
     `(#: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-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"))))
    (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-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-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)))
    (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)))
    (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)))
    (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)))
    (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)))
    (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)))
    (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-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-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)))
    (arguments
     `(#: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"))))
    (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-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)))
    (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-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-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")
             (commit (string-append "v" version))))
       (file-name "CSTParser")
       (sha256
        (base32 "04g9k646zv5adps5491mkksa71lfzrnvmd8qi8j6gpl1cd4as3qi"))))
    (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.Julia code and expressions.")
    (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)))
    (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")
    (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)))
    (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
     `(#: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)))