[bug#36856] build: Add julia-build-system

unofficial mirror of guix-patches@gnu.org 
 help / color / mirror / code / Atom feed

* [bug#36856] build: Add julia-build-system
@ 2019-07-30 12:49 Nicolò Balzarotti
  2019-07-30 14:08 ` Ricardo Wurmus
  2019-07-30 14:11 ` Ricardo Wurmus
  0 siblings, 2 replies; 9+ messages in thread
From: Nicolò Balzarotti @ 2019-07-30 12:49 UTC (permalink / raw)
  To: 36856


[-- Attachment #1.1: Type: text/plain, Size: 2769 bytes --]

Hello people! :)

Lately I've been working a bit on julia packages support in guix.

The good news first: I've been able to install dozen of them, including
those depending on binaryprovider with simple workarounds.
1. By writing manually the deps.jl file (the one that saves the path of
dynamic libraries in a julia const)
2. By "manually" writing required Package.toml files for old packages that
are not using it yet (else julia cannot find them)
3. By adding a simple startup.jl script, inspired by what emacs does. This
is simplified so I'm not sure it works for every corner case.
#+begin_src julia
let paths = [expanduser("~/.guix-profile"), "/run/current-system/profile"]
    ("GUIX_ENVIRONMENT" in keys(ENV)) && push!(paths,
ENV["GUIX_ENVIRONMENT"])
    empty!(LOAD_PATH)
    push!.(Ref(LOAD_PATH), joinpath.(paths, "share/julia/packages/"))
    push!(LOAD_PATH, "@stdlib")
    push!.(Ref(DEPOT_PATH), joinpath.(paths, "share/julia/"))
    nothing
end
#+end_src

With those, I've been able to install the following (with their
dependencies):
- Plots.jl (GR.jl backend)
- HTTP.jl
- Gtk.jl
- Gumbo.jl/Cascadia.jl
- FileIO.jl
- CSVFiles.jl ;; TODO: Fix warnings
- JSON.jl
- JSON2.jl
- MsgPack.jl
- DataFrames.jl
- Query.jl
- SQLite.jl
- Interact.jl

There is a phase called 'precompile' even if I could not get julia actually
use the precompiled packages. This is similar to what emacs does (.el ->
.elc). Even if currently this cache is not used, is useful to have this
phase to verify that package import works.

Now the bad news: this patch is really big (mostly because I wanted to be
sure that in principle installing every package is possible. Before
splitting the second patch into multiple small ones, I wanted to be sure
that what I'm doing is somewhat correct.

Also, even if I was able to install those by using a separate folder (with
guix environment -L .), I'm getting this error now, and I don't know what
is causing it (since I'm not touching those files):

#+begin_example
   626:19  2 (_ #<directory (gnu packages gnuzilla) 805fd20>)
   293:34  1 (_ #(#(#(#(#(#(#(#(#(#(#(#(#<directory (gnu packages gnuzilla)
805fd20> "60.8.0") "60") "8") "0") "60.8.0esr") #<origin "
https://ftp.mozilla.org/pub/firefox/releas?>) #) #) #) #) #) #))
    159:9  0 (_ #(#(#(#(#(#(#(#(#(#(#(#(#<directory (gnu packages gnuzilla)
805fd20> "60.8.0") "60") "8") "0") "60.8.0esr") #<origin "
https://ftp.mozilla.org/pub/firefox/releas?>) #) #) #) #) #) #))

ice-9/eval.scm:159:9: Throw to key `srfi-34' with args `(#<condition
&message [message: "icecat-makeicecat.patch: patch not found"] 8eeae0>)'.
#+end_example

I hope somebody is willed to help getting this in a good state :)
Thanks, Nicolò!

[-- Attachment #1.2: Type: text/html, Size: 3557 bytes --]

[-- Attachment #2: 0001-build-Add-julia-build-system.patch --]
[-- Type: text/x-patch, Size: 11454 bytes --]

From cd38a16fbc9f78a8eda90c215a6d69a54f9e6c28 Mon Sep 17 00:00:00 2001
From: nixo <nicolo@nixo.xyz>
Date: Mon, 29 Jul 2019 18:45:26 +0200
Subject: [PATCH 1/2] build: Add julia-build-system.

* guix/build/julia-build-system.scm: New file.
* guix/build-system/julia.scm: New file.
* Makefile.am: Added new files.
---
 Makefile.am                       |   2 +
 guix/build-system/julia.scm       | 106 +++++++++++++++++++++
 guix/build/julia-build-system.scm | 147 ++++++++++++++++++++++++++++++
 3 files changed, 255 insertions(+)
 create mode 100644 guix/build-system/julia.scm
 create mode 100644 guix/build/julia-build-system.scm

diff --git a/Makefile.am b/Makefile.am
index 0bd85e8fcf..d14487045a 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -125,6 +125,7 @@ MODULES =					\
   guix/build-system/gnu.scm			\
   guix/build-system/guile.scm			\
   guix/build-system/haskell.scm			\
+  guix/build-system/julia.scm			\
   guix/build-system/linux-module.scm		\
   guix/build-system/node.scm			\
   guix/build-system/perl.scm			\
@@ -183,6 +184,7 @@ MODULES =					\
   guix/build/texlive-build-system.scm		\
   guix/build/waf-build-system.scm		\
   guix/build/haskell-build-system.scm		\
+  guix/build/julia-build-system.scm		\
   guix/build/linux-module-build-system.scm	\
   guix/build/store-copy.scm			\
   guix/build/json.scm				\
diff --git a/guix/build-system/julia.scm b/guix/build-system/julia.scm
new file mode 100644
index 0000000000..a54b0f37f1
--- /dev/null
+++ b/guix/build-system/julia.scm
@@ -0,0 +1,106 @@
+(define-module (guix build-system julia)
+  #:use-module ((guix build julia-build-system))
+  #:use-module (gnu packages julia)
+  #:use-module (guix store)
+  #:use-module (guix utils)
+  #:use-module (guix packages)
+  #:use-module (guix derivations)
+  #:use-module (guix search-paths)
+  #:use-module (guix build-system)
+  #:use-module (guix build-system gnu)
+  #:use-module (ice-9 match)
+  #:use-module (srfi srfi-26)
+  #:export (%julia-build-system-modules
+            julia-build
+            julia-build-system))
+
+(define %julia-build-system-modules
+  ;; Build-side modules imported by default.
+  `((guix build julia-build-system)
+    ,@%gnu-build-system-modules))
+
+(define* (lower name
+                #:key source inputs native-inputs outputs system target
+                (julia julia)
+                #:allow-other-keys
+                #:rest arguments)
+  "Return a bag for NAME."
+  (define private-keywords
+    '(#:target #:julia #:inputs #:native-inputs))
+
+  (and (not target)			;XXX: no cross-compilation
+       (bag
+	(name name)
+	(system system)
+	(host-inputs `(,@(if source
+			     `(("source" ,source))
+			     '())
+		       ,@inputs
+		       ;; Keep the standard inputs of 'gnu-build-system'.
+		       ,@(standard-packages)))
+	(build-inputs `(("julia" ,julia)
+			,@native-inputs))
+	(outputs outputs)
+	(build julia-build)
+	(arguments (strip-keyword-arguments private-keywords arguments)))))
+
+(define* (julia-build store name inputs
+                      #:key source
+                      (tests? #f)
+                      (parallel-tests? #t)
+                      (test-command ''("make" "check"))
+                      (phases '(@ (guix build julia-build-system)
+                                  %standard-phases))
+                      (outputs '("out"))
+                      ;; (include (quote %default-include))
+                      ;; (exclude (quote %default-exclude))
+                      (search-paths '())
+                      (system (%current-system))
+                      (guile #f)
+                      (imported-modules %julia-build-system-modules)
+                      (modules '((guix build julia-build-system)
+                                 (guix build utils))))
+  "Build SOURCE using Julia, and with INPUTS."
+  (define builder
+    `(begin
+       (use-modules ,@modules)
+       (julia-build #:name ,name
+                    #:source ,(match (assoc-ref inputs "source")
+                                (((? derivation? source))
+                                 (derivation->output-path source))
+                                ((source)
+                                 source)
+                                (source
+                                 source))
+                    #:system ,system
+                    #:test-command ,test-command
+                    #:tests? ,tests?
+                    #:phases ,phases
+                    #:outputs %outputs
+                    ;; #:include ,include
+                    ;; #:exclude ,exclude
+                    #:search-paths ',(map search-path-specification->sexp
+                                          search-paths)
+                    #:inputs %build-inputs)))
+
+  (define guile-for-build
+    (match guile
+      ((? package?)
+       (package-derivation store guile system #:graft? #f))
+      (#f                                         ; the default
+       (let* ((distro (resolve-interface '(gnu packages commencement)))
+              (guile  (module-ref distro 'guile-final)))
+         (package-derivation store guile system #:graft? #f)))))
+
+  (build-expression->derivation store name builder
+                                #:inputs inputs
+                                #:system system
+                                #:modules imported-modules
+                                #:outputs outputs
+                                #:guile-for-build guile-for-build))
+
+(define julia-build-system
+  (build-system
+   (name 'julia)
+   (description "The build system for Julia packages")
+   (lower lower)))
diff --git a/guix/build/julia-build-system.scm b/guix/build/julia-build-system.scm
new file mode 100644
index 0000000000..5f222f0850
--- /dev/null
+++ b/guix/build/julia-build-system.scm
@@ -0,0 +1,147 @@
+(define-module (guix build julia-build-system)
+  #:use-module ((guix build gnu-build-system) #:prefix gnu:)
+  #:use-module (guix build utils)
+  ;; #:use-module (srfi srfi-1)
+  ;; #:use-module (srfi srfi-11)
+  ;; #:use-module (srfi srfi-26)
+  ;; #:use-module (ice-9 rdelim)
+  ;; #:use-module (ice-9 regex)
+  #:use-module (ice-9 match)
+  #:export (%standard-phases
+	    julia-create-package-toml
+            julia-build))
+
+;; (define* (set-emacs-load-path #:key source inputs #:allow-other-keys)
+;;   (define (inputs->directories inputs)
+;;     "Extract the directory part from INPUTS."
+;;     (match inputs
+;;       (((names . directories) ...) directories)))
+
+;;   (define (input-directory->el-directory input-directory)
+;;     "Return the correct Emacs Lisp directory in INPUT-DIRECTORY or #f, if there
+;; is no Emacs Lisp directory."
+;;     (let ((legacy-elisp-directory (string-append input-directory %legacy-install-suffix))
+;;           (guix-elisp-directory
+;;            (string-append
+;;             input-directory %install-suffix "/"
+;;             (store-directory->elpa-name-version input-directory))))
+;;       (cond
+;;        ((file-exists? guix-elisp-directory) guix-elisp-directory)
+;;        ((file-exists? legacy-elisp-directory) legacy-elisp-directory)
+;;        (else #f))))
+
+;;   (define (input-directories->el-directories input-directories)
+;;     "Return the list of Emacs Lisp directories in INPUT-DIRECTORIES."
+;;     (filter-map input-directory->el-directory input-directories))
+
+;;   "Set the EMACSLOADPATH environment variable so that dependencies are found."
+;;   (let* ((source-directory (getcwd))
+;;          (input-elisp-directories (input-directories->el-directories
+;;                                    (inputs->directories inputs)))
+;;          (emacs-load-path-value
+;;           (string-join
+;;            (append input-elisp-directories (list source-directory))
+;;            ":" 'suffix)))
+;;     (setenv "EMACSLOADPATH" emacs-load-path-value)
+;;     (format #t "environment variable `EMACSLOADPATH' set to ~a\n"
+;;             emacs-load-path-value)))
+
+
+(define* (install #:key outputs source #:allow-other-keys)
+  (let* ((out (assoc-ref outputs "out"))
+	 (package-dir (string-append out "/share/julia/packages/"
+				     (string-append
+				      (strip-store-file-name source)))))
+    (mkdir-p package-dir)
+    (copy-recursively source package-dir))
+  #t)
+
+;; FIXME: Precompilation is working, but I don't know how to tell
+;; julia to use use it. If setting HOME to
+;; /gnu/store/xib48jxkhiy0gylnm3q430zfwk6am47h-profile/share/julia/compiled/,
+;; julia tries to write files there
+(define* (precompile #:key outputs source inputs #:allow-other-keys)
+  (define (inputs->directories inputs)
+    "Extract the directory part from INPUTS."
+    (match inputs
+      (((names . directories) ...) directories)))
+  (let* ((out (assoc-ref outputs "out"))
+	 (builddir (string-append out "/share/julia/"))
+	 (pacakge (strip-store-file-name source)))
+    (mkdir-p builddir)
+    (setenv "JULIA_DEPOT_PATH" builddir)
+    (setenv "JULIA_LOAD_PATH"
+	    (string-append
+	     "@stdlib:"
+	     (string-append out "/share/julia/packages/:")
+	     (string-join (inputs->directories inputs) "/share/julia/packages/:")))
+    ;; (invoke "julia" "-e" (string-append "println(LOAD_PATH)"))
+    (invoke "julia" "-e" (string-append "using " pacakge))
+    )
+  #t)
+
+;; (define* (check #:key outputs source inputs #:allow-other-keys)
+;;   (define (inputs->directories inputs)
+;;     "Extract the directory part from INPUTS."
+;;     (match inputs
+;;       (((names . directories) ...) directories)))
+;;   (let* ((out (assoc-ref outputs "out"))
+;; 	 (builddir (string-append out "/share/julia/"))
+;; 	 (pacakge (strip-store-file-name source)))
+;;     (mkdir-p builddir)
+;;     (setenv "JULIA_DEPOT_PATH" builddir)
+;;     (setenv "JULIA_LOAD_PATH"
+;;     	    (string-append
+;; 	     "@:@v#.#:@stdlib:"
+;;     	     (string-append out "/share/julia/packages/:")
+;;     	     (string-join (inputs->directories inputs) "/share/julia/packages/:")))
+;;     ;; (invoke "julia" "-e" (string-append "println(LOAD_PATH)"))
+;;     (invoke "julia" "-e" (string-append "using Pkg; Pkg.test(\"" pacakge "\")"))
+;;     )
+;;   #t)
+
+;;* 
+(define (julia-create-package-toml outputs source
+				   name uuid version
+				   deps) 
+  (let ((f (open-file
+	    (string-append
+	     (assoc-ref outputs "out")
+	     "/share/julia/packages/"
+	     (string-append
+	      name "/Project.toml"))
+	    "w")))
+    (display (string-append
+	      "
+name = \"" name "\"
+uuid = \"" uuid "\"
+version = \"" version "\"
+") f)
+    (when (not (null? deps))
+      (display "[deps]\n" f)
+      (for-each (lambda dep
+		  (display (string-append (car (car dep)) " = \"" (cdr (car dep)) "\"\n")
+			   f))
+		deps))
+    (close-port f))
+  #t)
+
+(define %standard-phases
+  (modify-phases gnu:%standard-phases
+    (replace 'install install)
+    (add-after 'install 'precompile precompile)
+    ;; (replace 'check check)
+    ;; (add-after 'unpack 'set-julia-load-path set-julia-load-path)
+    (delete 'configure)
+    (delete 'bootstrap)
+    (delete 'patch-usr-bin-file)
+    (delete 'build)
+    (delete 'reset-gzip-timestamps)
+    (delete 'check)))
+
+(define* (julia-build #:key inputs (phases %standard-phases)
+                      #:allow-other-keys #:rest args)
+  "Build the given Julia package, applying all of PHASES in order."
+  (apply gnu:gnu-build
+         #:inputs inputs #:phases phases
+         args))
-- 
2.22.0


[-- Attachment #3: 0002-add-many-julia-packages.patch --]
[-- Type: text/x-patch, Size: 118866 bytes --]

From 5a7a235e2aa81f2b7a65a7101f79f862d1b06e7d Mon Sep 17 00:00:00 2001
From: nixo <nicolo@nixo.xyz>
Date: Tue, 30 Jul 2019 14:33:23 +0200
Subject: [PATCH 2/2] add many julia packages

---
 gnu/local.mk               |    1 +
 gnu/packages/julia-xyz.scm | 3510 ++++++++++++++++++++++++++++++++++++
 2 files changed, 3511 insertions(+)
 create mode 100644 gnu/packages/julia-xyz.scm

diff --git a/gnu/local.mk b/gnu/local.mk
index bd509647dc..8499d5b382 100644
--- a/gnu/local.mk
+++ b/gnu/local.mk
@@ -265,6 +265,7 @@ GNU_SYSTEM_MODULES =				\
   %D%/packages/jrnl.scm				\
   %D%/packages/jose.scm				\
   %D%/packages/julia.scm			\
+  %D%/packages/julia-xyz.scm			\
   %D%/packages/kawa.scm				\
   %D%/packages/kde.scm				\
   %D%/packages/kde-frameworks.scm		\
diff --git a/gnu/packages/julia-xyz.scm b/gnu/packages/julia-xyz.scm
new file mode 100644
index 0000000000..770d2eb6e7
--- /dev/null
+++ b/gnu/packages/julia-xyz.scm
@@ -0,0 +1,3510 @@
+(define-module (gnu packages julia-xyz)
+  #:use-module ((guix licenses) #:prefix license:)
+  #:use-module (guix packages)
+  #:use-module (guix download)
+  #:use-module (guix utils)
+  #:use-module (guix git-download)
+  #:use-module (guix build-system julia)
+  #:use-module (gnu packages)
+  #:use-module (gnu packages julia)
+  #:use-module (gnu packages version-control)
+  #:use-module (ice-9 match)
+  ;; pacakge dependencies
+  #:use-module (gnu packages compression)
+  #:use-module (gnu packages curl)
+  #:use-module (gnu packages glib)
+  #:use-module (gnu packages tls)
+  #:use-module (gnu packages video)
+  #:use-module (gnu packages gtk)
+  #:use-module (gnu packages python-xyz)
+  #:use-module (gnu packages web)
+  #:use-module (gnu packages maths)
+  #:use-module (gnu packages sqlite)
+  )
+
+;; Working top-level packages:
+;; - Plots.jl (GR.jl backend)
+;; - HTTP.jl
+;; - Gtk.jl
+;; - Gumbo.jl/Cascadia.jl
+;; - FileIO.jl
+;; - CSVFiles.jl ;; TODO: Fix warnings
+;; - JSON.jl
+;; - JSON2.jl
+;; - MsgPack.jl
+;; - DataFrames.jl
+;; - Query.jl
+;; - SQLite.jl
+;; - Interact.jl
+;; ;; - WIP GtkReactive.jl
+;; problems:
+;; - Revise.jl: no laoded projects, issues a warning
+;; - IJulia.jl: I'm not myself an Ijulia user, but it would nice to support it.
+;;   however it seems to want to install things to the XDG_DATA_HOME path, JUPYTER_DATA_DIR
+;; Those examples should explain how to add new packages and how to
+;; fix possible problems
+
+;;; TO GET IT WORKING, add this to your ~/.julia/config/startup.jl file
+
+;; let paths = [expanduser("~/.guix-profile"), "/run/current-system/profile"]
+;;     ("GUIX_ENVIRONMENT" in keys(ENV)) && push!(paths, ENV["GUIX_ENVIRONMENT"])
+;;     empty!(LOAD_PATH)
+;;     # f = popfirst!(DEPOT_PATH)
+;;     push!.(Ref(LOAD_PATH), joinpath.(paths, "share/julia/packages/"))
+;;     push!(LOAD_PATH, "@stdlib")
+;;     push!.(Ref(DEPOT_PATH), joinpath.(paths, "share/julia/"))
+;;     # push!(DEPOT_PATH, f)
+;;     nothing
+;; end
+
+;;; This is inspired by emacs-xyz and how emacs finds dependencies at
+;;; startup.  It's simplified but seems to do the job, for now.  Also,
+;;; julia will still precompile things to a folder inside $HOME
+;;; ($HOME/.julia/compiled).  Precompilation during install is not
+;;; possible (julia at runtime will still precompile to the home
+;;; directory. Chainging the home directory to the $GUIX_ENVIRONMENT
+;;; path does not work because it's readonly and julia wants to write
+;;; there. So for now, to ensure a clean environment, run julia with
+;;; HOME=$(mktemp -d) julia.
+;;; TODO: Find a better way (e.g., patching julia)
+
+(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.git")
+		    ;; master branch does not have a Project.toml file
+		    (commit "8ba59958495fa276d6489d2c3903e765d75e0bc0")))
+	      (file-name "IniFile")
+	      (sha256
+	       (base32 "11h6f99jpbg729lplw841m68jprka7q3n8yw390bndlmcdsjabpd"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaIO/IniFile.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-compat
+  (package
+    (name "julia-compat")
+    (version "2.1.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaLang/Compat.jl.git")
+		    (commit "a6b2831c438bf9f06f5ddbfdd43c5368a776eab4")))
+	      (file-name "Compat")
+	      (sha256
+	       (base32 "1ynl99w3ylhvzrwx2wbfvmxlz4jx7vwck2nh7j88a0wzsygipmf2"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaLang/Compat.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-binaryprovider
+  ;; In theory we should replace this with a package that errors when used
+  (package
+    (name "julia-binaryprovider")
+    (version "0.5.5")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaPackaging/BinaryProvider.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "BinaryProvider")
+	      (sha256
+	       (base32 "1papsz5ki5iwv1v3ac1ddybjxak93nydh7dqc3231zm0fzd918ys"))))
+    (propagated-inputs `(("julia-sha" ,julia-sha)
+			 ;; ("julia-logging" ,julia-logging)
+			 ))
+    (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 "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-libz
+  (package
+    (name "julia-libz")
+    (version "1.0.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/BioJulia/Libz.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Libz")
+	      (sha256
+	       (base32 "1434i2hhf8hncnchnrvz1j3gydm83yyglsjggc3i1zzg821pwrbv"))))
+    (propagated-inputs `(("julia-bufferedstreams" ,julia-bufferedstreams)
+			 ("julia-compat" ,julia-compat)
+			 ("zlib" ,zlib)))
+    (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/"
+					 (string-append (strip-store-file-name source) "/src/lowlevel.jl"))
+	       (("const zlib = \"libz\"")
+		(string-append "const zlib = \""
+			       (assoc-ref inputs "zlib")
+			       "/lib/libz.so\"\n")))
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/BioJulia/Libz.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-libepat
+  (package
+    (name "julia-libexpat")
+    (version "0.5.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaIO/LibExpat.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "LibExpat")
+	      (sha256
+	       (base32 "1iny18z76bkf3yi6cvpfia7z1j7kn789iy0nwigsj2sb9mfi5x8b"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaIO/LibExpat.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-libcurl
+  (package
+    (name "julia-libcurl")
+    (version "0.5.2")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaWeb/LibCURL.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "LibCURL")
+	      (sha256
+	       (base32 "1kwpk19338wvnq67nimdzp815hzhvbpk77qp2r851f7szqjbd1qc"))))
+    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
+			 ("curl" ,curl)
+			 ("zlib" ,zlib)
+			 ("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 libcurl = \""
+				       (assoc-ref inputs "curl")
+				       "/lib/libcurl.so\"\n") f)
+	       (display (string-append "const libz = \""
+				       (assoc-ref inputs "zlib")
+				       "/lib/libz.so\"\n") f)
+	       (display (string-append "const libmbedcrypto = \""
+				       (assoc-ref inputs "mbedtls-apache")
+				       "/lib/libmbedcrypto.so\"\n") f)
+	       (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) 
+	       (display (string-append "check_deps() = nothing\n") f)
+	       (close-port f))
+	     #t)
+	   ))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaWeb/LibCURL.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-http
+  (package
+    (name "julia-http")
+    (version "0.8.4")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaWeb/HTTP.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "HTTP")
+	      (sha256
+	       (base32 "1h2cgjijlmciljdfz4lqigq8lhrvdax5k5ffflvpv2anniywmsx0"))))
+    (propagated-inputs `(("julia-inifile" ,julia-inifile)
+			 ("julia-mbedtls" ,julia-mbedtls)
+			 ("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaWeb/HTTP.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "IteratorInterfaceExtensions")
+	      (sha256
+	       (base32 "1slpay1dhja8f9gy6z7b3psgvgcknn963dvfqqakvg1grk9ppa09"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/IteratorInterfaceExtensions.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-dataapi
+  (package
+    (name "julia-dataapi")
+    (version "1.0.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/DataAPI.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "DataAPI")
+	      (sha256
+	       (base32 "19zr2y10bdp5harrjsjgx4b5xr7hvhay0my584vxfj1m7rksz3sn"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaData/DataAPI.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "DataValueInterfaces")
+	      (sha256
+	       (base32 "0g2wj6q7jj956nx6g7dk8x7w1c4l2xcmnr1kq5x8s8fild9kslg8"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/DataValueInterfaces.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-tables
+  (package
+    (name "julia-tables")
+    (version "0.2.10")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/Tables.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Tables")
+	      (sha256
+	       (base32 "1x04cdfxqmf4n4a9xyg5md4j2h1izzypjyd3plp7gzk2bvip53jv"))))
+    (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.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-missings
+  (package
+    (name "julia-missings")
+    (version "0.4.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/Missings.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Missings")
+	      (sha256
+	       (base32 "07zlhyh6j2j1gs7fp166bj6zqdgasd0d1scpbcymwpzgq9anp8v0"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaData/Missings.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "OrderedCollections")
+	      (sha256
+	       (base32 "0rh1w8sb69b8670xqd3j0xh7pfsl89jhq66xdrdp0060lif5i5li"))))
+    (propagated-inputs `())
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda* (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "OrderedCollections"
+	      "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
+	      "1.1.0"
+	      '())
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaCollections/OrderedCollections.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-datastructures
+  (package
+    (name "julia-datastructures")
+    (version "0.17.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaCollections/DataStructures.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "DataStructures")
+	      (sha256
+	       (base32 "19d1k021ipy1wr0w0l7m2jnspwzp2rvl2yhcsal9kzfl2wl0a7r8"))))
+    (propagated-inputs `(("julia-orderedcollections" ,julia-orderedcollections)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaCollections/DataStructures.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; (define-public julia-arrayviews
+;;   (package
+;;     (name "julia-arrayviews")
+;;     (version "0.7.0")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/JuliaArrays/ArrayViews.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "ArrayViews")
+;; 	      (sha256
+;; 	       (base32 "0xs1if4dhy2m604r1ivzvyki6jap7xl8hkiinhi34qplflnr56f1"))))
+;;     (propagated-inputs `(("julia-compat" ,julia-compat)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/JuliaArrays/ArrayViews.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; (define-public julia-numericfuns
+;;   (package
+;;     (name "julia-numericfuns")
+;;     (version "0.2.4")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/lindahua/NumericFuns.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "NumericFuns")
+;; 	      (sha256
+;; 	       (base32 "1viv2bl4fbxwny52d4alpsgas8qs1i0yw0ld19nzgv44ivpd4mgj"))))
+;;     (propagated-inputs `(("julia-compat" ,julia-compat)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/lindahua/NumericFuns.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; (define-public julia-numericextensions
+;;   (package
+;;     (name "julia-numericextensions")
+;;     (version "0.6.2")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/lindahua/NumericExtensions.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "NumericExtensions")
+;; 	      (sha256
+;; 	       (base32 "0qr7k45jp3zcrq9jgl61k5hvkxs0h1z90wl6ksfaz8gb848v7s0w"))))
+;;     (propagated-inputs `(;; ("julia-arrayviews" ,julia-arrayviews)
+;; 			 ;; ("julia-numericfuns" ,julia-numericfuns)
+;; 			 ))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/lindahua/NumericExtensions.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; NO Project.toml, julia fails to import DataFrames .-.
+(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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-statsbase
+  (package
+    (name "julia-statsbase")
+    (version "0.31.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaStats/StatsBase.jl.git")
+		    (commit "b9454f979ff8bdbc3ecffe2490cc1331a824e798")))
+	      (file-name "StatsBase")
+	      (sha256
+	       (base32 "1k6zcblpdrdq568lsgna83ld2kj47h2cxn5idp8g41fdm9scph5b"))))
+    (propagated-inputs `(("julia-datastructures" ,julia-datastructures)
+			 ;; ("julia-numericextensions" ,julia-numericextensions)
+			 ("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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit "258a4088bb77ee4821bf2da1c73fd6e4897fd43c")))
+	      (file-name "Reexport")
+	      (sha256
+	       (base32 "0h8pfqwz0g0gywcsr5f7s3z6g7q0mmlb2ynki2nn16r8x4i074nx"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/simonster/Reexport.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; (define-public julia-nullablearrays
+;;   (package
+;;     (name "julia-nullablearrays")
+;;     (version "0.1.2")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/JuliaStats/NullableArrays.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "NullableArrays")
+;; 	      (sha256
+;; 	       (base32 "18sl4ck311wjdnv7hw6jg8yd0n8njzcfq9psz7khhr53j9c6r4ab"))))
+;;     (propagated-inputs `(;; ("julia-statsbase" ,julia-statsbase)
+;; 			 ("julia-reexport" ,julia-reexport)
+;; 			 ("julia-compat" ,julia-compat)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/JuliaStats/NullableArrays.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+(define-public julia-parsers
+  (package
+    (name "julia-parsers")
+    (version "0.3.6")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/Parsers.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Parsers")
+	      (sha256
+	       (base32 "1xjfg72ip7i5xci6nfc88swyny4dsarxqavfcfa2snjir1jws1zk"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaData/Parsers.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-categoricalarrays
+  (package
+    (name "julia-categoricalarrays")
+    (version "0.5.5")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/CategoricalArrays.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "CategoricalArrays")
+	      (sha256
+	       (base32 "0bqq20w64pjvd2mfvisqx1z7dn344ady6942jq80xr0jbc4rjdxh"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)
+			 ;; ("julia-nullablearrays" ,julia-nullablearrays)
+			 ("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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "InvertedIndices")
+	      (sha256
+	       (base32 "1179z20yxnkyziip7gn26wr1g3k3ssl1ci7pig3khc900f62di46"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/mbauman/InvertedIndices.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-stats
+  (package
+    (name "julia-stats")
+    (version "0.1.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaStats/StatsKit.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Stats")
+	      (sha256
+	       (base32 "0vz6183rj9122d53i35x86fzir6cq2sjhqmacb1id140d2ab80zl"))))
+    (propagated-inputs `(("julia-statsbase" ,julia-statsbase)
+			 ("julia-orderedcollections" ,julia-orderedcollections)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaStats/StatsKit.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-tokenize
+  (package
+    (name "julia-tokenize")
+    (version "0.5.5")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaLang/Tokenize.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Tokenize")
+	      (sha256
+	       (base32 "072j40xb3v8zcn3zjzv60iznanplvm4bn0lnz9xhri1sx2y2l5g0"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaLang/Tokenize.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "URIParser")
+	      (sha256
+	       (base32 "1i45wza6jh9k7x8jrqiil6k2yb81hdzm3s0zqhzy3y2sby66p44p"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaWeb/URIParser.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-cstparser
+  (package
+    (name "julia-cstparser")
+    (version "0.6.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/julia-vscode/CSTParser.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "CSTParser")
+	      (sha256
+	       (base32 "1m6y6jd703d9xyhhm00d5whbirsyy99wjcqmdvwxkjf9nm77ifzv"))))
+    (propagated-inputs `(("julia-tokenize" ,julia-tokenize)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/julia-vscode/CSTParser.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "MacroTools")
+	      (sha256
+	       (base32 "0sspp8na3cj7pni1b3dqzzpv2mkzln4f5w0n0wrh2jvn8rz1fjjx"))))
+    ;; CANT FIND COMPAT!
+    (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://github.com/MikeInnes/MacroTools.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-lazy
+  (package
+    (name "julia-lazy")
+    (version "0.13.2")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/MikeInnes/Lazy.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Lazy")
+	      (sha256
+	       (base32 "06ffflpjqv27wgali44lj68dplfmjind421jjrvgja5p2lyh2krg"))))
+    (propagated-inputs `(("julia-macrotools" ,julia-macrotools)
+			 ("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (arguments
+     `(#:phases
+       ;; macrotools can't find compat
+       (modify-phases %standard-phases (delete 'precompile))))
+    (home-page "https://github.com/MikeInnes/Lazy.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-markdown
+  (package
+    (name "julia-markdown")
+    (version "0.3.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaAttic/Markdown.jl.git")
+		    (commit "d17f3b19282e719a33b169ea46d660d51bbf5a9d")))
+	      (file-name "Markdown")
+	      (sha256
+	       (base32 "02hfx3x86w4cf4xq0nihs8h4qvqrybfrpsl9h8bsh4b077dwzi1s"))))
+    (propagated-inputs `(("julia-lazy" ,julia-lazy)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaAttic/Markdown.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; (define-public julia-docile
+;;   (package
+;;     (name "julia-docile")
+;;     (version "0.5.23")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/MichaelHatherly/Docile.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "Docile")
+;; 	      (sha256
+;; 	       (base32 "1r35wdkp6zxf4b66n7fqsw56y0gr04hn4rrzcmsba346lb39r8b8"))))
+;;     (propagated-inputs `(("julia-compat" ,julia-compat)
+;; 			 ("julia-markdown" ,julia-markdown)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/MichaelHatherly/Docile.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; (define-public julia-fixedsizearrays
+;;   (package
+;;     (name "julia-fixedsizearrays")
+;;     (version "0.2.5")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/SimonDanisch/FixedSizeArrays.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "FixedSizeArrays")
+;; 	      (sha256
+;; 	       (base32 "0hi9qv0b9p951ciss51gdsprvdr5iqk6ga5vm6is830bwbvvn73k"))))
+;;     (propagated-inputs `(("julia-compat" ,julia-compat)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/SimonDanisch/FixedSizeArrays.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "ColorTypes")
+	      (sha256
+	       (base32 "0yskbz6598aaa36502jzq59aqqy0daxcrcxcmhk6jnbb5a1psr95"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)
+			 ;; ("julia-docile" ,julia-docile)
+			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
+			 ;; ("julia-fixedsizearrays" ,julia-fixedsizearrays)
+			 ))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGraphics/ColorTypes.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-colors
+  (package
+    (name "julia-colors")
+    (version "0.9.5")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaGraphics/Colors.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Colors")
+	      (sha256
+	       (base32 "1a6qvhim024i524g6xjz7q8fjkgm9mbdhrqi18rrxrjmby0cr92a"))))
+    (propagated-inputs `(("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
+			 ("julia-colortypes" ,julia-colortypes)
+			 ("julia-reexport" ,julia-reexport)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGraphics/Colors.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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"
+	      '())
+	     #t)))))
+    (home-page "https://github.com/JuliaGraphics/Graphics.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; (define-public julia-color
+;;   (package
+;;     (name "julia-color")
+;;     (version "0.4.8")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/JuliaAttic/Color.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "Color")
+;; 	      (sha256
+;; 	       (base32 "011nhc7hd9yvn59aq58dvd84hsxd2z7x2949bi69w095vz8iciky"))))
+;;     (propagated-inputs `(("julia-graphics" ,julia-graphics)
+;; 			 ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)
+;; 			 ("julia-compat" ,julia-compat)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/JuliaAttic/Color.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; (define-public julia-terminals
+;;   (package
+;;     (name "julia-terminals")
+;;     (version "0.0.1")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/Keno/Terminals.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "Terminals")
+;; 	      (sha256
+;; 	       (base32 "1xc5w82c19b17ydglpr03mnzr07mpc59jzf5b5wca6qrilqdx8qb"))))
+;;     (propagated-inputs `(;; ("julia-color" ,julia-color)
+;; 			 ))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/Keno/Terminals.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; (define-public julia-lineedit
+;;   (package
+;;     (name "julia-lineedit")
+;;     (version "0.0.1")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/Keno/LineEdit.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "LineEdit")
+;; 	      (sha256
+;; 	       (base32 "05ily5jmznyzb00c0pwlgwplvmkyvcalcia3k438p3agnqpqkrnh"))))
+;;     (propagated-inputs `(;; ("julia-terminals" ,julia-terminals)
+;; 			 ))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/Keno/LineEdit.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+;; (define-public julia-repl
+;;   (package
+;;     (name "julia-repl")
+;;     (version "0.0.2")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/Keno/REPL.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "REPL")
+;; 	      (sha256
+;; 	       (base32 "1zf0x5rkj0i31z4idws0pwsdpv3yv5m0amjzgfyla7dsv7mv0d7i"))))
+;;     (propagated-inputs `(;; ("julia-lineedit" ,julia-lineedit)
+;; 			 ))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/Keno/REPL.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "PooledArrays")
+	      (sha256
+	       (base32 "0sdn965bb93api43dj8dsd32lp3yyh53mp22xr0vfj115x3ym2wj"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaData/PooledArrays.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-dataframes
+  (package
+    (name "julia-dataframes")
+    (version "0.19.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaData/DataFrames.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "DataFrames")
+	      (sha256
+	       (base32 "0i58khcg486k7affkkj43b23zrg4flmy85s9rkwp021gnal80p6b"))))
+    (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-stats" ,julia-stats)
+			 ("julia-compat" ,julia-compat)
+			 ;; ("julia-repl" ,julia-repl)
+			 ("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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Measures")
+	      (sha256
+	       (base32 "020yf4a7wmm0jhkpzxgz4bif2l4l0zmrzagz0gc2hrvnz0kp9m3b"))))
+    (propagated-inputs `())
+    (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.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-plotutils
+  (package
+    (name "julia-plotutils")
+    (version "0.5.8")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaPlots/PlotUtils.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "PlotUtils")
+	      (sha256
+	       (base32 "0406jq64fyramfjqzfw4p0lsgs9p2sindxximzmcsav8ha7r0vwy"))))
+    (propagated-inputs `(("julia-colors" ,julia-colors)
+			 ("julia-reexport" ,julia-reexport)))
+    (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
+	      "PlotUtils"
+	      "995b91a9-d308-5afd-9ec6-746e21dbc043"
+	      "0.5.8"
+	      '(("Dates" . "ade2ca70-3891-5945-98fb-dc099432e06a")
+		("Reexport" . "189a3867-3050-52da-a836-e630ba90ab69")
+		("Printf" . "de0858da-6303-5e67-8744-51eddeeeb8d7")
+		("Colors" . "5ae59095-9a9b-59fe-a467-6f913c188581")
+		("Random" . "9a3f8284-a2c9-5f02-9a11-845980a1fd5c")))
+	     #t)))))
+    (home-page "https://github.com/JuliaPlots/PlotUtils.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; (define-public julia-immutablearrays
+;;   (package
+;;     (name "julia-immutablearrays")
+;;     (version "0.0.12")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/JuliaGeometry/ImmutableArrays.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "ImmutableArrays")
+;; 	      (sha256
+;; 	       (base32 "0yvj494crpkvk8h38iqz6kcr66bhl394pgy2jg2w960dw3bp4y21"))))
+;;     (propagated-inputs `(("julia-compat" ,julia-compat)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/JuliaGeometry/ImmutableArrays.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+(define-public julia-staticarrays
+  (package
+    (name "julia-staticarrays")
+    (version "0.11.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaArrays/StaticArrays.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "StaticArrays")
+	      (sha256
+	       (base32 "0ni4rdq8qq4c7m49my885ispilqvhbza0id92j16rqzhdff8bghg"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaArrays/StaticArrays.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Contour")
+	      (sha256
+	       (base32 "0l7zi2xshyv81xlp1szm47f6200lnhfylfdrsk7g0xiajr81acpd"))))
+    (propagated-inputs `(;; ("julia-immutablearrays" ,julia-immutablearrays)
+			 ("julia-staticarrays" ,julia-staticarrays)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGeometry/Contour.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "IterTools")
+	      (sha256
+	       (base32 "1iq08xpj1gb2wz2hx7g177clxnxcwlma12dj240xnk7q0g623hbv"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaCollections/IterTools.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-geometrytypes
+  (package
+    (name "julia-geometrytypes")
+    (version "0.7.3")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaGeometry/GeometryTypes.jl.git")
+		    (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://github.com/JuliaGeometry/GeometryTypes.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-plotthemes
+  (package
+    (name "julia-plotthemes")
+    (version "0.3.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaPlots/PlotThemes.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "PlotThemes")
+	      (sha256
+	       (base32 "1hyrhfn3rhiw96743zlqzr5z67vgyrfpqqy23yww7zh0x3qzm5m0"))))
+    (propagated-inputs `(("julia-plotutils" ,julia-plotutils)
+			 ("julia-requires" ,julia-requires)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda* (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "PlotThemes"
+	      "ccf2f8ad-2431-5c83-bf29-c5338b663b6a"
+	      "0.3.0"
+	      '(("PlotUtils" . "995b91a9-d308-5afd-9ec6-746e21dbc043")
+		("Requires" . "ae029012-a4dd-5104-9daa-d747884805df")
+		("Statistics" . "10745b16-79ce-11e8-11f9-7d13ad32a3b2")))
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaPlots/PlotThemes.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; -- THIS SHOULD BE MOVED SOMEWHERE ELSE!
+(use-modules ((guix licenses) #:prefix license:))
+(use-modules (guix packages))
+(use-modules (guix build-system gnu))
+(use-modules (guix git-download))
+(use-modules (guix download))
+
+(use-modules (gnu packages gcc))
+(use-modules (gnu packages qt))
+(use-modules (gnu packages networking))
+(use-modules (gnu packages gtk))
+(use-modules (gnu packages gl))
+(use-modules (gnu packages image))
+(use-modules (gnu packages xorg))
+
+(define-public gr
+  (package
+    (name "gr")
+    (version "0.40.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url (string-append
+			  "https://github.com/jheinen/" name))
+		    (commit (string-append "v" version))))
+	      (file-name (git-file-name name version))
+	      (sha256
+	       (base32
+		"1fx11ha2lprx9y9h9l5lcsrdgp0kxxznf4qa8ci3n1lds89cpyp4"))
+	      (modules '((guix build utils)))))
+    (build-system gnu-build-system)
+    (arguments
+     '(#:parallel-build? #f 		; fails when parallel
+       #:phases
+       (modify-phases %standard-phases
+	 (delete 'configure)
+	 (delete 'check)
+	 (delete 'validate-runpath)
+	 (add-before 'build 'fix-zeromq
+	   (lambda _
+	     ;; remove prerequisites from targets (we already have zmq)
+	     (substitute* "lib/gks/Makefile"
+	       (("targets: prerequisites libGKS.a") "targets: libGKS.a"))
+	     #t))
+	 (add-before 'build 'fix-gks-install
+	   (lambda _
+	     ;; fonts and header has already been copied, override is needed
+	     (substitute* "lib/gks/Makefile"
+	       (("cp -a fonts") "cp -af fonts"))
+	     (substitute* "lib/gks/Makefile"
+	       (("cp -p gks.h") "cp -pf gks.h"))
+	     #t)))
+       #:make-flags
+       (list "CC=gcc"
+	     (string-append "GRDIR=" (assoc-ref %outputs "out")))))
+    (inputs
+     `(("gcc" ,gcc-8)
+       ("qt" ,qtbase)
+       ("zmq" ,zeromq)
+       ("czmq" ,czmq)
+       ("cairo" ,cairo)
+       ("glfw" ,glfw)
+       ("libtiff" ,libtiff)
+       ("x11" ,libx11)
+       ("xt" ,libxt)))
+    (home-page "http://gr-framework.org")
+    (synopsis "Universal framework for cross-platform visualization applications.")
+    (description "Offers developers a compact, portable and consistent graphics library for their programs.
+Applications range from publication quality 2D graphs to the representation of complex 3D scenes.")
+    (license license:expat)))
+;; --- until here
+
+
+(define-public julia-gr
+  (package
+    (name "julia-gr")
+    (version "0.40.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/jheinen/GR.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "GR")
+	      (sha256
+	       (base32 "0nmrc6xj4n55gv47d4ca9lhz053b26i1jq0nsis09w5mgz3y6nkl"))))
+    (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/"
+					 (string-append (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.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+
+(define-public julia-ffmpeg
+  (package
+    (name "julia-ffmpeg")
+    (version "0.2.2")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaIO/FFMPEG.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "FFMPEG")
+	      (sha256
+	       (base32 "0nbdm8ljizcgjmcaa12j3cv84yhcvnlna9g1l86m8gf8nhackwa5"))))
+    (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 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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "RecipesBase")
+	      (sha256
+	       (base32 "18dkzvnx6jcqvjaqx592bbxv5wgsl75japq56ij2s8p6gc868lvs"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaPlots/RecipesBase.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+
+;; (define-public julia-iterators
+;;   (package
+;;     (name "julia-iterators")
+;;     (version "0.3.1")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/JuliaCollections/Iterators.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "Iterators")
+;; 	      (sha256
+;; 	       (base32 "1iixfcc4mq928a0jjrd4nvl58dawxxwv7935wk3m7fh7gb6r68yk"))))
+;;     (propagated-inputs `())
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/JuliaCollections/Iterators.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (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.git")
+		    (commit "8502c2ec11f93c4f50c609ff4168aab31154b39d")))
+	      (file-name "Showoff")
+	      (sha256
+	       (base32 "10iydva8vqlfv4i5jw31q9pc7877syd0bfz2djg93xdy90l4c617"))))
+    (propagated-inputs `( ;; ("julia-iterators" ,julia-iterators)
+			 ("julia-compat" ,julia-compat)
+			 ))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGraphics/Showoff.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-plots
+  (package
+    (name "julia-plots")
+    (version "0.26.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaPlots/Plots.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Plots")
+	      (sha256
+	       (base32 "1n3az78fzj5h2g3xh0aar2rq5qfnwfidk0szn4c8v7m2sn69yi15"))))
+    (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-repl" ,julia-repl)
+			 ("julia-gr" ,julia-gr)
+			 ("julia-ffmpeg" ,julia-ffmpeg)
+			 ("julia-recipesbase" ,julia-recipesbase)
+			 ("julia-showoff" ,julia-showoff)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaPlots/Plots.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-codetracking
+  (package
+    (name "julia-codetracking")
+    (version "0.5.7")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/timholy/CodeTracking.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "CodeTracking")
+	      (sha256
+	       (base32 "0ycwhxfj9y618wixffxqfmr7vyx6ww3fax7c1n1i1hizsgsgfjwl"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/timholy/CodeTracking.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-juliainterpreter
+  (package
+    (name "julia-juliainterpreter")
+    (version "0.6.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaDebug/JuliaInterpreter.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "JuliaInterpreter")
+	      (sha256
+	       (base32 "0mgr7fghc33gb9pmjqp7yrqrw79d0inj4vn384fmgl2yr1q4k86p"))))
+    (propagated-inputs `(("julia-codetracking" ,julia-codetracking)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaDebug/JuliaInterpreter.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-loweredcodeutils
+  (package
+    (name "julia-loweredcodeutils")
+    (version "0.3.6")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaDebug/LoweredCodeUtils.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "LoweredCodeUtils")
+	      (sha256
+	       (base32 "14lsm58s1swhywys7z05ly386c21w1gn0pdb87shmys99lmzg6ib"))))
+    (propagated-inputs `(("julia-juliainterpreter" ,julia-juliainterpreter)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaDebug/LoweredCodeUtils.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-revise
+  (package
+    (name "julia-revise")
+    (version "2.1.6")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/timholy/Revise.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "Revise")
+	      (sha256
+	       (base32 "0qnfgsf4h13bw6jj6dd4559i00fdj8qbk8lmvrqx8qivb8b0ykxi"))))
+    (propagated-inputs `(("julia-loweredcodeutils" ,julia-loweredcodeutils)
+			 ("julia-juliainterpreter" ,julia-juliainterpreter)
+			 ("julia-orderedcollections" ,julia-orderedcollections)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/timholy/Revise.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit "0515a2cc615d55c2c5412e8d84740ea01fa4f7aa")))
+	      (file-name "TableShowUtils")
+	      (sha256
+	       (base32 "1mbniba5llf4f0k57wwd2a0i5c77d1sry66xaz9h9w5b2lhx7cdy"))))
+    (propagated-inputs `(("julia-markdown" ,julia-markdown)
+			 ("julia-json" ,julia-json)
+			 ("julia-datavalues" ,julia-datavalues)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/TableShowUtils.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "IteratorInterfaceExtensions")
+	      (sha256
+	       (base32 "1slpay1dhja8f9gy6z7b3psgvgcknn963dvfqqakvg1grk9ppa09"))))
+    (propagated-inputs `())
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/IteratorInterfaceExtensions.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-queryoperators
+  (package
+    (name "julia-queryoperators")
+    (version "0.9.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/QueryOperators.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "QueryOperators")
+	      (sha256
+	       (base32 "0bfwjahpcfmrp2z0gyj98nm1f19k1hqafz9znznb8yvn1rr58xm3"))))
+    (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/IterableTables.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-query
+(package
+(name "julia-query")
+(version "0.12.0")
+(source
+(origin
+(method git-fetch)
+(uri
+(git-reference
+(url "https://github.com/queryverse/Query.jl.git")
+(commit
+(string-append "v" version))))
+(file-name "Query")
+(sha256
+(base32 "19m87d5913mnk5vlfkkl9560dnsjn4c5k00aigrhpcgvv8ns0p07"))))
+(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.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-cairo
+  (package
+    (name "julia-cairo")
+    (version "0.6.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaGraphics/Cairo.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Cairo")
+       (sha256
+	(base32 "1hrv8pxrywl1845wq697qqk0l41fjh06gvl9cfqhym1x04f3j9qj"))))
+    (propagated-inputs
+     `(("julia-graphics" ,julia-graphics)
+       ("julia-colors" ,julia-colors)
+       ("julia-bindeps" ,julia-bindeps)
+       ("julia-compat" ,julia-compat)
+       ("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/"
+		     (string-append
+		      (strip-store-file-name source)
+		      "/deps/deps.jl"))
+		    "w")))
+	       (display
+		(string-append "const _jl_libcairo = \""
+			       (assoc-ref inputs "cairo")
+			       "/lib/libcairo.so\"\n")
+		f)
+	       (display
+		(string-append "const _jl_libpango = \""
+			       (assoc-ref inputs "pango")
+			       "/lib/libpango-1.0.so\"\n")
+		f)
+	       (display
+		(string-append "const _jl_libpangocairo = \""
+			       (assoc-ref inputs "pango")
+			       "/lib/libpangocairo-1.0.so\"\n")
+		f)
+	       (display
+		(string-append "const _jl_libgobject = \""
+			       (assoc-ref inputs "glib")
+			       "/lib/libgobject-2.0.so\"\n")
+		f)
+	       (close-port f))
+	     #t)
+	   ))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaGraphics/Cairo.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-gtk
+  (package
+    (name "julia-gtk")
+    (version "0.17.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaGraphics/Gtk.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Gtk")
+       (sha256
+	(base32 "0ivvia2iq8mfqhyjf9bjw9p1wamzi69gsr8j7av9j1hk5xn7xxc5"))))
+    (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
+     `(#: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://github.com/JuliaGraphics/Gtk.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+	 (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+	 (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Pidfile")
+       (sha256
+	(base32 "16xyb8mybj90l40rcd49ii6id2xllr9lgrb6p6l0g1ggyballwcd"))))
+    (propagated-inputs
+     `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/vtjnash/Pidfile.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+	 (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+	 (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Observables")
+       (sha256
+	(base32 "16qjjagaa6dvi3fhqyljhxg07r5cjz6d1h8yl38x3c11ilrvdy50"))))
+    (propagated-inputs
+     `())
+    (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://github.com/JuliaGizmos/Observables.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-widgets
+  (package
+    (name "julia-widgets")
+    (version "0.6.1")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/piever/Widgets.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "Widgets")
+       (sha256
+	(base32 "1w8rgaqprmz8g4kkjv2ba3hd66k5r62ra9p7j2bhrvvmw5h6dchp"))))
+    (propagated-inputs
+     `(("julia-observables" ,julia-observables)
+       ("julia-orderedcollections" ,julia-orderedcollections)
+       ("julia-colors" ,julia-colors)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "Widgets"
+	      "cc8bc4a8-27d6-5769-a93b-9d913e69aa62"
+	      "0.6.1"
+	      '())
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/piever/Widgets.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
+     `())
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "FunctionalCollections"
+	      "de31a74c-ac4f-5751-b3fd-e18cd04993ca"
+	      "0.5.0"
+	      '())
+	     #t)))))
+    (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.8")
+    (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 "0w0jqkkm9m4h9inkjhjm69y8fbvvqvmcyaszm7y5md8a2xyc392w"))))
+    (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.0")
+    (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 "0zdjfg2312z7gcrrl60nhx7l0krdj8bk8kk8x1qy4hyx486dp1lv"))))
+    (propagated-inputs
+     `(("julia-observables" ,julia-observables)
+       ("julia-macrotools" ,julia-macrotools)
+       ("julia-json" ,julia-json)
+       ("julia-webio" ,julia-webio)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "JSExpr"
+	      "97c1335a-c9c5-57fe-bc5d-ec35cebe8660"
+	      "0.5.0"
+	      '())
+	     #t)))))
+    (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)
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "CSSUtil"
+	      "70588ee8-6100-5070-97c1-3cb50ed05fe8"
+	      "0.1.0"
+	      '())
+	     #t)))))
+    (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.2")
+    (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 "0jiw93s8cqwbp7nhdmbhp9xn76an81h9yyyfq6mhiwxkcdhnm213"))))
+    (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.2")
+    (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 "0jin1ym3k48z1cxy7sq94cvm95hc19lsh7r5cjfmcji1yahgbn3p"))))
+    (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-json2
+  (package
+    (name "julia-json2")
+    (version "0.3.1")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/quinnj/JSON2.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "JSON2")
+       (sha256
+	(base32 "1hc3pwjxka206fd69x8dmdg11nnxand9bxbhs0lf3pzdhpf81jna"))))
+    (propagated-inputs
+     `(("julia-parsers" ,julia-parsers)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/quinnj/JSON2.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-msgpack
+  (package
+    (name "julia-msgpack")
+    (version "0.2.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaIO/MsgPack.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "MsgPack")
+       (sha256
+	(base32 "1dvy8bhkf6gjp8fsxl5g85jhjdngizwln9iklgrnvf5rm0nc7y18"))))
+    (propagated-inputs
+     `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaIO/MsgPack.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-osc
+  (package
+    (name "julia-osc")
+    (version "0.1.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://git.nixo.xyz/nixo/OSC.jl.git")
+	 (commit "d18aceff140021e7eb961b5b42d17c23e64074a4")))
+       (file-name "OSC")
+       (sha256
+	(base32 "11npby13nsw3qcjlwa7m20pzfnb43kvax5arjdgdm7mmlzm1wi32"))))
+    (propagated-inputs
+     `())
+    (build-system julia-build-system)
+    (home-page "https://git.nixo.xyz/nixo/OSC.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-intervalsets
+  (package
+    (name "julia-intervalsets")
+    (version "0.3.1")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaMath/IntervalSets.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "IntervalSets")
+       (sha256
+	(base32 "0f0ss4zwhphihmgq037qqva1knknvj2mqs26xzpg3wvvv2rzd9sb"))))
+    (propagated-inputs
+     `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaMath/IntervalSets.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-roundingintegers
+  (package
+    (name "julia-roundingintegers")
+    (version "0.2.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri
+	(git-reference
+	 (url "https://github.com/JuliaMath/RoundingIntegers.jl.git")
+	 (commit
+	  (string-append "v" version))))
+       (file-name "RoundingIntegers")
+       (sha256
+	(base32 "0g8avl67181q29vnza1gmmc3hj183jqknvi4daryj49313z0whj3"))))
+    (propagated-inputs
+     `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaMath/RoundingIntegers.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+;; (define-public julia-gtkreactive
+;;   (package
+;;     (name "julia-gtkreactive")
+;;     (version "0.6.0")
+;;     (source
+;;      (origin
+;;        (method git-fetch)
+;;        (uri
+;; 	(git-reference
+;; 	 (url "https://github.com/JuliaGizmos/GtkReactive.jl.git")
+;; 	 (commit
+;; 	  (string-append "v" version))))
+;;        (file-name "GtkReactive")
+;;        (sha256
+;; 	(base32 "0s37jdjnsp299drmrj2wa7zp89pnnh44ql6sxy59mq10wjjhmhj7"))))
+;;     (propagated-inputs
+;;      `(("julia-reactive" ,julia-reactive)
+;;        ("julia-intervalsets" ,julia-intervalsets)
+;;        ("julia-cairo" ,julia-cairo)
+;;        ("julia-colors" ,julia-colors)
+;;        ("julia-roundingintegers" ,julia-roundingintegers)
+;;        ("julia-reexport" ,julia-reexport)
+;;        ("julia-graphics" ,julia-graphics)
+;;        ("julia-gtk" ,julia-gtk)
+;;        ("julia-fixedpointnumbers" ,julia-fixedpointnumbers)))
+;;     (build-system julia-build-system)
+;;     (home-page "https://github.com/JuliaGizmos/GtkReactive.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+(define-public julia-zmq
+      (package
+	(name "julia-zmq")
+	(version "1.0.0")
+	(source (origin
+	          (method git-fetch)
+	          (uri (git-reference
+			(url "https://github.com/JuliaInterop/ZMQ.jl.git")
+			(commit (string-append "v" version))))
+	          (file-name "ZMQ")
+	          (sha256
+                   (base32 "0lfcq0xdw55silqy47hfsm81418agxxr8qly4sx9lpa9f3js12pz"))))
+	(propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
+			     ("julia-compat" ,julia-compat)
+			     ("zeromq" ,zeromq)))
+	(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 libzmq = \""
+					   (assoc-ref inputs "zeromq")
+					   "/lib/libzmq.so\"\n") f) 
+		   (display (string-append "check_deps() = nothing\n") f)
+		   (close-port f))
+		 #t)
+	       )
+	     (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "ZMQ"
+	      "c2297ded-f4af-51ae-bb23-16f91089e4e1"
+	      "1.0.0"
+	      '(("Libdl" . "8f399da3-3557-5675-b5ff-fb832c97cbdb")
+		("FileWatching" . "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee")
+		("Sockets" . "6462fe0b-24de-5631-8697-dd941f90decc")))
+	     #t)))))
+	(build-system julia-build-system)
+	(home-page "https://github.com/JuliaInterop/ZMQ.jl.git")
+	(synopsis "")
+	(description "")
+	(license license:expat)))
+
+(define-public julia-softglobalscope
+      (package
+	(name "julia-softglobalscope")
+	(version "1.0.10")
+	(source (origin
+	          (method git-fetch)
+	          (uri (git-reference
+			(url "https://github.com/stevengj/SoftGlobalScope.jl.git")
+			(commit (string-append "v" version))))
+	          (file-name "SoftGlobalScope")
+	          (sha256
+                   (base32 "1h6cka2iv4x21nnjyn4j0zizi7km75m6xvz2imih6gyjmq9hqlnp"))))
+	(propagated-inputs `())
+	(arguments
+     `(#:phases
+       (modify-phases %standard-phases
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "SoftGlobalScope"
+	      "b85f4697-e234-5449-a836-ec8e2f98b302"
+	      "1.0.10"
+	      '())
+	     #t)))))
+	(build-system julia-build-system)
+	(home-page "https://github.com/stevengj/SoftGlobalScope.jl.git")
+	(synopsis "")
+	(description "")
+	(license license:expat)))
+
+(define-public julia-versionparsing
+      (package
+	(name "julia-versionparsing")
+	(version "1.1.3")
+	(source (origin
+	          (method git-fetch)
+	          (uri (git-reference
+			(url "https://github.com/stevengj/VersionParsing.jl.git")
+			(commit (string-append "v" version))))
+	          (file-name "VersionParsing")
+	          (sha256
+                   (base32 "09bkzw21yyhvnknk6cs96j4ydb05fzppyhx0qgl5fqijsbn8dwqk"))))
+	(propagated-inputs `(("julia-compat" ,julia-compat)))
+	(build-system julia-build-system)
+	(home-page "https://github.com/stevengj/VersionParsing.jl.git")
+	(arguments
+	 `(#:phases
+	   (modify-phases %standard-phases
+	     (add-before 'precompile 'fix-toml
+	       (lambda*
+		   (#:key outputs source #:allow-other-keys)
+		 (julia-create-package-toml
+		  outputs source
+		  "VersionParsing"
+		  "81def892-9a0e-5fdd-b105-ffc91e053289"
+		  "1.1.3"
+		  '())
+		 #t)))))
+	(synopsis "")
+	(description "")
+	(license license:expat)))
+
+;; (define-public julia-conda
+;;       (package
+;;        (name "julia-conda")
+;;        (version "1.3.0")
+;;        (source (origin
+;; 	        (method git-fetch)
+;; 	        (uri (git-reference
+;; 		      (url "https://github.com/JuliaPy/Conda.jl.git")
+;; 		      (commit (string-append "v" version))))
+;; 	        (file-name "Conda")
+;; 	        (sha256
+;;                  (base32 "1zckglwgr7vd02rzgpshf0jqsfjby2vk8xvaxj68056pkw529ia2"))))
+;;        (propagated-inputs `(("julia-bindeps" ,julia-bindeps)
+;; 			    ("julia-json" ,julia-json)
+;; 			    ("julia-versionparsing" ,julia-versionparsing)))
+;;        (build-system julia-build-system)
+;;        (home-page "https://github.com/JuliaPy/Conda.jl.git")
+;;        (synopsis "")
+;;        (description "")
+;;        (license license:expat)))
+
+;; (define-public julia-ijulia
+;;   (package
+;;     (name "julia-ijulia")
+;;     (version "1.19.0")
+;;     (source (origin
+;; 	      (method git-fetch)
+;; 	      (uri (git-reference
+;; 		    (url "https://github.com/JuliaLang/IJulia.jl.git")
+;; 		    (commit (string-append "v" version))))
+;; 	      (file-name "IJulia")
+;; 	      (sha256
+;; 	       (base32 "0ygqkl7gn9d8ypplbha9hrn42357mjygl9xc3aq1va5h2pb2740a"))))
+;;     (propagated-inputs `(("julia-zmq" ,julia-zmq)
+;; 			 ("julia-json" ,julia-json)
+;; 			 ("julia-mbedtls" ,julia-mbedtls)
+;; 			 ("julia-markdown" ,julia-markdown)
+;; 			 ("julia-softglobalscope" ,julia-softglobalscope)
+;; 			 ("julia-conda" ,julia-conda)
+;; 			 ("jupyter" ,jupyter)))
+;;     (build-system julia-build-system)
+;;     (arguments
+;;      `(#:phases
+;;        (modify-phases %standard-phases
+;; 	 (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/"
+;; 			(string-append
+;; 			 (strip-store-file-name source) "/deps/deps.jl"))
+;; 		       "w")))
+;; 	       (display (string-append
+;; 			 "
+;; const IJULIA_DEBUG = false
+;; const JUPYTER = \""
+;; 			 (assoc-ref inputs "jupyter")
+;; 			 "/bin/jupyter\"")
+;; 			f)
+;; 	       (close-port f))
+;; 	     #t))
+;; 	 ;; debug
+;; 	 (delete 'precompile))))
+;;     (home-page "https://github.com/JuliaLang/IJulia.jl.git")
+;;     (synopsis "")
+;;     (description "")
+;;     (license license:expat)))
+
+
+(define-public julia-glm
+  (package
+    (name "julia-glm")
+    (version "1.3.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaStats/GLM.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "GLM")
+	      (sha256
+	       (base32 "03skzihlvyy76qal1chhz3jfxilg556k9iwk23zzihd46i6z2par"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaStats/GLM.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-formatting
+      (package
+       (name "julia-formatting")
+       (version "0.3.5")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/JuliaIO/Formatting.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "Formatting")
+	        (sha256
+                 (base32 "0nrdacmczf7xn1g8g3acampk0w5hal8cwfh16y96hi3zbfycxhx9"))))
+       (propagated-inputs `(("julia-compat" ,julia-compat)))
+       (build-system julia-build-system)
+       (home-page "https://github.com/JuliaIO/Formatting.jl.git")
+       (synopsis "")
+       (description "")
+       (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.git")
+		      (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.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-codecs
+      (package
+       (name "julia-codecs")
+       (version "0.5.0")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/BioJulia/Codecs.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "Codecs")
+	        (sha256
+                 (base32 "1i4xg0f75gidxmsim0as7s18sb7g4mxb04513025vb1433vvvcni"))))
+       (propagated-inputs `())
+       (build-system julia-build-system)
+       (home-page "https://github.com/BioJulia/Codecs.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-yaml
+      (package
+       (name "julia-yaml")
+       (version "0.3.2")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/BioJulia/YAML.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "YAML")
+	        (sha256
+                 (base32 "1csrkk7q5m2mw3znbkn7j8dqhxx7innam2gcll2qmw7paq03gzwr"))))
+       (propagated-inputs `(("julia-codecs" ,julia-codecs)
+("julia-compat" ,julia-compat)))
+       (build-system julia-build-system)
+       (home-page "https://github.com/BioJulia/YAML.jl.git")
+       (synopsis "")
+       (description "")
+       (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.git")
+		      (commit (string-append "v" version))))
+	        (file-name "AbstractTrees")
+	        (sha256
+                 (base32 "0w05zar1hlyqqx7zlzh05h78mjs9vsgaifn5z390crrhb1bgw4bj"))))
+       (propagated-inputs `(("julia-compat" ,julia-compat)
+			    ;; ("julia-markdown" ,julia-markdown)
+			    ))
+       (build-system julia-build-system)
+       (home-page "https://github.com/Keno/AbstractTrees.jl.git")
+       (synopsis "")
+       (description "")
+       (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (commit (string-append "v" version))))
+	      (file-name "FileIO")
+	      (sha256
+	       (base32 "0dwsklxzc4nhsii9hhjp1h3cbf9n5abipj44jf3i0zncid06aanv"))))
+    (propagated-inputs `(("julia-compat" ,julia-compat)
+			 ;; ("julia-docile" ,julia-docile)
+			 ))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaIO/FileIO.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-transcodingstreams
+      (package
+       (name "julia-transcodingstreams")
+       (version "0.9.4")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/bicycle1885/TranscodingStreams.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "TranscodingStreams")
+	        (sha256
+                 (base32 "0dgn8kqh4qlym3bicdblp9rsg1kqlwlnl22ik75dfwwqbzpnaf0m"))))
+       (propagated-inputs `(("julia-compat" ,julia-compat)))
+       (build-system julia-build-system)
+       (home-page "https://github.com/bicycle1885/TranscodingStreams.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-codeczlib
+  (package
+    (name "julia-codeczlib")
+    (version "0.5.2")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/bicycle1885/CodecZlib.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "CodecZlib")
+	      (sha256
+               (base32 "0v3n3fk7iaslqjyy7qxbad4yzfsd8cq8qdr8is6f79l90nwg8d92"))))
+    (propagated-inputs `(("julia-transcodingstreams" ,julia-transcodingstreams)
+			 ("julia-binaryprovider" ,julia-binaryprovider)
+			 ("zlib" ,zlib)))
+    (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 libz = \""
+				       (assoc-ref inputs "zlib")
+				       "/lib/libz.so\"\n") f)
+	       (display "check_deps() = true\n" f)
+	       (close-port f))
+	     #t))
+	 (add-before 'precompile 'fix-toml
+	   (lambda*
+	       (#:key outputs source #:allow-other-keys)
+	     (julia-create-package-toml
+	      outputs source
+	      "CodecZlib"
+	      "944b1d66-785c-5afd-91f1-9de20f533193"
+	      "0.5.2"
+	      '())
+	     #t))
+	 )))
+    (build-system julia-build-system)
+    (home-page "https://github.com/bicycle1885/CodecZlib.jl.git")
+    (synopsis "")
+    (description "")
+    (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.git")
+		    (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"
+	      '())
+	     #t))
+	 )))
+    (home-page "https://github.com/JuliaAttic/Nullables.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-specialfunctions
+      (package
+	(name "julia-specialfunctions")
+	(version "0.7.2")
+	(source (origin
+	          (method git-fetch)
+	          (uri (git-reference
+			(url "https://github.com/JuliaMath/SpecialFunctions.jl.git")
+			(commit (string-append "v" version))))
+	          (file-name "SpecialFunctions")
+	          (sha256
+                   (base32 "168jhv4b4n1vfzv7qrxxgx5jvc60lsgd2f6jrki4r0i9nfis81yq"))))
+	(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://github.com/JuliaMath/SpecialFunctions.jl.git")
+	(synopsis "")
+	(description "")
+	(license license:expat)))
+
+(define-public julia-quadmath
+      (package
+       (name "julia-quadmath")
+       (version "0.5.0")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/JuliaMath/Quadmath.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "Quadmath")
+	        (sha256
+                 (base32 "0s3y16713cs3zwzypdsnl9c7dlilcln039mnypxcnbxss7lxkrfj"))))
+       (propagated-inputs `(("julia-requires" ,julia-requires)
+			    ("julia-specialfunctions" ,julia-specialfunctions)
+			    ))
+       (build-system julia-build-system)
+       (home-page "https://github.com/JuliaMath/Quadmath.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-polynomials
+      (package
+	(name "julia-polynomials")
+	(version "0.5.2")
+	(source (origin
+	          (method git-fetch)
+	          (uri (git-reference
+			(url "https://github.com/JuliaMath/Polynomials.jl.git")
+			(commit (string-append "v" version))))
+	          (file-name "Polynomials")
+	          (sha256
+                   (base32 "1d7bmkj3a11g1diqqw9fynfw44wqhh8j1wssij63zn8pnlgh7b04"))))
+	(propagated-inputs `())
+	(build-system julia-build-system)
+	(home-page "https://github.com/JuliaMath/Polynomials.jl.git")
+	(arguments
+	 `(#:phases
+	   (modify-phases %standard-phases
+	     (add-before 'precompile 'fix-toml
+	       (lambda*
+		   (#:key outputs source #:allow-other-keys)
+		 (julia-create-package-toml
+		  outputs source
+		  "Polynomials"
+		  "f27b6e38-b328-58d1-80ce-0feddd5e7a45"
+		  "0.5.2"
+		  '())
+		 #t)))))
+	(synopsis "")
+	(description "")
+	(license license:expat)))
+
+(define-public julia-genericschur
+      (package
+       (name "julia-genericschur")
+       (version "0.2.3")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/RalphAS/GenericSchur.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "GenericSchur")
+	        (sha256
+                 (base32 "1yd91zqfwkknvcpfkzxpmyikp2m6z6f6gvlpa0qxhyc96657m6ah"))))
+       (propagated-inputs `())
+       (build-system julia-build-system)
+       (home-page "https://github.com/RalphAS/GenericSchur.jl.git")
+       (synopsis "")
+       (description "")
+       (license license:expat)))
+
+(define-public julia-genericsvd
+      (package
+	(name "julia-genericsvd")
+	(version "0.2.1")
+	(source (origin
+	          (method git-fetch)
+	          (uri (git-reference
+			(url "https://github.com/JuliaLinearAlgebra/GenericSVD.jl.git")
+			(commit (string-append "v" version))))
+	          (file-name "GenericSVD")
+	          (sha256
+                   (base32 "0icdfyipvhy3dnq7yri3cg3mr0szii1jgfqcb0fs8g7a9fcrd0a3"))))
+	(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
+		  "GenericSVD"
+		  "01680d73-4ee2-5a08-a1aa-533608c188bb"
+		  "0.2.1"
+		  '())
+		 #t)))))
+	(build-system julia-build-system)
+	(home-page "https://github.com/JuliaLinearAlgebra/GenericSVD.jl.git")
+	(synopsis "")
+	(description "")
+	(license license:expat)))
+
+(define-public julia-doublefloats
+      (package
+       (name "julia-doublefloats")
+       (version "0.9.3")
+       (source (origin
+	        (method git-fetch)
+	        (uri (git-reference
+		      (url "https://github.com/JuliaMath/DoubleFloats.jl.git")
+		      (commit (string-append "v" version))))
+	        (file-name "DoubleFloats")
+	        (sha256
+                 (base32 "0h39i29v2wqqmvbnphjmlarydpvgn17ayl7qipwh23qq2qm5lcqn"))))
+       (propagated-inputs `(("julia-quadmath" ,julia-quadmath)
+("julia-requires" ,julia-requires)
+("julia-polynomials" ,julia-polynomials)
+("julia-genericschur" ,julia-genericschur)
+("julia-genericsvd" ,julia-genericsvd)))
+       (build-system julia-build-system)
+       (home-page "https://github.com/JuliaMath/DoubleFloats.jl.git")
+       (synopsis "")
+       (description "")
+       (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.git")
+		      (commit (string-append "v" version))))
+	        (file-name "WeakRefStrings")
+	        (sha256
+                 (base32 "00sfqhw2niarfmpn8i3dmv5dfhyj3bylvwp4yrq77b560g997khh"))))
+       (propagated-inputs `())
+       (build-system julia-build-system)
+       (home-page "https://github.com/JuliaData/WeakRefStrings.jl.git")
+       (synopsis "")
+       (description "")
+       (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.git")
+		    (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.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-csvfiles
+  (package
+    (name "julia-csvfiles")
+    (version "0.15.0")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/queryverse/CSVFiles.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "CSVFiles")
+	      (sha256
+	       (base32 "1vzd6b1kp9gjml484lgziibkqasl5v83afr2yxaccskvmq36gxrm"))))
+    (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)))
+    (build-system julia-build-system)
+    (home-page "https://github.com/queryverse/CSVFiles.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
+
+(define-public julia-sqlite
+  (package
+    (name "julia-sqlite")
+    (version "0.8.1")
+    (source (origin
+	      (method git-fetch)
+	      (uri (git-reference
+		    (url "https://github.com/JuliaDatabases/SQLite.jl.git")
+		    (commit (string-append "v" version))))
+	      (file-name "SQLite")
+	      (sha256
+	       (base32 "0kpg0j9wd99qjlxvcr4zl5lm1d993j3php67dsvrrd9m2iva3i7v"))))
+    (propagated-inputs `(("julia-binaryprovider" ,julia-binaryprovider)
+			 ("julia-json" ,julia-json)
+			 ("julia-tables" ,julia-tables)
+			 ("julia-weakrefstrings" ,julia-weakrefstrings)
+			 ("julia-dataframes" ,julia-dataframes)
+			 ("sqlite" ,sqlite)))
+    (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 libsqlite = \""
+				       (assoc-ref inputs "sqlite")
+				       "/lib/libsqlite3.so\"\n") f)
+	       (display "check_deps() = true\n" f)
+	       (close-port f))
+	     #t)))))
+    (build-system julia-build-system)
+    (home-page "https://github.com/JuliaDatabases/SQLite.jl.git")
+    (synopsis "")
+    (description "")
+    (license license:expat)))
-- 
2.22.0


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [bug#36856] build: Add julia-build-system
  2019-07-30 12:49 [bug#36856] build: Add julia-build-system Nicolò Balzarotti
@ 2019-07-30 14:08 ` Ricardo Wurmus
  2019-07-30 14:11 ` Ricardo Wurmus
  1 sibling, 0 replies; 9+ messages in thread
From: Ricardo Wurmus @ 2019-07-30 14:08 UTC (permalink / raw)
  To: Nicolò Balzarotti; +Cc: 36856


Hi Nicolò,

> Lately I've been working a bit on julia packages support in guix.
>
> The good news first: I've been able to install dozen of them, including
> those depending on binaryprovider with simple workarounds.

Excellent!

> 3. By adding a simple startup.jl script, inspired by what emacs does. This
> is simplified so I'm not sure it works for every corner case.
> #+begin_src julia
> let paths = [expanduser("~/.guix-profile"), "/run/current-system/profile"]
>     ("GUIX_ENVIRONMENT" in keys(ENV)) && push!(paths,
> ENV["GUIX_ENVIRONMENT"])
>     empty!(LOAD_PATH)
>     push!.(Ref(LOAD_PATH), joinpath.(paths, "share/julia/packages/"))
>     push!(LOAD_PATH, "@stdlib")
>     push!.(Ref(DEPOT_PATH), joinpath.(paths, "share/julia/"))
>     nothing
> end
> #+end_src

This looks like it would not work with profiles installed anywhere else.
I’m not a fan of hard-coding ~/.guix-profile, because I know that many
people here at the institute use per-project profiles at custom
location.  Any mechanism that relies on things to be installed to
~/.guix-profile will fail them.

Could this be made profile-agnostic?  Perhaps the GUIX_PROFILE
environment variable could be referenced?

Thanks for working on it!

--
Ricardo

^ permalink raw reply	[flat|nested] 9+ messages in thread

* [bug#36856] build: Add julia-build-system
  2019-07-30 12:49 [bug#36856] build: Add julia-build-system Nicolò Balzarotti
  2019-07-30 14:08 ` Ricardo Wurmus
@ 2019-07-30 14:11 ` Ricardo Wurmus
  2019-07-30 14:23   ` Julien Lepiller
  1 sibling, 1 reply; 9+ messages in thread
From: Ricardo Wurmus @ 2019-07-30 14:11 UTC (permalink / raw)
  To: anothersms; +Cc: 36856


Nicolò Balzarotti <anothersms@gmail.com> writes:

> 3. By adding a simple startup.jl script, inspired by what emacs does. This
> is simplified so I'm not sure it works for every corner case.
> #+begin_src julia
> let paths = [expanduser("~/.guix-profile"), "/run/current-system/profile"]
>     ("GUIX_ENVIRONMENT" in keys(ENV)) && push!(paths,
> ENV["GUIX_ENVIRONMENT"])
>     empty!(LOAD_PATH)
>     push!.(Ref(LOAD_PATH), joinpath.(paths, "share/julia/packages/"))
>     push!(LOAD_PATH, "@stdlib")
>     push!.(Ref(DEPOT_PATH), joinpath.(paths, "share/julia/"))
>     nothing
> end
> #+end_src

Could this perhaps be handled by a profile hook that is included only
when the profile manifest contains a julia package?

-- 
Ricardo

^ permalink raw reply	[flat|nested] 9+ messages in thread

* [bug#36856] build: Add julia-build-system
  2019-07-30 14:11 ` Ricardo Wurmus
@ 2019-07-30 14:23   ` Julien Lepiller
  2019-07-30 14:33     ` Ricardo Wurmus
  0 siblings, 1 reply; 9+ messages in thread
From: Julien Lepiller @ 2019-07-30 14:23 UTC (permalink / raw)
  To: 36856, rekado, anothersms

Le 30 juillet 2019 16:11:19 GMT+02:00, Ricardo Wurmus <rekado@elephly.net> a écrit :
>
>Nicolò Balzarotti <anothersms@gmail.com> writes:
>
>> 3. By adding a simple startup.jl script, inspired by what emacs does.
>This
>> is simplified so I'm not sure it works for every corner case.
>> #+begin_src julia
>> let paths = [expanduser("~/.guix-profile"),
>"/run/current-system/profile"]
>>     ("GUIX_ENVIRONMENT" in keys(ENV)) && push!(paths,
>> ENV["GUIX_ENVIRONMENT"])
>>     empty!(LOAD_PATH)
>>     push!.(Ref(LOAD_PATH), joinpath.(paths, "share/julia/packages/"))
>>     push!(LOAD_PATH, "@stdlib")
>>     push!.(Ref(DEPOT_PATH), joinpath.(paths, "share/julia/"))
>>     nothing
>> end
>> #+end_src
>
>Could this perhaps be handled by a profile hook that is included only
>when the profile manifest contains a julia package?

Or simply with an environment variable? GUIX_JULIA_PATH or something?

^ permalink raw reply	[flat|nested] 9+ messages in thread

* [bug#36856] build: Add julia-build-system
  2019-07-30 14:23   ` Julien Lepiller
@ 2019-07-30 14:33     ` Ricardo Wurmus
  2019-07-30 16:02       ` Nicolò Balzarotti
  0 siblings, 1 reply; 9+ messages in thread
From: Ricardo Wurmus @ 2019-07-30 14:33 UTC (permalink / raw)
  To: Julien Lepiller; +Cc: anothersms, 36856


Julien Lepiller <julien@lepiller.eu> writes:

> Le 30 juillet 2019 16:11:19 GMT+02:00, Ricardo Wurmus <rekado@elephly.net> a écrit :
>>
>>Nicolò Balzarotti <anothersms@gmail.com> writes:
>>
>>> 3. By adding a simple startup.jl script, inspired by what emacs does.
>>This
>>> is simplified so I'm not sure it works for every corner case.
>>> #+begin_src julia
>>> let paths = [expanduser("~/.guix-profile"),
>>"/run/current-system/profile"]
>>>     ("GUIX_ENVIRONMENT" in keys(ENV)) && push!(paths,
>>> ENV["GUIX_ENVIRONMENT"])
>>>     empty!(LOAD_PATH)
>>>     push!.(Ref(LOAD_PATH), joinpath.(paths, "share/julia/packages/"))
>>>     push!(LOAD_PATH, "@stdlib")
>>>     push!.(Ref(DEPOT_PATH), joinpath.(paths, "share/julia/"))
>>>     nothing
>>> end
>>> #+end_src
>>
>>Could this perhaps be handled by a profile hook that is included only
>>when the profile manifest contains a julia package?
>
> Or simply with an environment variable? GUIX_JULIA_PATH or something?

If this is the route you go down, please ensure that it can be used as a
search path with more than one directory.  This would make it possible
to extend a Julia environment with the contents of more than one
profile.

--
Ricardo

^ permalink raw reply	[flat|nested] 9+ messages in thread

* [bug#36856] build: Add julia-build-system
  2019-07-30 14:33     ` Ricardo Wurmus
@ 2019-07-30 16:02       ` Nicolò Balzarotti
  2019-08-03 10:03         ` Nicolò Balzarotti
  0 siblings, 1 reply; 9+ messages in thread
From: Nicolò Balzarotti @ 2019-07-30 16:02 UTC (permalink / raw)
  To: Ricardo Wurmus; +Cc: 36856

[-- Attachment #1: Type: text/plain, Size: 1963 bytes --]

Thanks for the quick response!

Well, the environment variable JULIA_LOAD_PATH (that inside julia is just
LOAD_PATH) works exactly like that (is a column-concatenated path list). It
just needs the special ":@stdlib" path to let julia find its standard
libraries.
Example:
> JULIA_LOAD_PATH=/my/new/path/:/profile/path/:@stdlib julia --startup=no
-E 'LOAD_PATH'
["/my/new/path/", "/profile/path/", "@stdlib"]

Is setting this variable from guix fine, or we need a special
GUIX_SOMETHING variable?
Where exactly should I set this?

Thanks

Il giorno mar 30 lug 2019 alle ore 14:33 Ricardo Wurmus <rekado@elephly.net>
ha scritto:

>
> Julien Lepiller <julien@lepiller.eu> writes:
>
> > Le 30 juillet 2019 16:11:19 GMT+02:00, Ricardo Wurmus <
> rekado@elephly.net> a écrit :
> >>
> >>Nicolò Balzarotti <anothersms@gmail.com> writes:
> >>
> >>> 3. By adding a simple startup.jl script, inspired by what emacs does.
> >>This
> >>> is simplified so I'm not sure it works for every corner case.
> >>> #+begin_src julia
> >>> let paths = [expanduser("~/.guix-profile"),
> >>"/run/current-system/profile"]
> >>>     ("GUIX_ENVIRONMENT" in keys(ENV)) && push!(paths,
> >>> ENV["GUIX_ENVIRONMENT"])
> >>>     empty!(LOAD_PATH)
> >>>     push!.(Ref(LOAD_PATH), joinpath.(paths, "share/julia/packages/"))
> >>>     push!(LOAD_PATH, "@stdlib")
> >>>     push!.(Ref(DEPOT_PATH), joinpath.(paths, "share/julia/"))
> >>>     nothing
> >>> end
> >>> #+end_src
> >>
> >>Could this perhaps be handled by a profile hook that is included only
> >>when the profile manifest contains a julia package?
> >
> > Or simply with an environment variable? GUIX_JULIA_PATH or something?
>
> If this is the route you go down, please ensure that it can be used as a
> search path with more than one directory.  This would make it possible
> to extend a Julia environment with the contents of more than one
> profile.
>
> --
> Ricardo
>
>

[-- Attachment #2: Type: text/html, Size: 2929 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

* [bug#36856] build: Add julia-build-system
  2019-07-30 16:02       ` Nicolò Balzarotti
@ 2019-08-03 10:03         ` Nicolò Balzarotti
  2019-08-03 10:04           ` Nicolò Balzarotti
  0 siblings, 1 reply; 9+ messages in thread
From: Nicolò Balzarotti @ 2019-08-03 10:03 UTC (permalink / raw)
  To: Ricardo Wurmus; +Cc: 36856

[-- Attachment #1: Type: text/plain, Size: 2827 bytes --]

Hi, I'm back.

I fixed the problem I had (I forgot the ./pre-inst-env -.-")

Following this discussion, I'm adding ``native-search-paths'' to the julia
package. Now, without any other hack (like the setup.jl one), it can find
the packages but only when installed with guix package -i . It cannot find
them when in an environment (guix environment --ad-hoc julia-package).
Can you help?

Except from this, I cleaned everything a bit, and added a draft of the
documentation. I'm attaching the new patches here (without the julia-xyz
part one, to which I'll add all package synopsis and description, and I'll
split in multiple patches before re-submitting).

Thanks, Nicolò

Il giorno mar 30 lug 2019 alle ore 16:02 Nicolò Balzarotti <
anothersms@gmail.com> ha scritto:

> Thanks for the quick response!
>
> Well, the environment variable JULIA_LOAD_PATH (that inside julia is just
> LOAD_PATH) works exactly like that (is a column-concatenated path list). It
> just needs the special ":@stdlib" path to let julia find its standard
> libraries.
> Example:
> > JULIA_LOAD_PATH=/my/new/path/:/profile/path/:@stdlib julia --startup=no
> -E 'LOAD_PATH'
> ["/my/new/path/", "/profile/path/", "@stdlib"]
>
> Is setting this variable from guix fine, or we need a special
> GUIX_SOMETHING variable?
> Where exactly should I set this?
>
> Thanks
>
> Il giorno mar 30 lug 2019 alle ore 14:33 Ricardo Wurmus <
> rekado@elephly.net> ha scritto:
>
>>
>> Julien Lepiller <julien@lepiller.eu> writes:
>>
>> > Le 30 juillet 2019 16:11:19 GMT+02:00, Ricardo Wurmus <
>> rekado@elephly.net> a écrit :
>> >>
>> >>Nicolò Balzarotti <anothersms@gmail.com> writes:
>> >>
>> >>> 3. By adding a simple startup.jl script, inspired by what emacs does.
>> >>This
>> >>> is simplified so I'm not sure it works for every corner case.
>> >>> #+begin_src julia
>> >>> let paths = [expanduser("~/.guix-profile"),
>> >>"/run/current-system/profile"]
>> >>>     ("GUIX_ENVIRONMENT" in keys(ENV)) && push!(paths,
>> >>> ENV["GUIX_ENVIRONMENT"])
>> >>>     empty!(LOAD_PATH)
>> >>>     push!.(Ref(LOAD_PATH), joinpath.(paths, "share/julia/packages/"))
>> >>>     push!(LOAD_PATH, "@stdlib")
>> >>>     push!.(Ref(DEPOT_PATH), joinpath.(paths, "share/julia/"))
>> >>>     nothing
>> >>> end
>> >>> #+end_src
>> >>
>> >>Could this perhaps be handled by a profile hook that is included only
>> >>when the profile manifest contains a julia package?
>> >
>> > Or simply with an environment variable? GUIX_JULIA_PATH or something?
>>
>> If this is the route you go down, please ensure that it can be used as a
>> search path with more than one directory.  This would make it possible
>> to extend a Julia environment with the contents of more than one
>> profile.
>>
>> --
>> Ricardo
>>
>>

[-- Attachment #2: Type: text/html, Size: 4158 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

* [bug#36856] build: Add julia-build-system
  2019-08-03 10:03         ` Nicolò Balzarotti
@ 2019-08-03 10:04           ` Nicolò Balzarotti
  2019-09-04 20:21             ` bug#36856: " Julien Lepiller
  0 siblings, 1 reply; 9+ messages in thread
From: Nicolò Balzarotti @ 2019-08-03 10:04 UTC (permalink / raw)
  To: Ricardo Wurmus; +Cc: 36856


[-- Attachment #1.1: Type: text/plain, Size: 3069 bytes --]

Yeah I forgot to attach the patches. Here we go

Il giorno sab 3 ago 2019 alle ore 10:03 Nicolò Balzarotti <
anothersms@gmail.com> ha scritto:

> Hi, I'm back.
>
> I fixed the problem I had (I forgot the ./pre-inst-env -.-")
>
> Following this discussion, I'm adding ``native-search-paths'' to the julia
> package. Now, without any other hack (like the setup.jl one), it can find
> the packages but only when installed with guix package -i . It cannot find
> them when in an environment (guix environment --ad-hoc julia-package).
> Can you help?
>
> Except from this, I cleaned everything a bit, and added a draft of the
> documentation. I'm attaching the new patches here (without the julia-xyz
> part one, to which I'll add all package synopsis and description, and I'll
> split in multiple patches before re-submitting).
>
> Thanks, Nicolò
>
> Il giorno mar 30 lug 2019 alle ore 16:02 Nicolò Balzarotti <
> anothersms@gmail.com> ha scritto:
>
>> Thanks for the quick response!
>>
>> Well, the environment variable JULIA_LOAD_PATH (that inside julia is just
>> LOAD_PATH) works exactly like that (is a column-concatenated path list). It
>> just needs the special ":@stdlib" path to let julia find its standard
>> libraries.
>> Example:
>> > JULIA_LOAD_PATH=/my/new/path/:/profile/path/:@stdlib julia --startup=no
>> -E 'LOAD_PATH'
>> ["/my/new/path/", "/profile/path/", "@stdlib"]
>>
>> Is setting this variable from guix fine, or we need a special
>> GUIX_SOMETHING variable?
>> Where exactly should I set this?
>>
>> Thanks
>>
>> Il giorno mar 30 lug 2019 alle ore 14:33 Ricardo Wurmus <
>> rekado@elephly.net> ha scritto:
>>
>>>
>>> Julien Lepiller <julien@lepiller.eu> writes:
>>>
>>> > Le 30 juillet 2019 16:11:19 GMT+02:00, Ricardo Wurmus <
>>> rekado@elephly.net> a écrit :
>>> >>
>>> >>Nicolò Balzarotti <anothersms@gmail.com> writes:
>>> >>
>>> >>> 3. By adding a simple startup.jl script, inspired by what emacs does.
>>> >>This
>>> >>> is simplified so I'm not sure it works for every corner case.
>>> >>> #+begin_src julia
>>> >>> let paths = [expanduser("~/.guix-profile"),
>>> >>"/run/current-system/profile"]
>>> >>>     ("GUIX_ENVIRONMENT" in keys(ENV)) && push!(paths,
>>> >>> ENV["GUIX_ENVIRONMENT"])
>>> >>>     empty!(LOAD_PATH)
>>> >>>     push!.(Ref(LOAD_PATH), joinpath.(paths, "share/julia/packages/"))
>>> >>>     push!(LOAD_PATH, "@stdlib")
>>> >>>     push!.(Ref(DEPOT_PATH), joinpath.(paths, "share/julia/"))
>>> >>>     nothing
>>> >>> end
>>> >>> #+end_src
>>> >>
>>> >>Could this perhaps be handled by a profile hook that is included only
>>> >>when the profile manifest contains a julia package?
>>> >
>>> > Or simply with an environment variable? GUIX_JULIA_PATH or something?
>>>
>>> If this is the route you go down, please ensure that it can be used as a
>>> search path with more than one directory.  This would make it possible
>>> to extend a Julia environment with the contents of more than one
>>> profile.
>>>
>>> --
>>> Ricardo
>>>
>>>

[-- Attachment #1.2: Type: text/html, Size: 4602 bytes --]

[-- Attachment #2: 0001-build-Add-julia-build-system.patch --]
[-- Type: text/x-patch, Size: 13390 bytes --]

From 5538e759e6a50041a40c350cf8c08c0b4c0f647e Mon Sep 17 00:00:00 2001
From: nixo <nicolo@nixo.xyz>
Date: Mon, 29 Jul 2019 18:45:26 +0200
Subject: [PATCH 1/2] build: Add julia-build-system.

* guix/build/julia-build-system.scm: New file.
* guix/build-system/julia.scm: New file.
* Makefile.am: Added new files.
---
 Makefile.am                       |   2 +
 doc/guix.texi                     |  23 +++++
 guix/build-system/julia.scm       | 132 +++++++++++++++++++++++++++++
 guix/build/julia-build-system.scm | 135 ++++++++++++++++++++++++++++++
 4 files changed, 292 insertions(+)
 create mode 100644 guix/build-system/julia.scm
 create mode 100644 guix/build/julia-build-system.scm

diff --git a/Makefile.am b/Makefile.am
index 0bd85e8fcf..d14487045a 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -125,6 +125,7 @@ MODULES =					\
   guix/build-system/gnu.scm			\
   guix/build-system/guile.scm			\
   guix/build-system/haskell.scm			\
+  guix/build-system/julia.scm			\
   guix/build-system/linux-module.scm		\
   guix/build-system/node.scm			\
   guix/build-system/perl.scm			\
@@ -183,6 +184,7 @@ MODULES =					\
   guix/build/texlive-build-system.scm		\
   guix/build/waf-build-system.scm		\
   guix/build/haskell-build-system.scm		\
+  guix/build/julia-build-system.scm		\
   guix/build/linux-module-build-system.scm	\
   guix/build/store-copy.scm			\
   guix/build/json.scm				\
diff --git a/doc/guix.texi b/doc/guix.texi
index ccc36a8a97..e8aa4bc906 100644
--- a/doc/guix.texi
+++ b/doc/guix.texi
@@ -6032,6 +6032,29 @@ Packages built with @code{guile-build-system} must provide a Guile package in
 their @code{native-inputs} field.
 @end defvr
 
+@defvr {Scheme Variable} julia-build-system
+This variable is exported by @code{(guix build-system julia)}.  It implements
+the build procedure used by @uref{https://julialang.org/, julia} packages,
+which essentially is similar to running @command{julia -e 'using Pkg;
+Pkg.add(package)'} in an environment where @code{JULIA_LOAD_PATH} contains the
+paths to all Julia package inputs.  Tests are run not run.
+
+Julia packages require the source @code{file-name} to be the real name of the
+package, correctly capitalized.
+
+For packages requiring shared library dependencies, you may need to write the
+@file{/deps/deps.jl} file manually. It's usually a line of @code{const
+variable = /gnu/store/libary.so} for each dependency, plus a void function
+@code{check_deps() = nothing}.
+
+Some older packages that aren't using @file{Package.toml} yet, will require
+this file to be created, too. The function @code{julia-create-package-toml}
+helps creating the file. You need to pass the outputs and the source of the
+package, it's name (the same as the @code{file-name} parameter), the package
+uuid, the package version, and a list of dependencies specified by their name
+and their uuid.
+@end defvr
+
 @defvr {Scheme Variable} minify-build-system
 This variable is exported by @code{(guix build-system minify)}.  It
 implements a minification procedure for simple JavaScript packages.
diff --git a/guix/build-system/julia.scm b/guix/build-system/julia.scm
new file mode 100644
index 0000000000..4e0d6ccddf
--- /dev/null
+++ b/guix/build-system/julia.scm
@@ -0,0 +1,132 @@
+;;; 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 (guix build-system julia)
+  #:use-module ((guix build julia-build-system))
+  #:use-module (gnu packages julia)
+  #:use-module (guix store)
+  #:use-module (guix utils)
+  #:use-module (guix packages)
+  #:use-module (guix derivations)
+  #:use-module (guix search-paths)
+  #:use-module (guix build-system)
+  #:use-module (guix build-system gnu)
+  #:use-module (ice-9 match)
+  #:use-module (srfi srfi-26)
+  #:export (%julia-build-system-modules
+            julia-build
+            julia-build-system))
+
+;; Commentary:
+;;
+;; Standard build procedure for Julia packages.
+;;
+;; Code:
+
+(define %julia-build-system-modules
+  ;; Build-side modules imported by default.
+  `((guix build julia-build-system)
+    ,@%gnu-build-system-modules))
+
+(define (default-julia)
+  "Return the default Julia package."
+  ;; Lazily resolve the binding to avoid a circular dependency.
+  (let ((julia-mod (resolve-interface '(gnu packages julia))))
+    (module-ref julia-mod 'julia)))
+
+(define* (lower name
+                #:key source inputs native-inputs outputs system target
+                (julia julia)
+                #:allow-other-keys
+                #:rest arguments)
+  "Return a bag for NAME."
+  (define private-keywords
+    '(#:target #:julia #:inputs #:native-inputs))
+
+  (and (not target)			;XXX: no cross-compilation
+       (bag
+	 (name name)
+	 (system system)
+	 (host-inputs `(,@(if source
+			      `(("source" ,source))
+			      '())
+		        ,@inputs
+                        
+                        ;; Keep the standard inputs of 'gnu-build-system'.
+		        ,@(standard-packages)))
+	 (build-inputs `(("julia" ,julia)
+			 ,@native-inputs))
+	 (outputs outputs)
+	 (build julia-build)
+	 (arguments (strip-keyword-arguments private-keywords arguments)))))
+
+(define* (julia-build store name inputs
+                      #:key source
+                      (tests? #f)
+                      (phases '(@ (guix build julia-build-system)
+                                  %standard-phases))
+                      (outputs '("out"))
+                      (search-paths '())
+                      (system (%current-system))
+                      (guile #f)
+                      (imported-modules %julia-build-system-modules)
+                      (modules '((guix build julia-build-system)
+                                 (guix build utils))))
+  "Build SOURCE using Julia, and with INPUTS."
+  (define builder
+    `(begin
+       (use-modules ,@modules)
+       (julia-build #:name ,name
+                    #:source ,(match (assoc-ref inputs "source")
+                                (((? derivation? source))
+                                 (derivation->output-path source))
+                                ((source)
+                                 source)
+                                (source
+                                 source))
+                    #:system ,system
+                    #:tests? ,tests?
+                    #:phases ,phases
+                    #:outputs %outputs
+                    #:search-paths ',(map search-path-specification->sexp
+                                          search-paths)
+                    #:inputs %build-inputs)))
+
+  (define guile-for-build
+    (match guile
+      ((? package?)
+       (package-derivation store guile system #:graft? #f))
+      (#f                                         ; the default
+       (let* ((distro (resolve-interface '(gnu packages commencement)))
+              (guile  (module-ref distro 'guile-final)))
+         (package-derivation store guile system #:graft? #f)))))
+
+  (build-expression->derivation store name builder
+                                #:inputs inputs
+                                #:system system
+                                #:modules imported-modules
+                                #:outputs outputs
+                                #:guile-for-build guile-for-build))
+
+(define julia-build-system
+  (build-system
+   (name 'julia)
+   (description "The build system for Julia packages")
+   (lower lower)))
+
+;;; julia.scm ends here
diff --git a/guix/build/julia-build-system.scm b/guix/build/julia-build-system.scm
new file mode 100644
index 0000000000..728bb65893
--- /dev/null
+++ b/guix/build/julia-build-system.scm
@@ -0,0 +1,135 @@
+;;; 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 (guix build julia-build-system)
+  #:use-module ((guix build gnu-build-system) #:prefix gnu:)
+  #:use-module (guix build utils)
+  #:use-module (ice-9 match)
+  #:export (%standard-phases
+	    julia-create-package-toml
+            julia-build))
+
+;; Commentary:
+;;
+;; Builder-side code of the standard build procedure for Julia packages.
+;;
+;; Code:
+
+(define (invoke-julia code)
+  (invoke "julia" "-e" code))
+
+;; subpath where we store the package content
+(define %package-path "/share/julia/packages/")
+
+(define (generate-load-path inputs outputs)
+  (string-append
+   (string-join (map (match-lambda
+                       ((_ . path)
+                        (string-append path %package-path)))
+                     ;; Restrict to inputs beginning with "julia-".
+                     (filter (match-lambda
+                               ((name . _)
+                                (string-prefix? "julia-" name)))
+                             inputs))
+                ":")
+   (string-append ":" (assoc-ref outputs "out") %package-path)
+   ;; stdlib is always required to find Julia's standard libraries.
+   ;; usually there are other two paths in this variable:
+   ;; "@" and "@v#.#"
+   ":@stdlib"))
+
+(define* (install #:key source inputs outputs #:allow-other-keys)
+  (let* ((out (assoc-ref outputs "out"))
+	 (package-dir (string-append out %package-path
+				     (string-append
+				      (strip-store-file-name source)))))
+    (setenv "JULIA_LOAD_PATH" (generate-load-path inputs outputs))
+    (mkdir-p package-dir)
+    (copy-recursively source package-dir))
+  #t)
+
+;; TODO: Precompilation is working, but I don't know how to tell
+;; julia to use use it. If (on rantime) we set HOME to
+;; store path, julia tries to write files there (failing)
+(define* (precompile #:key source inputs outputs #:allow-other-keys)
+  (let* ((out (assoc-ref outputs "out"))
+	 (builddir (string-append out "/share/julia/"))
+	 (package (strip-store-file-name source)))
+    (mkdir-p builddir)
+    (setenv "JULIA_DEPOT_PATH" builddir)
+    (setenv "JULIA_LOAD_PATH" (generate-load-path inputs outputs))
+    ;; Actual precompilation
+    (invoke-julia (string-append "using " package)))
+  #t)
+
+(define* (check #:key source inputs outputs #:allow-other-keys)
+  (let* ((out (assoc-ref outputs "out"))
+	 (package (strip-store-file-name source))
+	 (builddir (string-append out "/share/julia/")))
+    (setenv "JULIA_DEPOT_PATH" builddir)
+    (setenv "JULIA_LOAD_PATH" (generate-load-path inputs outputs))
+    (invoke-julia (string-append "using Pkg;Pkg.test(\"" package "\")")))
+  #t)
+
+(define (julia-create-package-toml outputs source
+				   name uuid version
+				   deps)
+  "Some packages are not using the new Package.toml dependency specifications.
+Write this file manually, so that Julia can find its dependencies."
+  (let ((f (open-file
+	    (string-append
+	     (assoc-ref outputs "out")
+	     %package-path
+	     (string-append
+	      name "/Project.toml"))
+	    "w")))
+    (display (string-append
+	      "
+name = \"" name "\"
+uuid = \"" uuid "\"
+version = \"" version "\"
+") f)
+    (when (not (null? deps))
+      (display "[deps]\n" f)
+      (for-each (lambda dep
+		  (display (string-append (car (car dep)) " = \"" (cdr (car dep)) "\"\n")
+			   f))
+		deps))
+    (close-port f))
+  #t)
+
+(define %standard-phases
+  (modify-phases gnu:%standard-phases
+    (delete 'check) ; tests must be run after installation
+    (replace 'install install)
+    (add-after 'install 'precompile precompile)
+    ;; (add-after 'install 'check check)
+    ;; TODO: In the future we could add a "system-image-generation" phase
+    ;; where we use PackageCompiler.jl to speed up package loading times
+    (delete 'configure)
+    (delete 'bootstrap)
+    (delete 'patch-usr-bin-file)
+    (delete 'build)))
+
+(define* (julia-build #:key inputs (phases %standard-phases)
+                      #:allow-other-keys #:rest args)
+  "Build the given Julia package, applying all of PHASES in order."
+  (apply gnu:gnu-build
+         #:inputs inputs #:phases phases
+         args))
-- 
2.22.0


[-- Attachment #3: 0002-packages-julia-set-JULIA_LOAD_PATH-to-be-able-to-fin.patch --]
[-- Type: text/x-patch, Size: 934 bytes --]

From a0b0bf1350023404b782656c2a093ca0bfd6abb8 Mon Sep 17 00:00:00 2001
From: nixo <nicolo@nixo.xyz>
Date: Sat, 3 Aug 2019 11:19:11 +0200
Subject: [PATCH 2/2] packages: julia: set JULIA_LOAD_PATH to be able to find
 packages

---
 gnu/packages/julia.scm | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/gnu/packages/julia.scm b/gnu/packages/julia.scm
index 43254f25fd..65a5e42beb 100644
--- a/gnu/packages/julia.scm
+++ b/gnu/packages/julia.scm
@@ -482,6 +482,10 @@
        ("patchelf" ,patchelf)
        ("pkg-config" ,pkg-config)
        ("python" ,python-2)))
+    (native-search-paths
+     (list (search-path-specification
+            (variable "JULIA_LOAD_PATH")
+            (files (list "share/julia/packages/")))))
     ;; Julia is not officially released for ARM and MIPS.
     ;; See https://github.com/JuliaLang/julia/issues/10639
     (supported-systems '("i686-linux" "x86_64-linux" "aarch64-linux"))
-- 
2.22.0


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* bug#36856: build: Add julia-build-system
  2019-08-03 10:04           ` Nicolò Balzarotti
@ 2019-09-04 20:21             ` Julien Lepiller
  0 siblings, 0 replies; 9+ messages in thread
From: Julien Lepiller @ 2019-09-04 20:21 UTC (permalink / raw)
  To: Nicolò Balzarotti; +Cc: 36856-done

Hi Nicolò,

I've just pushed your patches as
a44a535ebecd40c52514623a44d31d927ecca9da and
11d73fb412d8728cf916eff9d9750be0bb593076. Sorry for the delay!

I took the liberty to remove some whitespace errors and transform tabs
into spaces, as well as changing the changelog from your second patch.

I'm closing this thread now, so please send your julia packages to a
new bug when they are ready (don't forget to fill in the description,
synopsis, and run guix lint :))

Julien

Le Sat, 3 Aug 2019 10:04:20 +0000,
Nicolò Balzarotti <anothersms@gmail.com> a écrit :

> Yeah I forgot to attach the patches. Here we go
> 
> Il giorno sab 3 ago 2019 alle ore 10:03 Nicolò Balzarotti <
> anothersms@gmail.com> ha scritto:  
> 
> > Hi, I'm back.
> >
> > I fixed the problem I had (I forgot the ./pre-inst-env -.-")
> >
> > Following this discussion, I'm adding ``native-search-paths'' to
> > the julia package. Now, without any other hack (like the setup.jl
> > one), it can find the packages but only when installed with guix
> > package -i . It cannot find them when in an environment (guix
> > environment --ad-hoc julia-package). Can you help?
> >
> > Except from this, I cleaned everything a bit, and added a draft of
> > the documentation. I'm attaching the new patches here (without the
> > julia-xyz part one, to which I'll add all package synopsis and
> > description, and I'll split in multiple patches before
> > re-submitting).
> >
> > Thanks, Nicolò
> >
> > Il giorno mar 30 lug 2019 alle ore 16:02 Nicolò Balzarotti <  
> > anothersms@gmail.com> ha scritto:  
> >  
> >> Thanks for the quick response!
> >>
> >> Well, the environment variable JULIA_LOAD_PATH (that inside julia
> >> is just LOAD_PATH) works exactly like that (is a
> >> column-concatenated path list). It just needs the special
> >> ":@stdlib" path to let julia find its standard libraries.
> >> Example:  
> >> > JULIA_LOAD_PATH=/my/new/path/:/profile/path/:@stdlib julia
> >> > --startup=no  
> >> -E 'LOAD_PATH'
> >> ["/my/new/path/", "/profile/path/", "@stdlib"]
> >>
> >> Is setting this variable from guix fine, or we need a special
> >> GUIX_SOMETHING variable?
> >> Where exactly should I set this?
> >>
> >> Thanks
> >>
> >> Il giorno mar 30 lug 2019 alle ore 14:33 Ricardo Wurmus <  
> >> rekado@elephly.net> ha scritto:  
> >>  
> >>>
> >>> Julien Lepiller <julien@lepiller.eu> writes:
> >>>  
> >>> > Le 30 juillet 2019 16:11:19 GMT+02:00, Ricardo Wurmus <
> >>> rekado@elephly.net> a écrit :  
> >>> >>
> >>> >>Nicolò Balzarotti <anothersms@gmail.com> writes:
> >>> >>  
> >>> >>> 3. By adding a simple startup.jl script, inspired by what
> >>> >>> emacs does.  
> >>> >>This  
> >>> >>> is simplified so I'm not sure it works for every corner case.
> >>> >>> #+begin_src julia
> >>> >>> let paths = [expanduser("~/.guix-profile"),  
> >>> >>"/run/current-system/profile"]  
> >>> >>>     ("GUIX_ENVIRONMENT" in keys(ENV)) && push!(paths,
> >>> >>> ENV["GUIX_ENVIRONMENT"])
> >>> >>>     empty!(LOAD_PATH)
> >>> >>>     push!.(Ref(LOAD_PATH), joinpath.(paths,
> >>> >>> "share/julia/packages/")) push!(LOAD_PATH, "@stdlib")
> >>> >>>     push!.(Ref(DEPOT_PATH), joinpath.(paths, "share/julia/"))
> >>> >>>     nothing
> >>> >>> end
> >>> >>> #+end_src  
> >>> >>
> >>> >>Could this perhaps be handled by a profile hook that is
> >>> >>included only when the profile manifest contains a julia
> >>> >>package?  
> >>> >
> >>> > Or simply with an environment variable? GUIX_JULIA_PATH or
> >>> > something?  
> >>>
> >>> If this is the route you go down, please ensure that it can be
> >>> used as a search path with more than one directory.  This would
> >>> make it possible to extend a Julia environment with the contents
> >>> of more than one profile.
> >>>
> >>> --
> >>> Ricardo
> >>>
> >>>  

^ permalink raw reply	[flat|nested] 9+ messages in thread

end of thread, other threads:[~2019-09-04 20:22 UTC | newest]

Thread overview: 9+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2019-07-30 12:49 [bug#36856] build: Add julia-build-system Nicolò Balzarotti
2019-07-30 14:08 ` Ricardo Wurmus
2019-07-30 14:11 ` Ricardo Wurmus
2019-07-30 14:23   ` Julien Lepiller
2019-07-30 14:33     ` Ricardo Wurmus
2019-07-30 16:02       ` Nicolò Balzarotti
2019-08-03 10:03         ` Nicolò Balzarotti
2019-08-03 10:04           ` Nicolò Balzarotti
2019-09-04 20:21             ` bug#36856: " Julien Lepiller

Code repositories for project(s) associated with this public inbox

	https://git.savannah.gnu.org/cgit/guix.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).