;;; Copyright © 2019 Ricardo Wurmus <rekado@elephly.net>
;;; Copyright © 2020 Brett Gilio <brettg@gnu.org>
;;; Copyright © 2020 Marius Bakke <marius@gnu.org>
+;;; Copyright © 2020 Simon Tournier <zimon.toutoune@gmail.com>
+;;; Copyright © 2020 divoplade <d@divoplade.fr>
+;;; Copyright © 2020 pukkamustard <pukkamustard@posteo.net>
+;;; Copyright © 2021 aecepoglu <aecepoglu@fastmail.fm>
+;;; Copyright © 2021 Sharlatan Hellseher <sharlatanus@gmail.com>
;;;
;;; This file is part of GNU Guix.
;;;
#:use-module (gnu packages glib)
#:use-module (gnu packages gnome)
#:use-module (gnu packages gtk)
+ #:use-module (gnu packages guile)
#:use-module (gnu packages libevent)
#:use-module (gnu packages libffi)
#:use-module (gnu packages llvm)
#:use-module (gnu packages time)
#:use-module (gnu packages tls)
#:use-module (gnu packages virtualization)
+ #:use-module (gnu packages web)
#:use-module (gnu packages web-browsers)
#:use-module (gnu packages xml)
#:use-module (gnu packages xorg)
(number->string file-number) "/" name "-" version
".tar.gz"))
-;; Janestreet packages are found in a similar way and all need the same patch.
(define (janestreet-origin name version hash)
(origin (method url-fetch)
- (uri (string-append "https://ocaml.janestreet.com/ocaml-core/"
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
(version-major+minor version) "/files/"
- name "-" version ".tar.gz"))
- (sha256 (base32 hash))
- (modules '((guix build utils)))
- (snippet
- (let ((pattern (string-append "lib/" name)))
- `(begin
- ;; install.ml contains an invalid reference to the ppx file and
- ;; propagates this error to the generated META file. It
- ;; looks for it in the "lib" directory, but it is installed in
- ;; "lib/ocaml/site-lib/package". This substitute does not change
- ;; this file for non ppx packages.
- (substitute* "install.ml"
- ((,pattern) (string-append "lib/ocaml/site-lib/" ,name)))
- ;; The standard Makefile would try to install janestreet modules
- ;; in OCaml's directory in the store, which is read-only.
- (substitute* "Makefile"
- (("--prefix")
- "--libdir $(LIBDIR) --prefix"))
- #t)))))
-
-;; They also require almost the same set of arguments
-(define janestreet-arguments
- `(#:use-make? #t
- #:make-flags
- (list (string-append "CONFIGUREFLAGS=--prefix "
- (assoc-ref %outputs "out")
- " --enable-tests")
- (string-append "LIBDIR="
- (assoc-ref %outputs "out")
- "/lib/ocaml/site-lib")
- ;; for ocaml-bin-prot, otherwise ignored
- (string-append "OCAML_TOPLEVEL_PATH="
- (assoc-ref %build-inputs "findlib")
- "/lib/ocaml/site-lib"))
- #:phases (modify-phases %standard-phases (delete 'configure))))
+ name "-v" (version-major+minor+point version)
+ ".tar.gz"))
+ (sha256 (base32 hash))))
-(define-public ocaml-4.09
+(define-public camlboot
+ (let ((commit "506280c6e0813e0e794988151a8e46be55373ebc")
+ (revision "0"))
+ (package
+ (name "camlboot")
+ (version (git-version "0.0.0" revision commit))
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Ekdohibs/camlboot")
+ (commit commit)
+ (recursive? #t)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0vimxl4karw9ih3npyc5rhxg85cjh6fqjbq3dzj7j2iymlhwfbkv"))
+ (modules '((guix build utils)))
+ (snippet
+ `(begin
+ ;; Remove bootstrap binaries and pre-generated source files,
+ ;; to ensure we actually bootstrap properly.
+ (for-each delete-file (find-files "ocaml-src" "^.depend$"))
+ (delete-file "ocaml-src/boot/ocamlc")
+ (delete-file "ocaml-src/boot/ocamllex")
+ ;; Ensure writable
+ (for-each
+ (lambda (file)
+ (chmod file (logior (stat:mode (stat file)) #o200)))
+ (find-files "." "."))))))
+ (build-system gnu-build-system)
+ (arguments
+ `(#:make-flags (list "_boot/ocamlc") ; build target
+ #:tests? #f ; no tests
+ #:phases
+ (modify-phases %standard-phases
+ (delete 'configure)
+ (add-before 'build 'no-autocompile
+ (lambda _
+ ;; prevent a guile warning
+ (setenv "GUILE_AUTO_COMPILE" "0")))
+ (replace 'install
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (bin (string-append out "/bin")))
+ (mkdir-p bin)
+ (install-file "_boot/ocamlc" bin)
+ (rename-file "miniml/interp/lex.byte" "ocamllex")
+ (install-file "ocamllex" bin)))))))
+ (native-inputs
+ `(("guile" ,guile-3.0)))
+ (properties
+ `((max-silent-time . 14400))) ; 4 hours, expected even on x86_64
+ (home-page "https://github.com/Ekdohibs/camlboot")
+ (synopsis "OCaml source bootstrap")
+ (description "OCaml is written in OCaml. Its sources contain a pre-compiled
+bytecode version of @command{ocamlc} and @command{ocamllex} that are used to
+build the next version of the compiler. Camlboot implements a bootstrap for
+the OCaml compiler and provides a bootstrapped equivalent to these files.
+
+It contains a compiler for a small subset of OCaml written in Guile Scheme,
+an interpreter for OCaml written in that subset and a manually-written lexer
+for OCaml. These elements eliminate the need for the binary bootstrap in
+OCaml and can effectively bootstrap OCaml 4.07.
+
+This package produces a native @command{ocamlc} and a bytecode @command{ocamllex}.")
+ (license license:expat))))
+
+(define-public ocaml-4.11
(package
(name "ocaml")
- (version "4.09.0")
+ (version "4.11.1")
(source (origin
(method url-fetch)
(uri (string-append
"/ocaml-" version ".tar.xz"))
(sha256
(base32
- "1v3z5ar326f3hzvpfljg4xj8b9lmbrl53fn57yih1bkbx3gr3yzj"))))
+ "0k4521c0p10c5ams6vjv5qkkjhmpkb0bfn04llcz46ah0f3r2jpa"))))
(build-system gnu-build-system)
(native-search-paths
(list (search-path-specification
;; distributed under lgpl2.0.
(license (list license:qpl license:lgpl2.0))))
-(define-public ocaml-4.07
+(define-public ocaml-4.09
+ (package
+ (inherit ocaml-4.11)
+ (version "4.09.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://caml.inria.fr/pub/distrib/ocaml-"
+ (version-major+minor version)
+ "/ocaml-" version ".tar.xz"))
+ (sha256
+ (base32
+ "1v3z5ar326f3hzvpfljg4xj8b9lmbrl53fn57yih1bkbx3gr3yzj"))))))
+
+;; This package is a bootstrap package for ocaml-4.07. It builds from camlboot,
+;; using the upstream sources for ocaml 4.07. It installs a bytecode ocamllex
+;; and ocamlc, the bytecode interpreter ocamlrun, and generated .depend files
+;; that we otherwise remove for bootstrap purposes.
+(define ocaml-4.07-boot
(package
(inherit ocaml-4.09)
(version "4.07.1")
"/ocaml-" version ".tar.xz"))
(sha256
(base32
- "1f07hgj5k45cylj1q3k5mk8yi02cwzx849b1fwnwia8xlcfqpr6z"))))
+ "1f07hgj5k45cylj1q3k5mk8yi02cwzx849b1fwnwia8xlcfqpr6z"))
+ (modules '((guix build utils)))
+ (snippet
+ `(begin
+ ;; Remove bootstrap binaries and pre-generated source files,
+ ;; to ensure we actually bootstrap properly.
+ (for-each delete-file (find-files "." "^.depend$"))
+ (delete-file "boot/ocamlc")
+ (delete-file "boot/ocamllex")))))
+ (arguments
+ `(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-before 'configure 'copy-bootstrap
+ (lambda* (#:key inputs #:allow-other-keys)
+ (let ((camlboot (assoc-ref inputs "camlboot")))
+ (copy-file (string-append camlboot "/bin/ocamllex") "boot/ocamllex")
+ (copy-file (string-append camlboot "/bin/ocamlc") "boot/ocamlc")
+ (chmod "boot/ocamllex" #o755)
+ (chmod "boot/ocamlc" #o755))))
+ (replace 'configure
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (mandir (string-append out "/share/man")))
+ (invoke "./configure"
+ "--prefix" out
+ "--mandir" mandir))))
+ (replace 'build
+ (lambda* (#:key parallel-build? #:allow-other-keys)
+ (define* (make . args)
+ (apply invoke "make"
+ (append (if parallel-build?
+ `("-j" ,(number->string (parallel-job-count)))
+ '())
+ args)))
+ ;; create empty .depend files because they are included by various
+ ;; Makefiles, and they have no rule to generate them.
+ (invoke "touch" ".depend" "stdlib/.depend" "byterun/.depend"
+ "tools/.depend" "lex/.depend" "asmrun/.depend"
+ "debugger/.depend" "ocamltest/.depend" "ocamldoc/.depend"
+ "ocamldoc/stdlib_non_prefixed/.depend"
+ "otherlibs/bigarray/.depend" "otherlibs/graph/.depend"
+ "otherlibs/raw_spacetime_lib/.depend" "otherlibs/str/.depend"
+ "otherlibs/systhreads/.depend" "otherlibs/threads/.depend"
+ "otherlibs/unix/.depend" "otherlibs/win32unix/.depend")
+ ;; We cannot build ocamldep until we have created all the .depend
+ ;; files, so replace it with ocamlc -depend.
+ (substitute* "tools/Makefile"
+ (("\\$\\(CAMLRUN\\) ./ocamldep") "../boot/ocamlc -depend"))
+ (substitute* '("otherlibs/graph/Makefile"
+ "otherlibs/systhreads/Makefile"
+ "otherlibs/threads/Makefile"
+ "otherlibs/unix/Makefile")
+ (("\\$\\(CAMLRUN\\) ../../tools/ocamldep")
+ "../../boot/ocamlc -depend"))
+ (substitute* '("otherlibs/bigarray/Makefile"
+ "otherlibs/raw_spacetime_lib/Makefile"
+ "otherlibs/str/Makefile"
+ "otherlibs/win32unix/Makefile")
+ (("\\$\\(CAMLRUN\\) \\$\\(ROOTDIR\\)/tools/ocamldep")
+ "../../boot/ocamlc -depend"))
+ ;; Ensure we copy needed file, so we can generate a proper .depend
+ (substitute* "ocamldoc/Makefile"
+ (("include Makefile.unprefix")
+ "include Makefile.unprefix
+depend: $(STDLIB_MLIS) $(STDLIB_DEPS)"))
+ ;; Generate required tools for `alldepend'
+ (make "-C" "byterun" "depend")
+ (make "-C" "byterun" "all")
+ (copy-file "byterun/ocamlrun" "boot/ocamlrun")
+ (make "ocamlyacc")
+ (copy-file "yacc/ocamlyacc" "boot/ocamlyacc")
+ (make "-C" "stdlib" "sys.ml")
+ (make "-C" "stdlib" "CAMLDEP=../boot/ocamlc -depend" "depend")
+ ;; Build and copy files later used by `tools'
+ (make "-C" "stdlib" "COMPILER="
+ "CAMLC=../boot/ocamlc -use-prims ../byterun/primitives"
+ "all")
+ (for-each
+ (lambda (file)
+ (copy-file file (string-append "boot/" (basename file))))
+ (cons* "stdlib/stdlib.cma" "stdlib/std_exit.cmo" "stdlib/camlheader"
+ (find-files "stdlib" ".*.cmi$")))
+ (symlink "../byterun/libcamlrun.a" "boot/libcamlrun.a")
+ ;; required for ocamldoc/stdlib_non_prefixed
+ (make "parsing/parser.mli")
+ ;; required for dependencies
+ (make "-C" "tools"
+ "CAMLC=../boot/ocamlc -nostdlib -I ../boot -use-prims ../byterun/primitives -I .."
+ "make_opcodes" "cvt_emit")
+ ;; generate all remaining .depend files
+ (make "alldepend"
+ (string-append "ocamllex=" (getcwd) "/boot/ocamlrun "
+ (getcwd) "/boot/ocamllex")
+ (string-append "CAMLDEP=" (getcwd) "/boot/ocamlc -depend")
+ (string-append "OCAMLDEP=" (getcwd) "/boot/ocamlc -depend")
+ (string-append "ocamldep=" (getcwd) "/boot/ocamlc -depend"))
+ ;; Build ocamllex
+ (make "CAMLC=boot/ocamlc -nostdlib -I boot -use-prims byterun/primitives"
+ "ocamlc")
+ ;; Build ocamlc
+ (make "-C" "lex"
+ "CAMLC=../boot/ocamlc -strict-sequence -nostdlib -I ../boot -use-prims ../byterun/primitives"
+ "all")))
+ (replace 'install
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (bin (string-append out "/bin"))
+ (depends (string-append out "/share/depends")))
+ (mkdir-p bin)
+ (mkdir-p depends)
+ (install-file "ocamlc" bin)
+ (install-file "lex/ocamllex" bin)
+ (for-each
+ (lambda (file)
+ (let ((dir (string-append depends "/" (dirname file))))
+ (mkdir-p dir)
+ (install-file file dir)))
+ (find-files "." "^\\.depend$"))))))))
+ (native-inputs
+ `(("camlboot" ,camlboot)
+ ("perl" ,perl)
+ ("pkg-config" ,pkg-config)))))
+
+(define-public ocaml-4.07
+ (package
+ (inherit ocaml-4.07-boot)
(arguments
(substitute-keyword-arguments (package-arguments ocaml-4.09)
((#:phases phases)
`(modify-phases ,phases
+ (add-before 'configure 'copy-bootstrap
+ (lambda* (#:key inputs #:allow-other-keys)
+ (let ((ocaml (assoc-ref inputs "ocaml")))
+ (copy-file (string-append ocaml "/bin/ocamllex") "boot/ocamllex")
+ (copy-file (string-append ocaml "/bin/ocamlc") "boot/ocamlc")
+ (chmod "boot/ocamllex" #o755)
+ (chmod "boot/ocamlc" #o755)
+ (let ((rootdir (getcwd)))
+ (with-directory-excursion (string-append ocaml "/share/depends")
+ (for-each
+ (lambda (file)
+ (copy-file file (string-append rootdir "/" file)))
+ (find-files "." ".")))))))
(replace 'configure
(lambda* (#:key outputs #:allow-other-keys)
(let* ((out (assoc-ref outputs "out"))
;; --prefix=<PREFIX> syntax (with equals sign).
(invoke "./configure"
"--prefix" out
- "--mandir" mandir))))))))))
+ "--mandir" mandir))))))))
+ (native-inputs
+ `(("ocaml" ,ocaml-4.07-boot)
+ ("perl" ,perl)
+ ("pkg-config" ,pkg-config)))))
-(define-public ocaml ocaml-4.09)
+(define-public ocaml ocaml-4.11)
(define-public ocamlbuild
(package
for building OCaml library and programs.")
(license license:lgpl2.1+)))
+(define-public camlidl
+ (package
+ (name "camlidl")
+ (version "1.09")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/xavierleroy/camlidl")
+ (commit "camlidl109")))
+ (sha256
+ (base32 "0zrkaq7fk23b2b9vg6jwdjx7l0hdqp4synbbrw1zcg8gjf6n3c80"))
+ (file-name (git-file-name name version))))
+ (build-system gnu-build-system)
+ (arguments
+ `(#:tests? #f ;; No test suite
+ #:make-flags
+ (list
+ (string-append
+ "BINDIR=" (assoc-ref %outputs "out") "/bin")
+ (string-append
+ "OCAMLLIB=" (assoc-ref %outputs "out") "/lib/ocaml/site-lib/camlidl"))
+ #:phases
+ (modify-phases %standard-phases
+ (delete 'configure)
+ (replace 'build
+ (lambda _
+ (copy-file "config/Makefile.unix" "config/Makefile")
+ ;; Note: do not pass '-jN' as this appears to not be
+ ;; parallel-safe (race condition related to libcamlidl.a).
+ (invoke "make" "all")
+ #t))
+ (add-before 'install 'create-target-directories
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let ((out (string-append (assoc-ref outputs "out"))))
+ (mkdir-p
+ (string-append out "/bin"))
+ (mkdir-p
+ (string-append out "/lib/ocaml/site-lib/camlidl/stublibs"))
+ (mkdir-p
+ (string-append out "/lib/ocaml/site-lib/camlidl/caml")))
+ #t))
+ (add-after 'install 'install-meta
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let ((out (assoc-ref outputs "out")))
+ (with-output-to-file
+ (string-append out "/lib/ocaml/site-lib/camlidl/META")
+ (lambda _
+ (display
+ (string-append
+ "description = \"Stub code generator for OCaml/C interface\"
+version = \"" ,version "\"
+directory = \"^\"
+archive(byte) = \"com.cma\"
+archive(native) = \"com.cmxa\"")))))
+ #t)))))
+ (native-inputs
+ `(("ocaml" ,ocaml)))
+ (home-page "https://github.com/xavierleroy/camlidl")
+ (synopsis "Stub code generator for OCaml/C interface")
+ (description
+ "Camlidl is a stub code generator for Objective Caml. It generates stub
+code for interfacing Caml with C from an IDL description of the C functions.")
+ (license license:lgpl2.1)))
+
(define-public ocaml-extlib
(package
(name "ocaml-extlib")
#:phases
(modify-phases %standard-phases
(delete 'configure))))
- (home-page "http://www.mancoosi.org/cudf/")
+ (home-page "https://www.mancoosi.org/cudf/")
(synopsis "CUDF library (part of the Mancoosi tools)")
(description "CUDF (for Common Upgradeability Description Format) is a
format for describing upgrade scenarios in package-based Free and Open Source
("ocaml-extlib" ,ocaml-extlib)
("ocamlbuild" ,ocamlbuild)
("ocaml-cppo" ,ocaml-cppo)))
- (home-page "http://www.mancoosi.org/software/")
+ (home-page "https://www.mancoosi.org/software/")
(synopsis "Package distribution management framework")
(description "Dose3 is a framework made of several OCaml libraries for
managing distribution packages and their dependencies. Though not tied to
;; with static-linking exception
(license license:lgpl2.1+)))
+(define-public ocaml-down
+ (package
+ (name "ocaml-down")
+ (version "0.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://erratique.ch/software/down/releases/down-"
+ version ".tbz"))
+ (sha256
+ (base32
+ "1nz2f5j17frgr2vrslcz9klmi6w9sm2vqwwwpi33ngcm3rgmsrlg"))))
+ (build-system ocaml-build-system)
+ (arguments
+ `(#:tests? #f ;no tests
+ #:phases
+ (modify-phases %standard-phases
+ (delete 'configure))
+ #:build-flags
+ (list "build" "--lib-dir"
+ (string-append (assoc-ref %outputs "out") "/lib/ocaml/site-lib"))))
+ (native-inputs
+ `(("ocaml-findlib" ,ocaml-findlib)
+ ("ocamlbuild" ,ocamlbuild)
+ ("ocaml-topkg" ,ocaml-topkg)
+ ("opam" ,opam)))
+ (home-page "https://erratique.ch/software/down")
+ (synopsis "OCaml toplevel (REPL) upgrade")
+ (description "Down is an unintrusive user experience upgrade for the
+@command{ocaml} toplevel (REPL).
+
+Simply load the zero dependency @code{down} library in the @command{ocaml}
+toplevel and you get line edition, history, session support and identifier
+completion and documentation with @command{ocp-index}.
+
+Add this to your @file{~/.ocamlinit}:
+
+@example
+#use \"down.top\"
+@end example
+
+You may also need to add this to your @file{~/.ocamlinit} and declare
+the environment variable @code{OCAML_TOPLEVEL_PATH}:
+
+@example
+let () =
+ try Topdirs.dir_directory (Sys.getenv \"OCAML_TOPLEVEL_PATH\")
+ with Not_found -> ()
+@end example
+
+OR
+
+@example
+let () = String.split_on_char ':' (Sys.getenv \"OCAMLPATH\")
+ |> List.filter (fun x -> Filename.check_suffix x \"/site-lib\")
+ |> List.map (fun x -> x ^ \"/toplevel\")
+ (* remove the line below if you don't want to see the text
+ every time you start the toplevel *)
+ |> List.map (fun x -> Printf.printf \"adding directory %s\\n\" x; x)
+ |> List.iter Topdirs.dir_directory;;
+@end example")
+ (license license:isc)))
+
(define-public ocaml-opam-file-format
(package
(name "ocaml-opam-file-format")
(define-public opam
(package
(name "opam")
- (version "2.0.7")
+ (version "2.0.8")
(source (origin
(method git-fetch)
(uri (git-reference
(file-name (git-file-name name version))
(sha256
(base32
- "1p719ccn9wnzk6impsnwr809yh507h8f37dx9nn64b1hsyb5z8ax"))))
+ "1z0ls6xxa4ws5xw0am5gxmh5apnmyhgkcphrncp53w34j8sfydsj"))))
(build-system ocaml-build-system)
(arguments
`(#:configure-flags
(license license:lgpl2.1+))); with linking exception
(define-public emacs-tuareg
- (package
- (name "emacs-tuareg")
- (version "2.2.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/ocaml/tuareg")
- (commit version)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "06zxnn85fk5087iq0zxc5l5n9fz8r0367wylmynbfhc9711vccy6"))))
- (build-system gnu-build-system)
- (native-inputs `(("emacs" ,emacs-minimal)
- ("opam" ,opam)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'make-git-checkout-writable
- (lambda _
- (for-each make-file-writable (find-files "."))
- #t))
- (delete 'configure)
- (add-before 'install 'fix-install-path
- (lambda* (#:key outputs #:allow-other-keys)
- (substitute* "Makefile"
- (("/emacs/site-lisp")
- (string-append (assoc-ref %outputs "out")
- "/share/emacs/site-lisp/")))
- #t))
- (add-after 'install 'post-install
- (lambda* (#:key outputs #:allow-other-keys)
- (symlink "tuareg.el"
- (string-append (assoc-ref outputs "out")
- "/share/emacs/site-lisp/"
- "tuareg-autoloads.el"))
- #t)))))
- (home-page "https://github.com/ocaml/tuareg")
- (synopsis "OCaml programming mode, REPL, debugger for Emacs")
- (description "Tuareg helps editing OCaml code, to highlight important
+ ;; Last upstream release on Sept., 14th, 2018, since then "Package cl
+ ;; deprecated" or 'lexical-binding' and others had been fixed.
+ (let ((commit "ccde45bbc292123ec20617f1af7f7e19f7481545")
+ (revision "0"))
+ (package
+ (name "emacs-tuareg")
+ (version (git-version "2.2.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ocaml/tuareg")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1yxv4bnqarilnpg5j7wywall8170hwvm0q4xx06yqjgcn8pq1lac"))))
+ (build-system gnu-build-system)
+ (native-inputs
+ `(("emacs" ,emacs-minimal)
+ ("opam" ,opam)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'make-git-checkout-writable
+ (lambda _
+ (for-each make-file-writable (find-files "."))
+ #t))
+ (delete 'configure)
+ (add-before 'install 'fix-install-path
+ (lambda* (#:key outputs #:allow-other-keys)
+ (substitute* "Makefile"
+ (("/emacs/site-lisp")
+ (string-append (assoc-ref %outputs "out")
+ "/share/emacs/site-lisp/")))
+ #t))
+ (add-after 'install 'post-install
+ (lambda* (#:key outputs #:allow-other-keys)
+ (symlink "tuareg.el"
+ (string-append (assoc-ref outputs "out")
+ "/share/emacs/site-lisp/"
+ "tuareg-autoloads.el"))
+ #t)))))
+ (home-page "https://github.com/ocaml/tuareg")
+ (synopsis "OCaml programming mode, REPL, debugger for Emacs")
+ (description "Tuareg helps editing OCaml code, to highlight important
parts of the code, to run an OCaml REPL, and to run the OCaml debugger within
Emacs.")
- (license license:gpl2+)))
+ (license license:gpl2+))))
(define-public ocaml-menhir
(package
(name "ocaml-menhir")
- ;; More recent versions can be built after we have dune >= 2.0
- (version "20190626")
+ (version "20200211")
(source
(origin
(method git-fetch)
(commit version)))
(file-name (git-file-name name version))
(sha256
- (base32 "0v8av4pw6rykzb7wx54xhbsx0jhh8xyb4x0k4yrxi0w5ylkck6mb"))))
- (build-system ocaml-build-system)
+ (base32 "019izf51kdc7pzkw68zg8a2alc8lxw1gwdp7in970mr90n16b5zj"))))
+ (build-system dune-build-system)
(inputs
`(("ocaml" ,ocaml)))
- (native-inputs
- `(("ocamlbuild" ,ocamlbuild)))
(arguments
- `(#:make-flags `("USE_OCAMLFIND=true"
- ,(string-append "PREFIX=" (assoc-ref %outputs "out")))
- #:tests? #f ; No check target
- #:phases
- (modify-phases %standard-phases
- (delete 'configure))))
+ `(#:tests? #f)) ; No check target
(home-page "http://gallium.inria.fr/~fpottier/menhir/")
(synopsis "Parser generator")
(description "Menhir is a parser generator. It turns high-level grammar
`(("m4" ,m4)
("ocaml" ,ocaml-4.07)))))
+(define-public ocaml4.09-findlib
+ (package
+ (inherit ocaml-findlib)
+ (name "ocaml4.09-findlib")
+ (native-inputs
+ `(("m4" ,m4)
+ ("ocaml" ,ocaml-4.09)))))
+
+(define-public ocaml-ounit2
+ (package
+ (name "ocaml-ounit2")
+ (version "2.2.4")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gildor478/ounit.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0gxjw1bhmjcjzri6x6psqrkbbyq678b69bqfl9i1zswp7cj2lryg"))))
+ (build-system dune-build-system)
+ (inputs
+ ;; XXX Should libev be a propagated-input of ocaml-lwt?
+ `(("libev" ,libev)))
+ (propagated-inputs
+ `(("lwt" ,ocaml-lwt)
+ ("ocaml-stdlib-shims" ,ocaml-stdlib-shims)))
+ (home-page "https://github.com/gildor478/ounit")
+ (synopsis "Unit testing framework for OCaml")
+ (description "OUnit2 is a unit testing framework for OCaml. It is similar
+to JUnit and other XUnit testing frameworks.")
+ (license license:expat)))
+
;; note that some tests may hang for no obvious reason.
(define-public ocaml-ounit
(package
following a very simple s-expression syntax.")
(license license:expat)))
+(define ocaml4.09-dune-bootstrap
+ (package-with-ocaml4.09 dune-bootstrap))
+
(define-public dune-configurator
(package
(inherit dune-bootstrap)
#:tests? #f))
(propagated-inputs
`(("ocaml-csexp" ,ocaml-csexp)))
- (synopsis "")
- (description "")))
+ (properties `((ocaml4.09-variant . ,(delay ocaml4.09-dune-configurator))))
+ (synopsis "Dune helper library for gathering system configuration")
+ (description "Dune-configurator is a small library that helps writing
+OCaml scripts that test features available on the system, in order to generate
+config.h files for instance. Among other things, dune-configurator allows one to:
+
+@itemize
+@item test if a C program compiles
+@item query pkg-config
+@item import #define from OCaml header files
+@item generate config.h file
+@end itemize")))
+
+(define-public ocaml4.09-dune-configurator
+ (package
+ (inherit dune-configurator)
+ (name "ocaml4.09-dune-configurator")
+ (arguments
+ `(#:package "dune-configurator"
+ #:tests? #f
+ #:dune ,ocaml4.09-dune-bootstrap
+ #:ocaml ,ocaml-4.09
+ #:findlib ,ocaml4.09-findlib))
+ (propagated-inputs
+ `(("ocaml-csexp" ,ocaml4.09-csexp)))))
(define-public dune
(package
(inherit dune-bootstrap)
(propagated-inputs
`(("dune-configurator" ,dune-configurator)))
- (properties `((ocaml4.07-variant . ,(delay ocaml4.07-dune))))))
+ (properties `((ocaml4.07-variant . ,(delay ocaml4.07-dune))
+ (ocaml4.09-variant . ,(delay ocaml4.09-dune))))))
+
+(define-public ocaml4.09-dune
+ (package
+ (inherit ocaml4.09-dune-bootstrap)
+ (propagated-inputs
+ `(("dune-configurator" ,dune-configurator)))))
(define-public ocaml4.07-dune
(package
#t)))))
(propagated-inputs
`(("ocaml-result" ,ocaml-result)))
+ (properties `((ocaml4.09-variant . ,(delay ocaml4.09-csexp))))
(home-page "https://github.com/ocaml-dune/csexp")
(synopsis "Parsing and printing of S-expressions in Canonical form")
(description "This library provides minimal support for Canonical
module of this library is parameterised by the type of S-expressions.")
(license license:expat)))
+(define-public ocaml4.09-csexp
+ (package
+ (inherit ocaml-csexp)
+ (name "ocaml4.09-csexp")
+ (arguments
+ `(#:ocaml ,ocaml-4.09
+ #:findlib ,ocaml4.09-findlib
+ ,@(substitute-keyword-arguments (package-arguments ocaml-csexp)
+ ((#:dune _) ocaml4.09-dune-bootstrap))))
+ (propagated-inputs
+ `(("ocaml-result" ,ocaml4.09-result)))))
+
(define-public ocaml-migrate-parsetree
(package
(name "ocaml-migrate-parsetree")
"07lnj4yzwvwyh5fhpp1dxrys4ddih15jhgqjn59pmgxinbnddi66"))))
(build-system dune-build-system)
(arguments
- `(#:test-target "."))
+ `(#:test-target "."
+ #:package "ppx_tools_versioned"))
(propagated-inputs
`(("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)))
(properties `((upstream-name . "ppx_tools_versioned")))
(arguments
`(#:test-target "."
#:dune ,dune-bootstrap))
+ (properties `((ocaml4.09-variant . ,(delay ocaml4.09-result))))
(home-page "https://github.com/janestreet/result")
(synopsis "Compatibility Result module")
(description "Uses the new result type defined in OCaml >= 4.03 while
staying compatible with older version of OCaml should use the Result module
defined in this library.")
(license license:bsd-3)))
+
+(define-public ocaml4.09-result
+ (package
+ (inherit ocaml-result)
+ (name "ocaml4.09-result")
+ (arguments
+ `(#:test-target "."
+ #:dune ,ocaml4.09-dune-bootstrap
+ #:ocaml ,ocaml-4.09
+ #:findlib ,ocaml4.09-findlib))))
(define-public ocaml-topkg
(package
#:phases
(modify-phases %standard-phases
(delete 'configure))))
- (home-page "http://erratique.ch/software/topkg")
+ (home-page "https://erratique.ch/software/topkg")
(synopsis "Transitory OCaml software packager")
(description "Topkg is a packager for distributing OCaml software. It
provides an API to describe the files a package installs in a given build
#:phases
(modify-phases %standard-phases
(delete 'configure))))
- (home-page "http://erratique.ch/software/rresult")
+ (home-page "https://erratique.ch/software/rresult")
(synopsis "Result value combinators for OCaml")
(description "Handle computation results and errors in an explicit and
declarative manner, without resorting to exceptions. It defines combinators
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(native-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-stdio" ,ocaml4.07-stdio)
("pkg-config" ,pkg-config)))
(inputs
#:phases
(modify-phases %standard-phases
(delete 'configure))))
- (home-page "http://erratique.ch/software/mtime")
+ (home-page "https://erratique.ch/software/mtime")
(synopsis "Monotonic wall-clock time for OCaml")
(description "Access monotonic wall-clock time. It measures time
spans without being subject to operating system calendar time adjustments.")
(("Sys.readdir dir")
"let a = Sys.readdir dir in Array.sort String.compare a; a"))
#t)))))
- (home-page "http://erratique.ch/software/cmdliner")
+ (home-page "https://erratique.ch/software/cmdliner")
(synopsis "Declarative definition of command line interfaces for OCaml")
(description "Cmdliner is a module for the declarative definition of command
line interfaces. It provides a simple and compositional mechanism to convert
#:phases
(modify-phases %standard-phases
(delete 'configure))))
- (home-page "http://erratique.ch/software/fmt")
+ (home-page "https://erratique.ch/software/fmt")
(synopsis "OCaml Format pretty-printer combinators")
(description "Fmt exposes combinators to devise Format pretty-printing
functions.")
#:phases
(modify-phases %standard-phases
(delete 'configure))))
- (home-page "http://erratique.ch/software/astring")
+ (home-page "https://erratique.ch/software/astring")
(synopsis "Alternative String module for OCaml")
(description "Astring exposes an alternative String module for OCaml. This
module balances minimality and expressiveness for basic, index-free, string
#:phases
(modify-phases %standard-phases
(delete 'configure))))
- (home-page "http://erratique.ch/software/react")
+ (home-page "https://erratique.ch/software/react")
(synopsis "Declarative events and signals for OCaml")
(description "React is an OCaml module for functional reactive programming
(FRP). It provides support to program with time varying values: declarative
("result" ,ocaml-result)
("cmdliner" ,ocaml-cmdliner)
("topkg" ,ocaml-topkg)))
- (home-page "http://erratique.ch/software/logs")
+ (home-page "https://erratique.ch/software/logs")
(synopsis "Logging infrastructure for OCaml")
(description "Logs provides a logging infrastructure for OCaml. Logging is
performed on sources whose reporting level can be set independently. Log
(propagated-inputs
`(("topkg" ,ocaml-topkg)
("astring" ,ocaml-astring)))
- (home-page "http://erratique.ch/software/fpath")
+ (home-page "https://erratique.ch/software/fpath")
(synopsis "File system paths for OCaml")
(description "Fpath is an OCaml module for handling file system paths with
POSIX or Windows conventions. Fpath processes paths without accessing the
("fpath" ,ocaml-fpath)
("logs" ,ocaml-logs)
("rresult" ,ocaml-rresult)))
- (home-page "http://erratique.ch/software/bos")
+ (home-page "https://erratique.ch/software/bos")
(synopsis "Basic OS interaction for OCaml")
(description "Bos provides support for basic and robust interaction with
the operating system in OCaml. It has functions to access the process
`(("ocamlbuild" ,ocamlbuild)
("ocaml-topkg" ,ocaml-topkg)
("opam" ,opam)))
- (home-page "http://erratique.ch/software/xmlm")
+ (home-page "https://erratique.ch/software/xmlm")
(synopsis "Streaming XML codec for OCaml")
(description "Xmlm is a streaming codec to decode and encode the XML data
format. It can process XML documents without a complete in-memory
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-odoc" ,ocaml4.07-odoc)))
+ `(("ocaml-odoc" ,(package-with-ocaml4.07 ocaml4.07-odoc))))
(native-inputs
`(("ocaml-qtest" ,(package-with-ocaml4.07 ocaml-qtest))
("ocaml-qcheck" ,(package-with-ocaml4.07 ocaml-qcheck))))
(propagated-inputs
`(("uchar" ,ocaml-uchar)
("cmdliner" ,ocaml-cmdliner)))
- (home-page "http://erratique.ch/software/uutf")
+ (home-page "https://erratique.ch/software/uutf")
(synopsis "Non-blocking streaming Unicode codec for OCaml")
(description "Uutf is a non-blocking streaming codec to decode and encode
the UTF-8, UTF-16, UTF-16LE and UTF-16BE encoding schemes. It can efficiently
(propagated-inputs
`(("uutf" ,ocaml-uutf)
("cmdliner" ,ocaml-cmdliner)))
- (home-page "http://erratique.ch/software/jsonm")
+ (home-page "https://erratique.ch/software/jsonm")
(synopsis "Non-blocking streaming JSON codec for OCaml")
(description "Jsonm is a non-blocking streaming codec to decode and encode
the JSON data format. It can process JSON text without blocking on IO and
without a complete in-memory representation of the data.")
(license license:isc)))
+
+(define-public ocaml-ocp-indent
+ (package
+ (name "ocaml-ocp-indent")
+ (version "1.8.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/OCamlPro/ocp-indent")
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1dvcl108ir9nqkk4mjm9xhhj4p9dx9bmg8bnms54fizs1x3x8ar3"))))
+ (build-system dune-build-system)
+ (arguments
+ `(#:test-target "tests"
+ #:build-flags (list "--profile=release")))
+ (propagated-inputs
+ `(("ocaml-cmdliner" ,ocaml-cmdliner)))
+ (home-page "https://www.typerex.org/ocp-indent.html")
+ (synopsis "Tool to indent OCaml programs")
+ (description
+ "Ocp-indent is based on an approximate, tolerant OCaml parser
+and a simple stack machine. Presets and configuration options are available,
+with the possibility to set them project-wide. It supports the most common
+syntax extensions, and it is extensible for others.
+
+This package includes:
+
+@itemize
+@item An indentor program, callable from the command-line or from within editors,
+@item Bindings for popular editors,
+@item A library that can be directly used by editor writers, or just for
+ fault-tolerant and approximate parsing.
+@end itemize")
+ (license license:lgpl2.1)))
+
+(define-public ocaml-ocp-index
+ (package
+ (name "ocaml-ocp-index")
+ (version "1.2.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/OCamlPro/ocp-index")
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "08r7mxdnxmhff37fw4hmrpjgckgi5kaiiiirwp4rmdl594z0h9c8"))))
+ (build-system dune-build-system)
+ (arguments
+ `(#:package "ocp-index"))
+ (propagated-inputs
+ `(("ocaml-ocp-indent" ,ocaml-ocp-indent)
+ ("ocaml-re" ,ocaml-re)
+ ("ocaml-cmdliner" ,ocaml-cmdliner)))
+ (native-inputs
+ `(("ocaml-cppo" ,ocaml-cppo)))
+ (home-page "https://www.typerex.org/ocp-index.html")
+ (synopsis "Lightweight completion and documentation browsing for OCaml libraries")
+ (description "This package includes only the @code{ocp-index} library
+and command-line tool.")
+ ;; All files in libs/ are GNU lgpl2.1
+ ;; For static linking, clause 6 of LGPL is lifted
+ ;; All other files under GNU gpl3
+ (license (list license:gpl3+
+ license:lgpl2.1+))))
(define-public ocaml-ocurl
(package
(base32 "1f0fghvlbfryf5h3j4as7vcqrgfjb4c8abl5y0y5h069vs4kp5ii"))))
(build-system ocaml-build-system)
(arguments
- `(#:phases
+ `(#:tests? #f; no tests
+ #:phases
(modify-phases %standard-phases
- (add-after 'unpack 'disable-safe-string
- ;; Work around ‘Error: This expression has type string but an
- ;; expression was expected of type bytes’ since OCaml 4.06.
+ (delete 'configure)
+ (replace 'build
+ ;; This package uses pre-generated setup.ml by oasis, but is
+ ;; a dependency of oasis. the pre-generated setup.ml is broken
+ ;; with recent versions of OCaml, so we perform a bootstrap instead.
(lambda _
- (setenv "OCAMLPARAM" "safe-string=0,_")
+ (substitute* "src/OCamlifyConfig.ml.ab"
+ (("$pkg_version") ,version))
+ (rename-file "src/OCamlifyConfig.ml.ab" "src/OCamlifyConfig.ml")
+ (with-directory-excursion "src"
+ (invoke "ocamlc" "OCamlifyConfig.ml" "ocamlify.ml" "-o"
+ "ocamlify"))
#t))
- (delete 'check) ; tests are run during the build
- (replace 'configure
+ (replace 'install
(lambda* (#:key outputs #:allow-other-keys)
- (invoke "ocaml" "setup.ml" "-configure" "--prefix"
- (assoc-ref outputs "out")))))))
- (native-inputs
- `(("ocamlbuild" ,ocamlbuild)))
+ (let ((bin (string-append (assoc-ref outputs "out") "/bin")))
+ (mkdir-p bin)
+ (install-file "src/ocamlify" bin)
+ #t))))))
(home-page "https://forge.ocamlcore.org/projects/ocamlify")
(synopsis "Include files in OCaml code")
(description "OCamlify creates OCaml source code by including
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(native-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("pcre:bin" ,pcre "bin")))
(propagated-inputs `(("pcre" ,pcre)))
(home-page "https://mmottl.github.io/pcre-ocaml")
build system and allows external tools to analyse your project easily.")
(license license:lgpl2.1+))) ; with ocaml static compilation exception
-(define-public ocaml-js-build-tools
- (package
- (name "ocaml-js-build-tools")
- (version "113.33.06")
- (source (janestreet-origin "js-build-tools" version
- "0r8z4fz8iy5y6hkdlkpwf6rk4qigcr3dzyv35585xgg2ahf12zy6"))
- (native-inputs
- `(("oasis" ,ocaml-oasis)
- ("ocamlbuild" ,ocamlbuild)
- ("opam" ,opam)))
- (build-system ocaml-build-system)
- (arguments janestreet-arguments)
- (home-page "https://github.com/janestreet/js-build-tools")
- (synopsis "Collection of tools to help building Jane Street Packages")
- (description "This package contains tools to help building Jane Street
-packages, but can be used for other purposes. It contains:
-@enumerate
-@item an @command{oasis2opam-install} tool to produce a @file{.install} file
-from the oasis build log
-@item a @code{js_build_tools} ocamlbuild plugin with various goodies.
-@end enumerate")
- (license license:asl2.0)))
-
(define-public ocaml-cppo
(package
(name "ocaml-cppo")
(propagated-inputs
`(("ocaml-hex" ,(package-with-ocaml4.07 ocaml-hex))
("ocaml-jsonm" ,(package-with-ocaml4.07 ocaml-jsonm))
- ("ocaml-sexplib" ,ocaml4.07-sexplib)))
+ ("ocaml-sexplib" ,(package-with-ocaml4.07 ocaml-sexplib))))
(home-page "https://github.com/mirage/ezjsonm/")
(synopsis "Read and write JSON data")
(description "Ezjsonm provides more convenient (but far less flexible) input
("ocaml-ppx-sexp-conv" ,ocaml4.07-ppx-sexp-conv)))
(propagated-inputs
`(("ocaml-re" ,(package-with-ocaml4.07 ocaml-re))
- ("ocaml-sexplib0" ,ocaml4.07-sexplib0)
+ ("ocaml-sexplib0" ,(package-with-ocaml4.07 ocaml-sexplib0))
("ocaml-stringext" ,(package-with-ocaml4.07 ocaml-stringext))))
(home-page "https://github.com/mirage/ocaml-uri")
(synopsis "RFC3986 URI/URL parsing library")
(propagated-inputs
`(("cmdliner" ,ocaml-cmdliner)
("topkg" ,ocaml-topkg)))
- (home-page "http://erratique.ch/software/uuidm")
+ (home-page "https://erratique.ch/software/uuidm")
(synopsis "Universally unique identifiers for OCaml")
(description "Uuidm is an OCaml module implementing 128 bits universally
unique identifiers (UUIDs) version 3, 5 (named based with MD5, SHA-1 hashing)
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
("ocaml-compiler-libs" ,ocaml4.07-compiler-libs)
- ("ocaml-sexplib0" ,ocaml4.07-sexplib0)
+ ("ocaml-sexplib0" ,(package-with-ocaml4.07 ocaml-sexplib0))
("ocaml-stdio" ,ocaml4.07-stdio)
("ocaml-ppxlib" ,ocaml4.07-ppxlib)))
(properties `((upstream-name . "ppx_inline_test")))
(build-system dune-build-system)
(arguments
`(#:test-target "."))
- (inputs
+ (propagated-inputs
`(("ocaml-biniou" ,ocaml-biniou)
("ocaml-easy-format" ,ocaml-easy-format)))
(native-inputs
format}. @code{craml} is released as a single binary (called @code{craml}).")
(license license:isc)))
-(define-public ocaml4.07-merlin
+(define-public ocaml-dot-merlin-reader
(package
- (name "ocaml4.07-merlin")
- (version "3.2.2")
+ (name "ocaml-dot-merlin-reader")
+ (version "3.4.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ocaml/merlin")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0i2nwkdh6cfzmnsdsr8aw86vs8j1k5jkjzrs61b9384wnffdbbmj"))))
+ (build-system dune-build-system)
+ (arguments '(#:package "dot-merlin-reader"
+ #:tests? #f)) ; no tests
+ (inputs
+ `(("ocaml-yojson" ,ocaml-yojson)
+ ("ocaml-csexp" ,ocaml-csexp)
+ ("ocaml-result" ,ocaml-result)))
(home-page "https://ocaml.github.io/merlin/")
+ (synopsis "Reads config files for @code{ocaml-merlin}")
+ (description "@code{ocaml-dot-merlin-reader} is an external reader for
+@code{ocaml-merlin} configurations.")
+ (license license:expat)))
+
+(define-public ocaml-merlin
+ (package
+ (name "ocaml-merlin")
+ (version "3.4.2")
(source
(origin
(method git-fetch)
(file-name (git-file-name name version))
(sha256
(base32
- "15ssgmwdxylbwhld9p1cq8x6kadxyhll5bfyf11dddj6cldna3hb"))))
+ "0i2nwkdh6cfzmnsdsr8aw86vs8j1k5jkjzrs61b9384wnffdbbmj"))))
(build-system dune-build-system)
+ (arguments '(#:package "merlin"
+ #:test-target "tests"))
(inputs
- `(("ocaml-biniou" ,(package-with-ocaml4.07 ocaml-biniou))
- ("ocaml-yojson" ,(package-with-ocaml4.07 ocaml-yojson))
- ("ocaml-easy-format" ,(package-with-ocaml4.07 ocaml-easy-format))))
+ `(("ocaml-yojson" ,ocaml-yojson)
+ ("ocaml-csexp" ,ocaml-csexp)
+ ("ocaml-result" ,ocaml-result)))
(native-inputs
- `(("ocaml-findlib" ,ocaml-findlib)))
- (arguments
- `(#:package "merlin"
- #:tests? #f ;; Errors in tests in version 3.2.2
- #:ocaml ,ocaml-4.07
- #:findlib ,ocaml4.07-findlib
- #:dune ,ocaml4.07-dune))
+ `(("ocaml-dot-merlin-reader" ,ocaml-dot-merlin-reader) ; required for tests
+ ("ocaml-mdx" ,ocaml-mdx)
+ ("jq" ,jq)))
+ (home-page "https://ocaml.github.io/merlin/")
(synopsis "Context sensitive completion for OCaml in Vim and Emacs")
(description "Merlin is an editor service that provides modern IDE
features for OCaml. Emacs and Vim support is provided out-of-the-box.
Atom.")
(license license:expat)))
+;; ocaml-merlin 3.4.2 can not be built with old version of dune used in
+;; package-with-ocaml4.07
+(define-public ocaml4.07-merlin
+ (package-with-ocaml4.07
+ (package
+ (inherit ocaml-merlin)
+ (name "ocaml-merlin")
+ (version "3.2.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ocaml/merlin")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "15ssgmwdxylbwhld9p1cq8x6kadxyhll5bfyf11dddj6cldna3hb"))))
+ (build-system dune-build-system)
+ (inputs
+ `(("ocaml-yojson" ,ocaml-yojson)))
+ (native-inputs
+ `(("ocaml-findlib" ,ocaml-findlib)))
+ (arguments
+ `(#:package "merlin"
+ ;; Errors in tests in version 3.2.2
+ #:tests? #f)))))
+
(define-public ocaml4.07-gsl
(package
(name "ocaml4.07-gsl")
(inputs
`(("gsl" ,gsl)))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-stdio" ,ocaml4.07-stdio)))
(home-page "https://mmottl.github.io/gsl-ocaml")
(synopsis "Bindings to the GNU Scientific Library")
exclusion algorithms are typical examples of such systems.")
(license license:asl2.0)))
-(define-public ocaml4.07-sexplib0
+(define-public ocaml-sexplib0
(package
- (name "ocaml4.07-sexplib0")
- (version "0.11.0")
+ (name "ocaml-sexplib0")
+ (version "0.14.0")
(home-page "https://github.com/janestreet/sexplib0")
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url (string-append home-page ".git"))
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "07v3ggyss7xhfv14bjk1n87sr42iqwj4cgjiv2lcdfkqk49i2bmi"))))
+ (janestreet-origin "sexplib0" version
+ "0adrc0r1vvvr41dcpj8jwkzh1dfgqf0mks9xlnnskqfm3a51iavg"))
(build-system dune-build-system)
- (arguments
- `(#:tests? #f ;no tests
- #:ocaml ,ocaml-4.07
- #:findlib ,ocaml4.07-findlib
- #:dune ,ocaml4.07-dune))
+ (arguments `(#:tests? #f)) ;no tests
+ (properties `((ocaml4.07-variant . ,(delay ocaml4.07-sexplib0))))
(synopsis "Library containing the definition of S-expressions and some
base converters")
(description "Part of Jane Street's Core library The Core suite of
libraries is an industrial strength alternative to OCaml's standard library
that was developed by Jane Street, the largest industrial user of OCaml.")
-(license license:expat)))
+ (license license:expat)))
-(define-public ocaml4.07-parsexp
- (package
- (name "ocaml4.07-parsexp")
- (version "0.11.0")
+(define-public ocaml4.07-sexplib0
+ (package-with-ocaml4.07
+ (package
+ (inherit ocaml-sexplib0)
+ (name "ocaml-sexplib0")
+ (version "0.11.0")
+ (source
+ (janestreet-origin "sexplib0" version
+ "1p06p2s7p9xsjn0z9qicniv1ai54d8sj11k8j633di2mm7jzxpin"))
+ (arguments `(#:tests? #f)) ; no tests
+ (properties '()))))
+
+(define-public ocaml-parsexp
+ (package
+ (name "ocaml-parsexp")
+ (version "0.14.0")
(home-page "https://github.com/janestreet/parsexp")
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url (string-append home-page ".git"))
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1nyq23s5igd8cf3n4qxprjvhbmb6ighb3fy5mw7hxl0mdgsw5fvz"))))
+ (janestreet-origin "parsexp" version
+ "158znj19dvfdcwsgzs3rdhxpj1g4aw0d4nkfr8c05bahf0lnshlb"))
(build-system dune-build-system)
- (arguments
- `(#:ocaml ,ocaml-4.07
- #:findlib ,ocaml4.07-findlib
- #:dune ,ocaml4.07-dune))
(inputs
- `(("ocaml-sexplib0" ,ocaml4.07-sexplib0)))
+ `(("ocaml-sexplib0" ,ocaml-sexplib0)
+ ("ocaml-base" ,ocaml-base)))
+ (properties `((ocaml4.07-variant . ,(delay ocaml4.07-parsexp))))
(synopsis "S-expression parsing library")
(description
"This library provides generic parsers for parsing S-expressions from
parsexp_io.")
(license license:expat)))
-(define-public ocaml4.07-sexplib
- (package
- (name "ocaml4.07-sexplib")
- (version "0.11.0")
+(define-public ocaml4.07-parsexp
+ (package-with-ocaml4.07
+ (package
+ (inherit ocaml-parsexp)
+ (name "ocaml-parsexp")
+ (version "0.11.0")
+ (source
+ (janestreet-origin "parsexp" version
+ "11a30zkfgbi6pb4whq22k1zc8ghdp9bwxl5s5cdlmx1z8s4yxsf0"))
+ (properties '()))))
+
+(define-public ocaml-sexplib
+ (package
+ (name "ocaml-sexplib")
+ (version "0.14.0")
(home-page "https://github.com/janestreet/sexplib")
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url (string-append home-page ".git"))
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1qfl0m04rpcjvc4yw1hzh6r16jpwmap0sa9ax6zjji67dz4szpyb"))))
+ (janestreet-origin "sexplib" version
+ "12rlnc6fcrjfdn3gs2agi418sj54ighhs6dfll37zcv7mgywblm2"))
(build-system dune-build-system)
- (arguments
- `(#:ocaml ,ocaml-4.07
- #:findlib ,ocaml4.07-findlib
- #:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-num" ,(package-with-ocaml4.07 ocaml-num))
- ("ocaml-parsexp" ,ocaml4.07-parsexp)
- ("ocaml-sexplib0" ,ocaml4.07-sexplib0)))
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-num" ,ocaml-num)
+ ("ocaml-parsexp" ,ocaml-parsexp)
+ ("ocaml-sexplib0" ,ocaml-sexplib0)))
+ (properties `((ocaml4.07-variant . ,(delay ocaml4.07-sexplib))))
(synopsis
"Library for serializing OCaml values to and from S-expressions")
(description
- "This package is part of Jane Street's Core library. Sexplib contains
+ "This package is part of Jane Street's Core library. Sexplib contains
functionality for parsing and pretty-printing s-expressions.")
(license license:expat)))
-(define-public ocaml4.07-base
- (package
- (name "ocaml4.07-base")
- (version "0.11.1")
+(define-public ocaml4.07-sexplib
+ (package-with-ocaml4.07
+ (package
+ (inherit ocaml-sexplib)
+ (version "0.11.0")
+ (source
+ (janestreet-origin "sexplib" version
+ "0ksx62zsxhz8xmdrsn41n2hbc2qbyh3bxxc6946xisvgwh42h3q3"))
+ (properties '()))))
+
+(define-public ocaml-base
+ (package
+ (name "ocaml-base")
+ (version "0.14.0")
(home-page "https://github.com/janestreet/base")
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url (string-append home-page ".git"))
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0j6xb4265jr41vw4fjzak6yr8s30qrnzapnc6rl1dxy8bjai0nir"))))
+ (janestreet-origin "base" version
+ "1rkdhsgbcv0a8p29mwvpd2ldz8cjk97pixl43izm54wyin4lp778"))
(build-system dune-build-system)
(propagated-inputs
- `(("ocaml-sexplib0" ,ocaml4.07-sexplib0)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (replace 'build
- ;; make warnings non fatal (jbuilder behaviour)
- (lambda _
- (invoke "dune" "build" "@install" "--profile=release"))))
- #:ocaml ,ocaml-4.07
- #:findlib ,ocaml4.07-findlib
- #:dune ,ocaml4.07-dune))
- (synopsis
- "Full standard library replacement for OCaml")
- (description
- "Base is a complete and portable alternative to the OCaml standard
+ `(("ocaml-sexplib0" ,ocaml-sexplib0)))
+ (properties `((ocaml4.07-variant . ,(delay ocaml4.07-base))))
+ (synopsis
+ "Full standard library replacement for OCaml")
+ (description
+ "Base is a complete and portable alternative to the OCaml standard
library. It provides all standard functionalities one would expect
from a language standard library. It uses consistent conventions
across all of its module.
features such as I/O are not offered by Base. They are instead
provided by companion libraries such as
@url{https://github.com/janestreet/stdio, ocaml-stdio}.")
- (license license:expat)))
+ (license license:expat)))
+
+(define-public ocaml4.07-base
+ (package-with-ocaml4.07
+ (package
+ (inherit ocaml-base)
+ (name "ocaml-base")
+ (version "0.11.1")
+ (source
+ (origin
+ ;; version 0.11.1 is not released on ocaml.janestreet.org.
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/janestreet/base.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0j6xb4265jr41vw4fjzak6yr8s30qrnzapnc6rl1dxy8bjai0nir"))))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (replace 'build
+ ;; make warnings non fatal (jbuilder behaviour)
+ (lambda _
+ (invoke "dune" "build" "@install" "--profile=release"))))
+ #:ocaml ,ocaml-4.07
+ #:findlib ,ocaml4.07-findlib
+ #:dune ,ocaml4.07-dune))
+ (properties '()))))
(define-public ocaml4.07-compiler-libs
(package
"1facajqhvq34g2wrg368y0ajxd6lrj5b3lyzyj0jhdmraxajjcwn"))))
(build-system dune-build-system)
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
- ("ocaml-sexplib0" ,ocaml4.07-sexplib0)))
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
+ ("ocaml-sexplib0" ,(package-with-ocaml4.07 ocaml-sexplib0))))
(arguments
`(#:tests? #f ;no tests
#:ocaml ,ocaml-4.07
"0my9x7sxb329h0lzshppdaawiyfbaw6g5f41yiy7bhl071rnlvbv"))))
(build-system dune-build-system)
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-compiler-libs" ,ocaml4.07-compiler-libs)
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
("ocaml-ppx-derivers" ,(package-with-ocaml4.07 ocaml-ppx-derivers))
("ocaml-stdio" ,ocaml4.07-stdio)
("ocaml-result" ,(package-with-ocaml4.07 ocaml-result))
- ("ocaml-sexplib0" ,ocaml4.07-sexplib0)))
+ ("ocaml-sexplib0" ,(package-with-ocaml4.07 ocaml-sexplib0))))
(arguments
`(#:phases
(modify-phases %standard-phases
"06bq4m1bsm4jlx4g7wh5m99qky7xm4c2g52kaz6pv25hdn5agi2m"))))
(build-system dune-build-system)
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
("ocaml-ppxlib" ,ocaml4.07-ppxlib)))
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
("ocaml-ppxlib" ,ocaml4.07-ppxlib)))
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
("ocaml-ppxlib" ,ocaml4.07-ppxlib)))
"07zrd3qky2ppbfl55gpm90rvqa5860xgwcsvihrjmkrw6d0jirkc"))))
(build-system dune-build-system)
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-fieldslib" ,ocaml4.07-fieldslib)
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
"0pqwnqy1xp309wvdcaax4lg02yk64lq2w03mbgfvf6ps5ry4gis9"))))
(build-system dune-build-system)
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
("ocaml-ppxlib" ,ocaml4.07-ppxlib)))
"1yc0gsds5m2nv39zga8nnrca2n75rkqy5dz4xj1635ybz20hhbjd"))))
(build-system dune-build-system)
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-variantslib" ,ocaml4.07-variantslib)
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
"11b73smf3g3bpd9lg014pr4rx285nk9mnk6g6464ph51jv0sqzhj"))))
(build-system dune-build-system)
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-ppx-sexp-conv" ,ocaml4.07-ppx-sexp-conv)
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
"1rsd91gx36prj4whi76nsiz1bzpgal9nzyw3pxdz1alv4ilk2il6"))))
(build-system dune-build-system)
(inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-ppx-compare" ,ocaml4.07-ppx-compare)
("ocaml-ppx-custom-printf" ,ocaml4.07-ppx-custom-printf)
("ocaml-ppx-fields-conv" ,ocaml4.07-ppx-fields-conv)
"1p0ic6aijxlrdggpmycj12q3cy9xksbq2vq727215maz4snvlf5p"))))
(build-system dune-build-system)
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-ppx-compare" ,ocaml4.07-ppx-compare)
("ocaml-ppx-sexp-conv" ,ocaml4.07-ppx-sexp-conv)
("ocaml-migrate-parsetree"
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
("ocaml-ppxlib" ,ocaml4.07-ppxlib)))
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
("ocaml-ppxlib" ,ocaml4.07-ppxlib)))
#:ocaml ,ocaml-4.07
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
- (propagated-inputs `(("ocaml-base" ,ocaml4.07-base)))
+ (propagated-inputs `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))))
(home-page "https://github.com/janestreet/typerep")
(synopsis "Typerep is a library for runtime types")
(description "Typerep is a library for runtime types.")
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-ppx-here" ,ocaml4.07-ppx-here)
("ocaml-ppx-sexp-conv" ,ocaml4.07-ppx-sexp-conv)
("ocaml-migrate-parsetree"
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-ppx-here" ,ocaml4.07-ppx-here)
("ocaml-ppx-sexp-conv" ,ocaml4.07-ppx-sexp-conv)
("ocaml-migrate-parsetree"
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
("ocaml-ppxlib" ,ocaml4.07-ppxlib)))
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-stdio" ,ocaml4.07-stdio)
("ocaml-ppxlib" ,ocaml4.07-ppxlib)))
(properties `((upstream-name . "ppx_optcomp")))
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
("ocaml-ppxlib" ,ocaml4.07-ppxlib)))
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-ppx-here" ,ocaml4.07-ppx-here)
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-ppx-compare" ,ocaml4.07-ppx-compare)
("ocaml-ppx-here" ,ocaml4.07-ppx-here)
("ocaml-ppx-sexp-conv" ,ocaml4.07-ppx-sexp-conv)
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-ppx-assert" ,ocaml4.07-ppx-assert)
("ocaml-ppx-compare" ,ocaml4.07-ppx-compare)
("ocaml-ppx-custom-printf" ,ocaml4.07-ppx-custom-printf)
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
("ocaml-octavius" ,(package-with-ocaml4.07 ocaml-octavius))
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-typerep" ,ocaml4.07-typerep)
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-bin-prot" ,ocaml4.07-bin-prot)
("ocaml-ppx-here" ,ocaml4.07-ppx-here)
("ocaml-migrate-parsetree"
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-ppx-jane" ,ocaml4.07-ppx-jane)
("ocaml-migrate-parsetree"
,(package-with-ocaml4.07 ocaml-migrate-parsetree))))
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-stdio" ,ocaml4.07-stdio)))
(home-page "https://github.com/janestreet/configurator")
(synopsis "Helper library for gathering system configuration")
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-configurator" ,ocaml4.07-configurator)
("ocaml-core-kernel" ,ocaml4.07-core-kernel)
("ocaml-ppx-assert" ,ocaml4.07-ppx-assert)
("ocaml-ppx-jane" ,ocaml4.07-ppx-jane)
- ("ocaml-sexplib" ,ocaml4.07-sexplib)
+ ("ocaml-sexplib" ,(package-with-ocaml4.07 ocaml-sexplib))
("ocaml-spawn" ,ocaml4.07-spawn)
("ocaml-stdio" ,ocaml4.07-stdio)
("ocaml-migrate-parsetree"
#:findlib ,ocaml4.07-findlib
#:dune ,ocaml4.07-dune))
(propagated-inputs
- `(("ocaml-base" ,ocaml4.07-base)
+ `(("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-bin-prot" ,ocaml4.07-bin-prot)
("ocaml-configurator" ,ocaml4.07-configurator)
("ocaml-fieldslib" ,ocaml4.07-fieldslib)
("ocaml-ppx-jane" ,ocaml4.07-ppx-jane)
("ocaml-ppx-sexp-conv" ,ocaml4.07-ppx-sexp-conv)
("ocaml-ppx-sexp-message" ,ocaml4.07-ppx-sexp-message)
- ("ocaml-sexplib" ,ocaml4.07-sexplib)
+ ("ocaml-sexplib" ,(package-with-ocaml4.07 ocaml-sexplib))
("ocaml-splittable-random" ,ocaml4.07-splittable-random)
("ocaml-stdio" ,ocaml4.07-stdio)
("ocaml-typerep" ,ocaml4.07-typerep)
(define-public ocaml-markup
(package
(name "ocaml-markup")
- (version "0.8.2")
+ (version "1.0.0")
(home-page "https://github.com/aantron/markup.ml")
(source
(origin
(file-name (git-file-name name version))
(sha256
(base32
- "13zcrwzjmifniv3bvjbkd2ah8wwa3ld75bxh1d8hrzdvfxzh9szn"))))
+ "09hkrf9pw6hpb9j06p5bddklpnjwdjpqza3bx2179l970yl67an9"))))
(build-system dune-build-system)
(arguments
`(#:package "markup"))
("ocaml-uutf" ,ocaml-uutf)
("ocaml-lwt" ,ocaml-lwt)))
(native-inputs
- `(("ocaml-ounit" ,ocaml-ounit)
+ `(("ocaml-ounit2" ,ocaml-ounit2)
("pkg-config" ,pkg-config)))
+ (properties
+ `((ocaml4.07-variant . ,(delay (package-with-ocaml4.07 ocaml-markup0.8.0)))))
(synopsis "Error-recovering functional HTML5 and XML parsers and writers")
(description "Markup.ml provides an HTML parser and an XML parser. The
parsers are wrapped in a simple interface: they are functions that transform
stream, and convert everything to UTF-8.")
(license license:bsd-3)))
+;; ocaml-markup 1.0.0 can not be built with old version of dune used in
+;; package-with-ocaml4.07
+(define-public ocaml-markup0.8.0
+ (package
+ (inherit ocaml-markup)
+ (name "ocaml-markup")
+ (version "0.8.0")
+ (home-page "https://github.com/aantron/markup.ml")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url (string-append home-page ".git"))
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0aif4abvfmi9xc1pvw5n5rbm6rzkkpsxyvdn0lanr33rjpvkwdlm"))))
+ (properties '())))
+
(define-public ocaml-tyxml
(package
(name "ocaml-tyxml")
- (version "4.3.0")
+ (version "4.4.0")
(source
(origin
(method git-fetch)
(file-name (git-file-name name version))
(sha256
(base32
- "0wv19xipkj8l2sks1h53105ywbjwk7q93fb7b8al4a2g9wr109c0"))))
+ "1hw4phyadcfgywgh5sj87i76gp56qwxzwlcpfdwjbf6ggag9clmd"))))
(build-system dune-build-system)
(inputs
`(("ocaml-re" ,ocaml-re)
then run the Bisect_ppx report tool on the generated visitation files.")
(license license:mpl2.0)))
-(define-public ocaml4.07-odoc
+(define-public ocaml-odoc
(package
- (name "ocaml4.07-odoc")
- (version "1.4.2")
+ (name "ocaml-odoc")
+ (version "1.5.2")
(source
(origin
(method git-fetch)
(commit version)))
(file-name (git-file-name name version))
(sha256
- (base32 "0rvhx139jx6wmlfz355mja6mk03x4swq1xxvk5ky6jzhalq3cf5i"))))
+ (base32 "0fqfyz48q7ss5bc4c5phmp4s3ka3vc08b8gfk8fvyryvb4bq27jm"))))
(build-system dune-build-system)
- (arguments
- `(#:ocaml ,ocaml-4.07
- #:findlib ,ocaml4.07-findlib
- #:dune ,ocaml4.07-dune))
(inputs
- `(("ocaml-alcotest" ,(package-with-ocaml4.07 ocaml-alcotest))
- ("ocaml-markup" ,(package-with-ocaml4.07 ocaml-markup))
- ("ocaml-sexplib" ,ocaml4.07-sexplib)
- ("ocaml-re" ,(package-with-ocaml4.07 ocaml-re))
- ("ocaml-uutf" ,(package-with-ocaml4.07 ocaml-uutf))))
+ `(("ocaml-alcotest" ,ocaml-alcotest)
+ ("ocaml-markup" ,ocaml-markup)
+ ("ocaml-sexplib" ,ocaml-sexplib)
+ ("ocaml-re" ,ocaml-re)
+ ("ocaml-uutf" ,ocaml-uutf)))
(native-inputs
- `(("ocaml-astring" ,(package-with-ocaml4.07 ocaml-astring))
- ("ocaml-cmdliner" ,(package-with-ocaml4.07 ocaml-cmdliner))
- ("ocaml-cppo" ,(package-with-ocaml4.07 ocaml-cppo))
- ("ocaml-fpath" ,(package-with-ocaml4.07 ocaml-fpath))
- ("ocaml-result" ,(package-with-ocaml4.07 ocaml-result))
- ("ocaml-tyxml" ,(package-with-ocaml4.07 ocaml-tyxml))
- ("ocaml-bisect-ppx" ,(package-with-ocaml4.07 ocaml-bisect-ppx))))
+ `(("ocaml-astring" ,ocaml-astring)
+ ("ocaml-cmdliner" ,ocaml-cmdliner)
+ ("ocaml-cppo" ,ocaml-cppo)
+ ("ocaml-fpath" ,ocaml-fpath)
+ ("ocaml-result" ,ocaml-result)
+ ("ocaml-tyxml" ,ocaml-tyxml)
+ ("ocaml-bisect-ppx" ,ocaml-bisect-ppx)
+ ("tidy-html" ,tidy-html)))
+ (properties `((ocaml4.07-variant . ,(delay ocaml4.07-odoc))))
(home-page "https://github.com/ocaml/odoc")
(synopsis "OCaml documentation generator")
(description "Odoc is a documentation generator for OCaml. It reads
complexity of the OCaml module system.")
(license license:isc)))
+;; version 1.5.2 requires ocaml-markdown 1.0.0 which does not compile
+;; with old version of dune used in package-with-ocaml4.07
+(define-public ocaml4.07-odoc
+ (package-with-ocaml4.07
+ (package
+ (inherit ocaml-odoc)
+ (name "ocaml-odoc")
+ (version "1.5.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ocaml/odoc")
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0z2nisg1vb5xlk41hqw8drvj90v52wli7zvnih6a844cg6xsvvj2"))))
+ (properties '()))))
+
(define-public ocaml4.07-fftw3
(package
(name "ocaml4.07-fftw3")
(native-inputs
`(("openblas" ,openblas)
("lapack" ,lapack)
- ("ocaml-base" ,ocaml4.07-base)
+ ("ocaml-base" ,(package-with-ocaml4.07 ocaml-base))
("ocaml-stdio" ,ocaml4.07-stdio)))
(home-page "https://mmottl.github.io/lacaml/")
(synopsis
(url "https://github.com/Chris00/ocaml-cairo")
(commit version)))
(file-name (git-file-name name version))
+ (patches
+ (search-patches
+ ;; NOTE: This patch will be obsolete on the
+ ;; next tagged release. Remove it at that
+ ;; point.
+ "ocaml-cairo2-caml_ba_array-fix.patch"))
(sha256
(base32
"0wzysis9fa850s68qh8vrvqc6svgllhwra3kzll2ibv0wmdqrich"))))
and SVG file output.")
(license license:lgpl3+)))
+(define-public ocaml-version
+ (package
+ (name "ocaml-version")
+ (version "3.0.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ocurrent/ocaml-version")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "13770mp6adjjbx63zsbh6506dqxz241chw8c3y403sxpw45hnaw6"))))
+ (build-system dune-build-system)
+ (arguments `(#:tests? #f)) ; no tests
+ (home-page
+ "https://github.com/ocurrent/ocaml-version")
+ (synopsis
+ "Manipulate, parse and generate OCaml compiler version strings")
+ (description
+ "This library provides facilities to parse version numbers of the OCaml
+compiler, and enumerates the various official OCaml releases and configuration
+variants.")
+ (license license:isc)))
+
+(define-public ocaml-mdx
+ (package
+ (name "ocaml-mdx")
+ (version "1.7.0")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/realworldocaml/mdx")
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "10avyv99xkfqdq3gmq8gps770jpibbfslg97sbhgmp0dpwikz49d"))))
+ (build-system dune-build-system)
+ (inputs
+ `(("ocaml-fmt" ,ocaml-fmt)
+ ("ocaml-astring" ,ocaml-astring)
+ ("ocaml-logs" ,ocaml-logs)
+ ("ocaml-cmdliner" ,ocaml-cmdliner)
+ ("ocaml-re" ,ocaml-re)
+ ("ocaml-result" ,ocaml-result)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-odoc" ,ocaml-odoc)
+ ("ocaml-version" ,ocaml-version)))
+ (native-inputs
+ `(("ocaml-cppo" ,ocaml-cppo)
+ ("ocaml-lwt" ,ocaml-lwt)
+ ("ocaml-alcotest" ,ocaml-alcotest)))
+ (home-page
+ "https://github.com/realworldocaml/mdx")
+ (synopsis
+ "Executable code blocks inside markdown files")
+ (description
+ "@code{ocaml-mdx} allows to execute code blocks inside markdown files.
+There are (currently) two sub-commands, corresponding
+to two modes of operations: pre-processing (@code{ocaml-mdx pp})
+and tests (@code{ocaml-mdx test}]).
+
+The pre-processor mode allows to mix documentation and code,
+and to practice @dfn{literate programming} using markdown and OCaml.
+
+The test mode allows to ensure that shell scripts and OCaml fragments
+in the documentation always stays up-to-date.
+
+@code{ocaml-mdx} is released as two binaries called @code{ocaml-mdx} and
+@code{mdx} which are the same, mdx being the deprecated name, kept for now for
+compatibility.")
+ (license license:isc)))
+
(define-public lablgtk3
(package
(name "lablgtk")
- (version "3.0.beta8")
+ (version "3.1.1")
(source (origin
(method git-fetch)
(uri (git-reference
(file-name (git-file-name name version))
(sha256
(base32
- "08pgwnia240i2rw1rbgiahg673kwa7b6bvhsg3z4b47xr5sh9pvz"))))
+ "11qfc39cmwfwfpwmjh6wh98zwdv6p73bv8hqwcsss869vs1r7gmn"))))
(build-system dune-build-system)
(arguments
`(#:tests? #t
generate OCaml code from .glade files), libpanel, librsvg and quartz.")
;; Version 2 only, with linking exception.
(license license:lgpl2.0)))
+
+(define-public ocaml-reactivedata
+ ;; Future releases will use dune.
+ (package
+ (name "ocaml-reactivedata")
+ (version "0.2.2")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ocsigen/reactiveData")
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0l5z0fsckqkywjbn2nwy3s55h85yx8scc4hq9qzr9ig3hrq1mfb0"))))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (delete 'configure)
+ (add-before 'build 'fix-deprecated
+ (lambda _
+ (substitute*
+ "src/reactiveData.ml"
+ (("Pervasives.compare") "compare"))
+ #t))
+ (add-before 'install 'forget-makefile
+ ;; Ensure we use opam to install files
+ (lambda _
+ (delete-file "Makefile")
+ #t)))))
+ (build-system ocaml-build-system)
+ (properties `((upstream-name . "reactiveData")))
+ (native-inputs
+ `(("ocamlbuild" ,ocamlbuild)
+ ("opam" ,opam)))
+ (propagated-inputs
+ `(("ocaml-react" ,ocaml-react)))
+ (home-page "https://github.com/ocsigen/reactiveData")
+ (synopsis "Declarative events and signals for OCaml")
+ (description
+ "React is an OCaml module for functional reactive programming (FRP). It
+provides support to program with time varying values: declarative events and
+ signals. React doesn't define any primitive event or signal, it lets the
+client chooses the concrete timeline.")
+ (license license:lgpl2.1+)))
HCoop / jackhill / guix / guix.git / blobdiff