;;; GNU Guix --- Functional package management for GNU

;;; Copyright © 2018 Julien Lepiller <julien@lepiller.eu>

;;;

;;; 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 (more packages scala)

  #:use-module ((guix licenses) #:prefix license:)

  #:use-module (gnu packages)

  #:use-module (guix packages)

  #:use-module (guix download)

  #:use-module (guix git-download)

  #:use-module (guix utils)

  #:use-module (guix build-system ant)

  #:use-module (guix build-system copy)

  #:use-module (guix build-system gnu)

  #:use-module (gnu packages base)

  #:use-module (gnu packages bash)

  #:use-module (gnu packages compression)

  #:use-module (gnu packages java)

  #:use-module (gnu packages protobuf)

  #:use-module (gnu packages web)

  #:use-module (more packages java))

;; This package downloads the so-called official version of scala, a pre-built

;; binary by the scala developers.

;; This binary should never be made part of Guix itself, because we have

;; ways to bootstrap it properly. The bootstrap project of scala takes time,

;; so in the meantime... here you are :(

(define %binary-scala

  (package

    (name "scala")

    (version "2.13.6")

    (source (origin

              (method url-fetch)

              (uri (string-append "https://downloads.lightbend.com/scala/"

                                  version  "/scala-" version ".tgz"))

              (sha256

               (base32

                "0hzd6pljc8z5fwins5a05rwpx2w7wmlb6gb8973c676i7i895ps9"))))

    (build-system copy-build-system)

    (arguments

     `(#:install-plan

       '(("." ""))

       #:phases

       (modify-phases %standard-phases

         (add-before 'install 'set-java-home

           (lambda* (#:key inputs #:allow-other-keys)

             (substitute* (find-files "bin" ".")

               (("^#!.*" shebang)

                (string-append shebang "\nJAVA_HOME="

                               (assoc-ref inputs "openjdk"))))))

         (add-before 'set-java-home 'remove-unneeded

           (lambda _

             (for-each delete-file (find-files "bin" "bat$")))))))

    (inputs

     `(("openjdk" ,openjdk14)))

    (home-page "https://scala-lang.org/")

    (synopsis "Scala programming language")

    (description "Scala combines object-oriented and functional programming in

one concise, high-level language.  Scala's static types help avoid bugs in

complex applications, and its JVM and JavaScript runtimes let you build

high-performance systems with easy access to huge ecosystems of libraries.")

    (license license:bsd-3)))

(define scala-asm

  (package

    (inherit java-asm)

    (version "9.1.0")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/scala/scala-asm")

                     (commit "s-9.1")))

              (file-name (git-file-name "scala-asm" version))

              (sha256

               (base32

                "1wsrlb6kb0fwxjdqanxqgmq4qcyq9gqn129w3l4bj7gvlspll33l"))))

    (arguments

     `(#:jar-name "java-asm.jar"

       #:source-dir "src/main/java"

       ;; no tests

       #:tests? #f))))

(define-public scala

  (package

    (inherit %binary-scala)

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/scala/scala")

                     (commit (string-append "v" (package-version %binary-scala)))))

              (file-name (git-file-name "scala" (package-version %binary-scala)))

              (sha256

               (base32

                "1gl156n6nd4xnq3cb6f1bbfbb9s4cp6bd9xczl99plpx6jwnpmhl"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (replace 'build

           (lambda* (#:key inputs #:allow-other-keys)

             (define* (build-project directory jar-name name #:optional (jar? #t))

               (let* ((build-dir (string-append "build/class/" name))

                      (java-files (find-files directory ".*.java$"))

                      (scala-files (find-files directory ".*.scala$")))

                 (mkdir-p build-dir)

                 (format #t "Building project ~a...~%" name)

                 (with-output-to-file (string-append build-dir "/" name ".properties")

                   (lambda _

                     (format #t "version.number=~a~%" ,(package-version this-package))

                     (format #t "maven.version.number=~a~%" ,(package-version this-package))))

                 (unless (eq? scala-files '())

                   (apply invoke "scalac" "-classpath"

                          (string-append

                            ;; Add any top-level directory in build that may contain

                            ;; .class files, but don't actually add build/ iteself or

                            ;; any individual class file.

                            (string-join

                              (filter (lambda (s) (eq? (string-count s #\/) 2))

                                      (find-files "build/class" "." #:directories? #t))

                              ":"))

                          "-d" build-dir "-nobootcp"

                          (append scala-files java-files)))

                 (unless (eq? java-files '())

                   (apply invoke "javac" "-classpath"

                          (string-append

                            (getenv "CLASSPATH") ":"

                            (string-join

                              (filter (lambda (s) (eq? (string-count s #\/) 2))

                                      (find-files "build/class" "." #:directories? #t))

                              ":"))

                          "-g" "-source" "1.8" "-target" "1.8"

                          "-d" build-dir java-files))

                 (mkdir-p "build/jar")

                 (when jar?

                   (invoke "jar" "cf" (string-append "build/jar/" jar-name)

                           "-C" build-dir "."))))

             (let ((scala-asm (assoc-ref inputs "scala-asm")))

               (setenv "CLASSPATH" (string-join (find-files scala-asm ".*.jar$") ":")))

             (setenv "JAVA_OPTS" "-Xmx1G")

             (build-project "src/library" "scala-library.jar" "library")

             (build-project "src/reflect" "scala-reflect.jar" "reflect")

             (build-project "src/compiler" "scala-compiler.jar" "compiler" #f)

             (build-project "src/interactive" "scala-compiler-interactive.jar" "interactive" #f)

             (build-project "src/scaladoc" "scala-compiler-doc.jar" "scaladoc" #f)

             (build-project "src/repl" "scala-repl.jar" "repl" #f)

             (build-project "src/repl-frontend" "scala-repl-frontend.jar" "replFrontend" #f)

             (build-project "src/scalap" "scalap.jar" "scalap")

             ;; create scala-compiler.jar as a union of some of those above

             (mkdir-p "build/class/scala-compiler")

             (with-directory-excursion "build/class/scala-compiler"

               (let ((scala-asm (assoc-ref inputs "scala-asm")))

                 (invoke "jar" "xf" (car (find-files scala-asm ".*.jar$"))))

               (copy-recursively "../compiler" ".")

               (copy-recursively "../interactive" ".")

               (copy-recursively "../scaladoc" ".")

               (copy-recursively "../repl" ".")

               (copy-recursively "../replFrontend" "."))

             (invoke "jar" "cf" "build/jar/scala-compiler.jar"

                     "-C" "build/class/scala-compiler" ".")))

         (replace 'install

           (lambda* (#:key inputs outputs #:allow-other-keys)

             (let* ((out (assoc-ref outputs "out"))

                    (lib (string-append out "/lib"))

                    (jna (assoc-ref inputs "java-native-access"))

                    (jline-terminal (assoc-ref inputs "java-jline3-terminal"))

                    (jline-reader (assoc-ref inputs "java-jline3-reader")))

               (mkdir-p lib)

               (for-each

                 (lambda (jar)

                   (copy-file jar (string-append lib "/" (basename jar))))

                 (find-files "build/jar" ".*.jar$"))

               (symlink (car (find-files jna "linux-.*.jar$"))

                        (string-append lib "/jna-lib.jar"))

               (symlink (car (find-files jna "jna.jar$"))

                        (string-append lib "/jna.jar"))

               (symlink (car (find-files jline-reader ".*.jar$"))

                        (string-append lib "/jline-reader.jar"))

               (symlink (car (find-files jline-terminal ".*.jar$"))

                        (string-append lib "/jline-terminal.jar")))))

         (add-after 'install 'install-bin

           (lambda* (#:key outputs #:allow-other-keys)

             (let* ((out (assoc-ref outputs "out"))

                    (bin (string-append out "/bin")))

               (define (install-script script class)

                 (let ((script (string-append bin "/" script)))

                   (copy-file "src/compiler/templates/tool-unix.tmpl" script)

                   ;; See project/ScalaTool and build.sbt

                   (substitute* script

                     (("@@") "@")

                     (("@class@") class)

                     (("@properties@") "-Dscala.home=\"$SCALA_HOME\"")

                     (("@javaflags@") "-Xmx256M -Xms32M")

                     (("@toolflags@") "")

                     (("@classpath@") ""))

                   (chmod script #o755)))

               (mkdir-p bin)

               (install-script "scala" "scala.tools.nsc.MainGenericRunner")

               (install-script "scalac" "scala.tools.nsc.Main")

               (install-script "fsc" "scala.tools.nsc.fsc.CompileClient")

               (install-script "scaladoc" "scala.tools.nsc.ScalaDoc")

               (install-script "scalap" "scala.tools.scalap.Main")))))))

    (inputs

     `(("scala" ,%binary-scala)

       ("scala-asm" ,scala-asm)

       ("java-jline3-terminal" ,java-jline3-terminal)

       ("java-jline3-reader" ,java-jline3-reader)

       ("java-native-access" ,java-native-access)))))

(define-public sbt-ivy

  (package

    (inherit java-apache-ivy)

    (name "sbt-ivy")

    (version "2.4.0-rc1")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/sbt/ivy")

                     (commit version)))

              (file-name (git-file-name name version))

              (sha256

               (base32

                "1i13iqq8r4lqkxhg9gc192874hs3wyxykyg64m98vydf5zddb5zd"))

              (modules '((guix build utils)))

              (snippet

               ; these jars are not build products, but they interfere with the

               ; ant-build-system, and we don't run the tests anyway.

               `(delete-file-recursively "test"))

              (patches

                (search-patches "sbt-ivy-fix-bouncycastle-api.patch"))))

    (arguments

     (substitute-keyword-arguments (package-arguments java-apache-ivy)

       ((#:phases phases)

        `(modify-phases ,phases

           (add-after 'unpack 'make-writable

             (lambda _

               (for-each make-file-writable (find-files "."))

               #t))))))))

(define %default-java-locations

  '("shared/src/main/java" "jvm/src/main/java" "src/main/java"))

(define %default-scala-locations

  '("shared/src/main/scala" "jvm/src/main/scala" "src/main/scala"))

(define %default-resources-locations

  '("shared/src/main/resources" "jvm/src/main/resources" "src/main/resources"))

;; TODO: put it in guix/build/java-utils.scm

(define* (build-scala-phase spec

                            #:key (scala-arguments '())

                                  (java-locations %default-java-locations)

                                  (scala-locations %default-scala-locations)

                                  (resources-locations %default-resources-locations))

  `(lambda* (#:key inputs #:allow-other-keys)

     (define (get-files directory expr)

       (if (file-exists? directory)

           (find-files directory expr)

           '()))

     (define (build-scala directory name)

       (let* ((build-directory (string-append (getcwd) "/build"))

              (current-build-directory (string-append build-directory "/" name))

              (jar-name (string-append name ".jar"))

              (manifest (string-append current-build-directory "/META-INF/MANIFEST.MF"))

              (classpath

                ;; Add any top-level directory in build that may contain

                ;; .class files, but don't actually add build/ iteself or

                ;; any individual class file.

                (string-join

                  (map

                    (lambda (s) (string-append (getcwd) "/" s))

                    (filter

                      (lambda (s) (eq? (string-count s #\/) 1))

                      (find-files "build" "." #:directories? #t)))

                  ":")))

           (mkdir-p current-build-directory)

           (with-directory-excursion directory

             (let ((java-files

                     (apply append

                            (map (lambda (loc) (get-files loc "\\.java$"))

                                 ',java-locations)))

                   (scala-files

                     (apply append

                            (map (lambda (loc) (get-files loc "\\.scala$"))

                                 ',scala-locations))))

               (format #t "Building project ~a...~%" jar-name)

               (unless (eq? scala-files '())

                 (apply invoke "scalac" "-classpath"

                        (string-append

                          (getenv "CLASSPATH") ":"

                          classpath)

                        "-d" current-build-directory ,@scala-arguments

                        (append scala-files java-files)))

               (unless (eq? java-files '())

                 (apply invoke "javac" "-classpath"

                        (string-append

                          (getenv "CLASSPATH") ":"

                          classpath)

                        "-d" current-build-directory java-files)))

             (for-each

               (lambda (dir)

                 (when (file-exists? dir)

                   (copy-recursively dir current-build-directory)))

               ',resources-locations))

           (if (file-exists? manifest)

             (invoke "jar" "cfm" (string-append "build/jar/" jar-name)

                     manifest "-C" current-build-directory ".")

             (invoke "jar" "cf" (string-append "build/jar/" jar-name)

                     "-C" current-build-directory "."))))

     (mkdir-p "build/jar")

     (for-each

       (lambda (s)

         (apply build-scala s))

       ',spec)))

(define-public scala-data-class

  (package

    (name "scala-data-class")

    (version "0.2.5")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/alexarchambault/data-class")

                     (commit (string-append "v" version))))

              (file-name (git-file-name name version))

              (sha256

               (base32

                "10csh0gc0snd8xpxmx8pad1rgci1i8xjhbfcx02njiy2vh4x5lh3"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (replace 'build

           ,(build-scala-phase '(("." "data-class"))

              #:scala-arguments '("-Ymacro-annotations")))

         (replace 'install

           (install-jars "build")))))

    (native-inputs

     `(("scala" ,scala)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public scala-xml

  (package

    (name "scala-xml")

    (version "2.0.0")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/scala/scala-xml")

                     (commit (string-append "v" version))))

              (file-name (git-file-name name version))

              (sha256

               (base32

                "16nw209dwj82mn0jc3ax77jmg0jqvvbc8wdwc7kaq3102k1wdv73"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (add-after 'unpack 'move-version-specific

           (lambda _

             (copy-file "shared/src/main/scala-2.13+/scala/xml/ScalaVersionSpecific.scala"

                        "shared/src/main/scala/scala/xml/ScalaVersionSpecific.scala")

             #t))

         (replace 'build

           ,(build-scala-phase '(("." "scala-xml"))))

         (replace 'install

           (install-jars "build")))))

    (native-inputs

     `(("scala" ,scala)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public scala-simulacrum

  (package

    (name "scala-simulacrum")

    (version "1.0.1")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/typelevel/simulacrum")

                     (commit (string-append "v" version))))

              (file-name (git-file-name name version))

              (sha256

               (base32

                "1a4yrv9x6vb989385m0rmb7y6lcd8b7lcq5ksp37k70dl3piam4z"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (replace 'build

           ,(build-scala-phase

              '(("core" "simulacrum"))

               #:scala-arguments

               '("-Ymacro-annotations" "-deprecation" "-feature"

                 "-language:higherKinds" "-language:implicitConversions")))

         (replace 'install

           (install-jars "build")))))

    (native-inputs

     `(("scala" ,scala)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public scala-geny

  (package

    (name "scala-geny")

    (version "0.6.10")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/com-lihaoyi/geny")

                     (commit version)))

              (file-name (git-file-name name version))

              (sha256

               (base32

                "1km1xpvyy14ipgv019axg31vd9csnsi54cp8sw9mzdjikh6i211f"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (replace 'build

           ,(build-scala-phase '(("geny" "scala-geny"))

              #:scala-locations '("src")

              #:java-locations '("src")))

         (replace 'install

           (install-jars "build")))))

    (native-inputs

     `(("scala" ,scala)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public scala-sourcecode

  (package

    (name "scala-sourcecode")

    (version "0.2.7")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/com-lihaoyi/sourcecode")

                     (commit version)))

              (file-name (git-file-name name version))

              (sha256

               (base32

                "11xd0a0svm15hcknpsfzsyl9sy7dc692b93i39j3z8mgrnh5x4di"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (replace 'build

           ,(build-scala-phase '(("sourcecode" "scala-sourcecode"))

              #:scala-locations '("src" "src-2")

              #:java-locations '("src")))

         (replace 'install

           (install-jars "build")))))

    (native-inputs

     `(("scala" ,scala)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public scala-fastparse

  (package

    (name "scala-fastparse")

    (version "2.3.2")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/com-lihaoyi/fastparse")

                     (commit version)))

              (file-name (git-file-name name version))

              (sha256

               (base32

                "04wqggkywfy3q733x18mi873wh23w1ix5kypradpz0njdyfznikh"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (add-after 'unpack 'generate-source

           (lambda _

             ;; this file would be generated by build.sc, but it requires

             ;; more dependencies

             (with-output-to-file "fastparse/src/fastparse/SequencerGen.scala"

               (lambda _

                 (display "package fastparse

trait SequencerGen[Sequencer[_, _, _]] extends LowestPriSequencer[Sequencer]{

  protected[this] def Sequencer0[A, B, C](f: (A, B) => C): Sequencer[A, B, C]

")

                 (display

                   (string-join

                     (map

                       (lambda (i)

                         (let* ((ts (map

                                      (lambda (n) (string-append "T" (number->string n)))

                                      (iota i 1)))

                                (chunks

                                  (map

                                    (lambda (n) (string-append "t._" (number->string n)))

                                    (iota i 1)))

                                (tsD (string-join

                                       (append ts (list "D"))

                                       ","))

                                (anys (string-join

                                        (map (lambda (t) "Any")

                                             ts)

                                        ", ")))

                           (string-append

                             "val BaseSequencer" (number->string i) ": Sequencer[(" anys "), Any, (" anys ", Any)] =

  Sequencer0((t, d) => (" (string-join chunks ", ") ", d))

implicit def Sequencer" (number->string i) "[" tsD "]: Sequencer[(" (string-join ts ", ") "), D, (" tsD ")] =

  BaseSequencer" (number->string i) ".asInstanceOf[Sequencer[(" (string-join ts ", ") "), D, (" tsD ")]]

")))

                       (iota 20 2))

                     "\n"))

                 (display "}

trait LowestPriSequencer[Sequencer[_, _, _]]{

  protected[this] def Sequencer0[A, B, C](f: (A, B) => C): Sequencer[A, B, C]

  implicit def Sequencer1[T1, T2]: Sequencer[T1, T2, (T1, T2)] = Sequencer0{case (t1, t2) => (t1, t2)}

}

")))

             #t))

         (replace 'build

           ,(build-scala-phase '(("fastparse" "scala-fastparse")

                                 ("scalaparse" "scala-scalaparse"))

              #:scala-locations '("src" "src-jvm")

              #:java-locations '("src" "src-jvm")))

         (replace 'install

           (install-jars "build")))))

    (native-inputs

     `(("scala" ,scala)))

    (propagated-inputs

     `(("scala-geny" ,scala-geny)

       ("scala-sourcecode" ,scala-sourcecode)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public scala-dirs-dev-directories

  (package

    (name "scala-dirs-dev-directories")

    (version "23")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/dirs-dev/directories-jvm")

                     ;; exact version used by coursier

                     (commit "7acadf2ab9a4ce306d840d652cdb77fade11b94b")))

              (file-name (git-file-name name version))

              (sha256

               (base32

                "09h2dxzbkhki65kkkm29w7id0m0hgswsbwrbb2ix50yj297n6nbm"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (replace 'build

           ,(build-scala-phase '(("." "scala-directories"))))

         (replace 'install

           (install-jars "build")))))

    (native-inputs

     `(("scala" ,scala)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public scala-windowsansi

  (package

    (name "scala-windowsansi")

    (version "0.0.3")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/alexarchambault/windows-ansi")

                     (commit (string-append "v" version))))

              (file-name (git-file-name name version))

              (sha256

               (base32

                "0r21yhxmwi71qx7qqrpk0z7ykcd08xs7fl6yhzwlqjl0kar7wq0m"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (replace 'build

           ,(build-scala-phase '(("jni" "scala-windowsansi-jni")

                                 ("ps" "scala-windowsansi-ps"))))

         (add-after 'unpack 'remove-proprietary-interfaces

           (lambda _

             (delete-file

               "jni/src/main/java/io/github/alexarchambault/windowsansi/NativeImageFeature.java")

             (delete-file

               "jni/src/main/java/io/github/alexarchambault/windowsansi/WindowsAnsiSubstitutions.java")))

         (replace 'install

           (install-jars "build")))))

    (native-inputs

     `(("scala" ,scala)))

    (propagated-inputs

     `(("java-jansi" ,java-jansi)))

    (home-page "")

    (synopsis "")

    (description "")

    (license license:asl2.0)))

(define-public scala-argonaut

  (package

    (name "scala-argonaut")

    (version "6.3.3")

    (source (origin

              (method git-fetch)

              (uri (git-reference

                     (url "https://github.com/argonaut-io/argonaut")

                     (commit (string-append "v" version))))

              (file-name (git-file-name name version))

              (sha256

               (base32

                "1pvc5jklaqqx957brkrwywvh5gsq08xd2k4c8bm4gnkd9b5n8wnl"))))

    (build-system ant-build-system)

    (arguments

     `(#:tests? #f

       #:phases

       (modify-phases %standard-phases

         (add-before 'build 'generate-sources

           (lambda _

             ;; Converted from project/Boilerplate.scala

             (define header "package argonaut\n\n")

             (define arities (iota 22 1))

             (define aritiesExceptOne (iota 21 2))

             (define (arityChars n)

               (string (integer->char (+ (char->integer #\A) (- n 1)))))

             (define (functionTypeParameters arity)

               (string-join (map arityChars (iota arity 1)) ", "))

             (define (tupleFields arity)

               (string-join

                 (map

                   (lambda (n)

                     (string-append "x._" (number->string n)))

                   (iota arity 1))

                 ", "))

             (define (listPatternMatch arity)

               (string-append

                 (string-join

                   (map

                     (lambda (n)

                       (string-append "c" (string-downcase (arityChars n))))

                     (iota arity 1))

                   " :: ")

                 " :: Nil"))

             (define (jsonStringParams arity)

               (string-join

                 (map

                   (lambda (n)

                     (format #f "~an: JsonString" (string-downcase (arityChars n))))

                   (iota arity 1))

                 ", "))

             (define (jsonStringParamNames arity)

               (string-join

                 (map

                   (lambda (n)

                     (format #f "~an" (string-downcase (arityChars n))))

                   (iota arity 1))

                 ", "))

             (with-output-to-file "argonaut/shared/src/main/scala/argonaut/GeneratedDecodeJsons.scala"

               (lambda _

                 (define (decodeJsonContextArities n)

                   (string-join

                     (map (lambda (n) (format #f "~a: DecodeJson" (arityChars n)))

                          (iota n 1))

                     ","))

                 (define (decodeJsonParams n)

                   (string-join

                     (map

                       (lambda (n)

                         (define char (arityChars n))

                         (format #f "decode~a: DecodeJson[~a]"

                                 (string-downcase char) char))

                       (iota n 1))

                     ", "))

                 (define tupleDecodes

                   (map

                     (lambda (arity)

                       (define forComprehensionLines

                         (string-join

                           (map

                             (lambda (n)

                               (define char (arityChars n))

                               (format #f "          x~a <- decode~a(c~a)"

                                       (string-downcase char) (string-downcase char)

                                       (string-downcase char)))

                             (iota arity 1))

                           "\n"))

                       (define yieldResult

                         (string-join

                           (map

                             (lambda (n)

                               (string-append "x" (string-downcase (arityChars n))))

                             (iota arity 1))

                           ", "))

                       (format #f "

  implicit def Tuple~aDecodeJson[~a](implicit ~a): DecodeJson[(~a)] =

    DecodeJson(c =>

      c.jdecode[List[HCursor]] flatMap {

        case ~a => for {

~a

        } yield (~a)

        case _ => DecodeResult.fail(\"[~a]Tuple~a[~a]\", c.history)

      })

"

                               arity

                               (functionTypeParameters arity)

                               (decodeJsonParams arity)

                               (functionTypeParameters arity)

                               (listPatternMatch arity)

                               forComprehensionLines

                               yieldResult

                               (functionTypeParameters arity)

                               arity

                               (functionTypeParameters arity)))

                     aritiesExceptOne))

                 (define jdecode1 "

  def jdecode1[A, X](f: A => X)(implicit decodea: DecodeJson[A]): DecodeJson[X] =

    decodea.map(f)

")

                 (define jdecodes

                   (map

                     (lambda (arity)

                       (format #f "

  def jdecode~a[~a, X](f: (~a) => X)(implicit dx: DecodeJson[(~a)]): DecodeJson[X] =

    dx.map(x => f(~a))"

                               arity

                               (functionTypeParameters arity)

                               (functionTypeParameters arity)

                               (functionTypeParameters arity)

                               (tupleFields arity)))

                     aritiesExceptOne))

                 (define jdecode1L "

  def jdecode1L[A: DecodeJson, X](f: A => X)(an: JsonString): DecodeJson[X] =

    DecodeJson(x => for {

      aa <- x.get[A](an)

    } yield f(aa))")

                 (define jdecodeLs

                   (map

                     (lambda (arity)

                       (define forComprehensionLines

                         (string-join

                           (map

                             (lambda (n)

                               (define upperChar (arityChars n))

                               (define lowerChar (string-downcase upperChar))

                               (format #f "       ~a~a <- x.get[~a](~an)"

                                       lowerChar lowerChar upperChar lowerChar))

                             (iota arity 1))

                           "\n"))

                       (define yieldExpression

                         (string-join

                           (map

                             (lambda (n)

                               (define lowerChar (string-downcase (arityChars n)))

                               (format #f "~a~a" lowerChar lowerChar))

                             (iota arity 1))

                           ", "))

                       (format #f "

  def jdecode~aL[~a, X](f: (~a) => X)(~a): DecodeJson[X] =

    DecodeJson(x => for {

~a

    } yield f(~a))"

                               arity

                               (decodeJsonContextArities arity)

                               (functionTypeParameters arity)

                               (jsonStringParams arity)

                               forComprehensionLines

                               yieldExpression))

                     aritiesExceptOne))

                 (display header)

                 (display "trait GeneratedDecodeJsons {

  this: DecodeJsons =>

  import Json._

")

                 (display

                   (string-join

                     (append tupleDecodes (cons jdecode1 jdecodes)

                             (cons jdecode1L jdecodeLs))

                     ""))

                 (display "\n}\n")))

             (with-output-to-file "argonaut/shared/src/main/scala/argonaut/GeneratedEncodeJsons.scala"

               (lambda _

                 (define (encodeJsonContextArities n)

                   (string-join

                     (map

                       (lambda (n)

                         (format #f "~a: EncodeJson" (arityChars n)))

                       (iota n 1))

                     ", "))

                 (define (encodeJsonParams n)

                   (string-join

                     (map

                       (lambda (n)

                         (define char (arityChars n))

                         (format #f "encode~a: EncodeJson[~a]"

                                 (string-downcase char) char))

                       (iota n 1))

                     ", "))