summaryrefslogtreecommitdiff
path: root/gnu/packages/ocaml.scm
diff options
context:
space:
mode:
Diffstat (limited to 'gnu/packages/ocaml.scm')
-rw-r--r--gnu/packages/ocaml.scm1141
1 files changed, 1063 insertions, 78 deletions
diff --git a/gnu/packages/ocaml.scm b/gnu/packages/ocaml.scm
index a32cee44dc..07fcf92aea 100644
--- a/gnu/packages/ocaml.scm
+++ b/gnu/packages/ocaml.scm
@@ -805,64 +805,21 @@ libpanel, librsvg and quartz.")
(define-public unison
(package
(name "unison")
- (version "2.48.3")
- (source
- (origin
- (method svn-fetch)
- (uri (svn-reference
- (url (string-append "https://webdav.seas.upenn.edu/svn/"
- "unison/branches/"
- (version-major+minor version)))
- (revision 535)))
- (file-name (string-append name "-" version "-checkout"))
- (sha256
- (base32
- "0486s53wyayicj9f2raj2dvwvk4xyzar219rccc1iczdwixm4x05"))
- (modules '((guix build utils)
- (ice-9 rdelim)
- (ice-9 regex)
- (srfi srfi-1)))
- (snippet
- `(begin
- ;; The svn revision in the release tarball appears to be
- ;; artificially manipulated in order to set the desired point
- ;; version number. Because the point version is calculated during
- ;; the build, we can offset pointVersionOrigin by the desired
- ;; point version and write that into "Rev: %d". We do this rather
- ;; than hardcoding the necessary revision number, for
- ;; maintainability.
- (with-atomic-file-replacement "src/mkProjectInfo.ml"
- (lambda (in out)
- (let ((pt-ver (string->number (third (string-split ,version #\.))))
- (pt-rx (make-regexp "^let pointVersionOrigin = ([0-9]+)"))
- (rev-rx (make-regexp "Rev: [0-9]+")))
- (let loop ((pt-origin #f))
- (let ((line (read-line in 'concat)))
- (cond
- ((regexp-exec pt-rx line)
- => (lambda (m)
- (display line out)
- (loop (string->number (match:substring m 1)))))
- ((regexp-exec rev-rx line)
- => (lambda (m)
- (format out "~aRev: ~d~a"
- (match:prefix m)
- (+ pt-origin pt-ver)
- (match:suffix m))
- (dump-port in out))) ;done
- (else
- (display line out)
- (loop pt-origin))))))))
- ;; Without the '-fix' argument, the html file produced does not
- ;; have functioning internal hyperlinks.
- (substitute* "doc/Makefile"
- (("hevea unison") "hevea -fix unison"))
- #t))))
+ (version "2.51.2")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/bcpierce00/unison.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1bykiyc0dc5pkw8x370qkg2kygq9pq7yqzsgczd3y13b6ivm4sdq"))))
(build-system gnu-build-system)
(outputs '("out"
"doc")) ; 1.9 MiB of documentation
(native-inputs
- `(("ocaml" ,ocaml-4.02)
+ `(("ocaml" ,ocaml)
;; For documentation
("ghostscript" ,ghostscript)
("texlive" ,texlive-tiny)
@@ -1391,14 +1348,14 @@ coverage information.")
(define-public dune
(package
(name "dune")
- (version "1.2.1")
+ (version "1.6.3")
(source (origin
(method url-fetch)
(uri (string-append "https://github.com/ocaml/dune/releases/"
"download/" version "/dune-" version ".tbz"))
(sha256
(base32
- "00c5dbm4hkdapc2i7pg07b2lj8sv6ly38qr7zid58cdmbmzq21z9"))))
+ "0dmf0wbfmgdy5plz1bjiisc2hjgblvxsnrqjmw2c8y45v1h23mdz"))))
(build-system ocaml-build-system)
(arguments
`(#:tests? #f; require odoc
@@ -1419,24 +1376,24 @@ following a very simple s-expression syntax.")
(define-public ocaml-migrate-parsetree
(package
(name "ocaml-migrate-parsetree")
- (version "1.1.0")
- (source (origin
- (method url-fetch)
- (uri (string-append "https://github.com/ocaml-ppx/"
- "ocaml-migrate-parsetree/releases/download/v"
- version "/ocaml-migrate-parsetree-"
- version ".tbz"))
- (sha256
- (base32
- "01zjp1q4hryqaxv4apkjd868fycz2kf887r6lkb6x2a545h1lh7f"))))
+ (version "1.2.0")
+ (home-page "https://github.com/ocaml-ppx/ocaml-migrate-parsetree")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url (string-append home-page ".git"))
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "16kas19iwm4afijv3yxd250s08absabmdcb4yj57wc8r4fmzv5dm"))))
(build-system dune-build-system)
(arguments
- `(#:tests? #f
- #:jbuild? #t))
+ `(#:tests? #f))
(propagated-inputs
- `(("ocamlbuild" ,ocamlbuild)
+ `(("ocaml-ppx-derivers" ,ocaml-ppx-derivers)
+ ("ocamlbuild" ,ocamlbuild)
("ocaml-result" ,ocaml-result)))
- (home-page "https://github.com/ocaml-ppx/ocaml-migrate-parsetree")
(synopsis "OCaml parsetree convertor")
(description "This library converts between parsetrees of different OCaml
versions. For each version, there is a snapshot of the parsetree and conversion
@@ -4694,6 +4651,38 @@ Dedukti files.")
syntax checking on dedukti files.")
(license license:cecill-b))))
+(define-public ocaml-ppx-inline-test
+ (package
+ (name "ocaml-ppx-inline-test")
+ (version "0.11.0")
+ (home-page "https://github.com/janestreet/ppx_inline_test")
+ (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
+ "11n94fz1asjf5vqdgriv0pvsa5lbfpqcyk525c7816w23vskcvq6"))))
+ (build-system dune-build-system)
+ (arguments
+ ;see home page README for further information
+ `(#:tests? #f))
+ (inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-compiler-libs" ,ocaml-compiler-libs)
+ ("ocaml-sexplib0" ,ocaml-sexplib0)
+ ("ocaml-stdio" ,ocaml-stdio)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (synopsis "Syntax extension for writing in-line tests in ocaml code")
+ (description "This package contains a syntax extension for writing
+in-line tests in ocaml code. It is part of Jane Street's PPX rewriters
+collection.")
+ (license license:expat)))
+
(define-public ocaml-biniou
(package
(name "ocaml-biniou")
@@ -4987,7 +4976,7 @@ parsexp_io.")
(base32
"1qfl0m04rpcjvc4yw1hzh6r16jpwmap0sa9ax6zjji67dz4szpyb"))))
(build-system dune-build-system)
- (inputs
+ (propagated-inputs
`(("ocaml-num" ,ocaml-num)
("ocaml-parsexp" ,ocaml-parsexp)
("ocaml-sexplib0" ,ocaml-sexplib0)))
@@ -5014,7 +5003,7 @@ functionality for parsing and pretty-printing s-expressions.")
(base32
"0j6xb4265jr41vw4fjzak6yr8s30qrnzapnc6rl1dxy8bjai0nir"))))
(build-system dune-build-system)
- (inputs
+ (propagated-inputs
`(("ocaml-sexplib0" ,ocaml-sexplib0)))
(arguments
`(#:phases
@@ -5077,8 +5066,9 @@ is now @code{Ocaml_common.Ast_helper}.")
(base32
"1facajqhvq34g2wrg368y0ajxd6lrj5b3lyzyj0jhdmraxajjcwn"))))
(build-system dune-build-system)
- (inputs `(("ocaml-base" ,ocaml-base)
- ("ocaml-sexplib0" ,ocaml-sexplib0)))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-sexplib0" ,ocaml-sexplib0)))
(arguments
'(#:tests? #f)) ;no tests
(synopsis "Standard IO library for OCaml")
@@ -5107,6 +5097,7 @@ a more consistent API.")
(build-system dune-build-system)
(arguments
'(#:tests? #f)) ;no tests
+ (properties `((upstream-name . "ppx_derivers")))
(synopsis "Shared @code{@@deriving} plugin registry")
(description
"Ppx_derivers is a tiny package whose sole purpose is to allow
@@ -5130,7 +5121,7 @@ as part of the same ocaml-migrate-parsetree driver.")
(base32
"1nr4igf5m4prvigvv470dnhfdhdw0p6hz6zw8gnm5bzcv7s2lg5l"))))
(build-system dune-build-system)
- (inputs
+ (propagated-inputs
`(("ocaml-base" ,ocaml-base)
("ocaml-compiler-libs" ,ocaml-compiler-libs)
("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
@@ -5138,8 +5129,6 @@ as part of the same ocaml-migrate-parsetree driver.")
("ocaml-stdio" ,ocaml-stdio)
("ocaml-result" ,ocaml-result)
("ocaml-sexplib0" ,ocaml-sexplib0)))
- (native-inputs
- `(("ocaml-findlib" ,ocaml-findlib)))
(arguments
'(#:phases
(modify-phases %standard-phases
@@ -5147,7 +5136,7 @@ as part of the same ocaml-migrate-parsetree driver.")
(lambda* (#:key inputs #:allow-other-keys)
;; add the line #directory ".." at the top of each file
;; using #use "topfind";; to be able to find topfind
- (let* ((findlib-path (assoc-ref inputs "ocaml-findlib"))
+ (let* ((findlib-path (assoc-ref inputs "findlib"))
(findlib-libdir
(string-append findlib-path "/lib/ocaml/site-lib")))
(substitute* '("test/base/test.ml"
@@ -5175,3 +5164,999 @@ OCaml AST in the OCaml syntax;
@item a generator of open recursion classes from type definitions.
@end itemize")
(license license:expat)))
+
+(define-public ocaml-ppx-compare
+ (package
+ (name "ocaml-ppx-compare")
+ (version "0.11.1")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/janestreet/ppx_compare.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "06bq4m1bsm4jlx4g7wh5m99qky7xm4c2g52kaz6pv25hdn5agi2m"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_compare")))
+ (home-page "https://github.com/janestreet/ppx_compare")
+ (synopsis "Generation of comparison functions from types")
+ (description "Generation of fast comparison functions from type expressions
+and definitions. Ppx_compare is a ppx rewriter that derives comparison functions
+from type representations. The scaffolded functions are usually much faster
+than ocaml's Pervasives.compare. Scaffolding functions also gives you more
+flexibility by allowing you to override them for a specific type and more safety
+by making sure that you only compare comparable values.")
+ (license license:asl2.0)))
+
+(define-public ocaml-fieldslib
+ (package
+ (name "ocaml-fieldslib")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version) "/files/"
+ "fieldslib-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "12948pzxrl360lybm9fzyvplgcl87zjbn4m3sk1aw75zk85p1388"))))
+ (build-system dune-build-system)
+ (arguments
+ ;; No tests
+ `(#:tests? #f))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "fieldslib")))
+ (home-page "https://github.com/janestreet/fieldslib")
+ (synopsis "Syntax extension to record fields")
+ (description "Syntax extension to define first class values representing
+record fields, to get and set record fields, iterate and fold over all fields
+of a record and create new record values.")
+ (license license:asl2.0)))
+
+(define-public ocaml-variantslib
+ (package
+ (name "ocaml-variantslib")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/variantslib-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "1hsdwmkslvk4cznqr4lyyiy7vvk5spil226k0z2in26fxq6y0hf3"))))
+ (build-system dune-build-system)
+ (arguments
+ ;; No tests
+ `(#:tests? #f))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "variantslib")))
+ (home-page "https://github.com/janestreet/variantslib")
+ (synopsis "OCaml variants as first class values")
+ (description "The Core suite of libraries is an alternative to OCaml's
+standard library.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-fields-conv
+ (package
+ (name "ocaml-ppx-fields-conv")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_fields_conv-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "07zrd3qky2ppbfl55gpm90rvqa5860xgwcsvihrjmkrw6d0jirkc"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-fieldslib" ,ocaml-fieldslib)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_fields_conv")))
+ (home-page "https://github.com/janestreet/ppx_fields_conv")
+ (synopsis "Generation of accessor and iteration functions for ocaml records")
+ (description "Ppx_fields_conv is a ppx rewriter that can be used to define
+first class values representing record fields, and additional routines, to get
+and set record fields, iterate and fold over all fields of a record and create
+new record values.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-sexp-conv
+ (package
+ (name "ocaml-ppx-sexp-conv")
+ (version "0.11.2")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/janestreet/ppx_sexp_conv.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0pqwnqy1xp309wvdcaax4lg02yk64lq2w03mbgfvf6ps5ry4gis9"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_sexp_conv")))
+ (home-page "https://github.com/janestreet/ppx_sexp_conv")
+ (synopsis "Generation of S-expression conversion functions from type definitions")
+ (description "This package generates S-expression conversion functions from type
+definitions.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-variants-conv
+ (package
+ (name "ocaml-ppx-variants-conv")
+ (version "0.11.1")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/janestreet/ppx_variants_conv.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1yc0gsds5m2nv39zga8nnrca2n75rkqy5dz4xj1635ybz20hhbjd"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-variantslib" ,ocaml-variantslib)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties
+ `((upstream-name . "ppx_variants_conv")))
+ (home-page
+ "https://github.com/janestreet/ppx_variants_conv")
+ (synopsis "Generation of accessor and iteration functions for OCaml variant types")
+ (description
+ "This package generates accessors and interation functions for OCaml
+variant types.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-custom-printf
+ (package
+ (name "ocaml-ppx-custom-printf")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_custom_printf-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "11b73smf3g3bpd9lg014pr4rx285nk9mnk6g6464ph51jv0sqzhj"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_custom_printf")))
+ (home-page "https://github.com/janestreet/ppx_custom_printf")
+ (synopsis "Printf-style format-strings for user-defined string conversion")
+ (description "Extensions to printf-style format-strings for user-defined
+string conversion.")
+ (license license:asl2.0)))
+
+(define-public ocaml-bin-prot
+ (package
+ (name "ocaml-bin-prot")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/bin_prot-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "1rsd91gx36prj4whi76nsiz1bzpgal9nzyw3pxdz1alv4ilk2il6"))))
+ (build-system dune-build-system)
+ (inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-ppx-compare" ,ocaml-ppx-compare)
+ ("ocaml-ppx-custom-printf" ,ocaml-ppx-custom-printf)
+ ("ocaml-ppx-fields-conv" ,ocaml-ppx-fields-conv)
+ ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
+ ("ocaml-ppx-variants-conv" ,ocaml-ppx-variants-conv)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)))
+ (properties `((upstream-name . "bin_prot")))
+ (home-page "https://github.com/janestreet/bin_prot")
+ (synopsis "Binary protocol generator")
+ (description "This library contains functionality for reading and writing
+OCaml-values in a type-safe binary protocol. It is extremely efficient,
+typically supporting type-safe marshalling and unmarshalling of even highly
+structured values at speeds sufficient to saturate a gigabit connection. The
+protocol is also heavily optimized for size, making it ideal for long-term
+storage of large amounts of data.")
+ (license (list
+ license:asl2.0
+ license:bsd-3))))
+
+(define-public ocaml-octavius
+ (package
+ (name "ocaml-octavius")
+ (version "1.2.0")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ocaml-doc/octavius")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0gqfbwsh0zq4b9mvvlmg3zhpbfbvq8swqr31320aibbqydwf77hr"))))
+ (build-system dune-build-system)
+ (properties `((upstream-name . "octavius")))
+ (home-page "https://github.com/ocaml-doc/octavius")
+ (synopsis "Ocamldoc comment syntax parser")
+ (description "Octavius is a library to parse the `ocamldoc` comment syntax.")
+ (license license:isc)))
+
+(define-public ocaml-ppx-hash
+ (package
+ (name "ocaml-ppx-hash")
+ (version "0.11.1")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/janestreet/ppx_hash.git")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "1p0ic6aijxlrdggpmycj12q3cy9xksbq2vq727215maz4snvlf5p"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-ppx-compare" ,ocaml-ppx-compare)
+ ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_hash")))
+ (home-page "https://github.com/janestreet/ppx_hash")
+ (synopsis "Generation of hash functions from type expressions and definitions")
+ (description "This package is a collecton of ppx rewriters that generate
+hash functions from type exrpessions and definitions.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-enumerate
+ (package
+ (name "ocaml-ppx-enumerate")
+ (version "0.11.1")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/janestreet/ppx_enumerate.git")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "0spx9k1v7vjjb6sigbfs69yndgq76v114jhxvzjmffw7q989cyhr"))))
+ (build-system dune-build-system)
+ (arguments
+ ;; No tests
+ `(#:tests? #f))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_enumerate")))
+ (home-page "https://github.com/janestreet/ppx_enumerate")
+ (synopsis "Generate a list containing all values of a finite type")
+ (description "Ppx_enumerate is a ppx rewriter which generates a definition
+for the list of all values of a type (for a type which only has finitely
+many values).")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-bench
+ (package
+ (name "ocaml-ppx-bench")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_bench-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "0ys4pblbcjbk9dn073rqiwm7r6rc7fah03j7riklkwnb5n44andl"))))
+ (build-system dune-build-system)
+ (arguments
+ ;; No tests
+ `(#:tests? #f))
+ (propagated-inputs
+ `(("ocaml-ppx-inline-test" ,ocaml-ppx-inline-test)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_bench")))
+ (home-page "https://github.com/janestreet/ppx_bench")
+ (synopsis "Syntax extension for writing in-line benchmarks in ocaml code")
+ (description "Syntax extension for writing in-line benchmarks in ocaml code.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-here
+ (package
+ (name "ocaml-ppx-here")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_here-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "0wxcak3ay4jpigm3pfdcpr65qw4hxfa8whhkryhcd8gy71x056z5"))))
+ (build-system dune-build-system)
+ (arguments
+ ;; broken tests
+ `(#:tests? #f))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_here")))
+ (home-page "https://github.com/janestreet/ppx_here")
+ (synopsis "Expands [%here] into its location")
+ (description
+ "Part of the Jane Street's PPX rewriters collection.")
+ (license license:asl2.0)))
+
+(define-public ocaml-typerep
+ (package
+ (name "ocaml-typerep")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/typerep-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "1zi7hy0prpgzqhr4lkacr04wvlvbp21jfbdfvffhrm6cd400rb5v"))))
+ (build-system dune-build-system)
+ (arguments
+ `(#:tests? #f))
+ (propagated-inputs `(("ocaml-base" ,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.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-sexp-value
+ (package
+ (name "ocaml-ppx-sexp-value")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_sexp_value-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "1xnalfrln6k5khsyxvxkg6v32q8fpr4cqamsjqfih29jdv486xrs"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-ppx-here" ,ocaml-ppx-here)
+ ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_sexp_value")))
+ (home-page "https://github.com/janestreet/ppx_sexp_value")
+ (synopsis "Simplify building s-expressions from ocaml values")
+ (description "A ppx rewriter that simplifies building s-expressions from
+ocaml values.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-sexp-message
+ (package
+ (name "ocaml-ppx-sexp-message")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_sexp_message-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "1yh440za0w9cvrbxbmqacir8715kdaw6sw24ys9xj80av9nqpiw7"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-ppx-here" ,ocaml-ppx-here)
+ ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_sexp_message")))
+ (home-page "https://github.com/janestreet/ppx_sexp_message")
+ (synopsis "A ppx rewriter for easy construction of s-expressions")
+ (description "Ppx_sexp_message aims to ease the creation of s-expressions
+in OCaml. This is mainly motivated by writing error and debugging messages,
+where one needs to construct a s-expression based on various element of the
+context such as function arguments.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-pipebang
+ (package
+ (name "ocaml-ppx-pipebang")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_pipebang-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "1wrrzlb4kdvkkcmzi01fw25jar38r2jlnyn0i6pn4z0lq4gpm9m0"))))
+ (build-system dune-build-system)
+ (arguments
+ ;; No tests
+ `(#:tests? #f))
+ (propagated-inputs
+ `(("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_pipebang")))
+ (home-page "https://github.com/janestreet/ppx_pipebang")
+ (synopsis "Inline reverse application operators `|>` and `|!`")
+ (description "A ppx rewriter that inlines reverse application operators
+@code{|>} and @code{|!}.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-optional
+ (package
+ (name "ocaml-ppx-optional")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_optional-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "1z8z2bga95k2vksljljfglg10vygkjd24kn1b37sk4z3nmp47x0h"))))
+ (build-system dune-build-system)
+ (arguments
+ ;; No tests
+ `(#:tests? #f))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_optional")))
+ (home-page "https://github.com/janestreet/ppx_optional")
+ (synopsis "Pattern matching on flat options")
+ (description
+ "A ppx rewriter that rewrites simple match statements with an if then
+else expression.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-optcomp
+ (package
+ (name "ocaml-ppx-optcomp")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_optcomp-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "1bb52p2j2h4s9f06vrcpla80rj93jinnzq6jzilapyx9q068929i"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-stdio" ,ocaml-stdio)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_optcomp")))
+ (home-page "https://github.com/janestreet/ppx_optcomp")
+ (synopsis "Optional compilation for OCaml")
+ (description "Ppx_optcomp stands for Optional Compilation. It is a tool
+used to handle optional compilations of pieces of code depending of the word
+size, the version of the compiler, ...")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-let
+ (package
+ (name "ocaml-ppx-let")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_let-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "1wdfw6w4xbg97a35yg6bif9gggxniy9ddnrjfw1a0inkl2yamxkj"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_let")))
+ (home-page "https://github.com/janestreet/ppx_let")
+ (synopsis "Monadic let-bindings")
+ (description "A ppx rewriter for monadic and applicative let bindings,
+match expressions, and if expressions.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-fail
+ (package
+ (name "ocaml-ppx-fail")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_fail-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "07plqsvljiwvngggfypwq55g46s5my55y45mvlmalrxyppzr03s8"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-ppx-here" ,ocaml-ppx-here)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_fail")))
+ (home-page "https://github.com/janestreet/ppx_fail")
+ (synopsis "Add location to calls to failwiths")
+ (description "Syntax extension that makes [failwiths] always include a
+position.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-assert
+ (package
+ (name "ocaml-ppx-assert")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_assert-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "17kd311n0l9f72gblf9kv8i5rghr106w37x4f0m5qwh6nlgl0j9k"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-ppx-compare" ,ocaml-ppx-compare)
+ ("ocaml-ppx-here" ,ocaml-ppx-here)
+ ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_assert")))
+ (home-page "https://github.com/janestreet/ppx_assert")
+ (synopsis "Assert-like extension nodes that raise useful errors on failure")
+ (description "This package contains assert-like extension nodes that raise
+useful errors on failure.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-expect
+ (package
+ (name "ocaml-ppx-expect")
+ (version "0.11.1")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/janestreet/ppx_expect.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0bnz3cpj3vwdw409r6f8raakl8n364q5l7wy4i6gckr34a4vla69"))))
+ (build-system dune-build-system)
+ (arguments
+ `(#:jbuild? #t))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-ppx-assert" ,ocaml-ppx-assert)
+ ("ocaml-ppx-compare" ,ocaml-ppx-compare)
+ ("ocaml-ppx-custom-printf" ,ocaml-ppx-custom-printf)
+ ("ocaml-ppx-fields-conv" ,ocaml-ppx-fields-conv)
+ ("ocaml-ppx-here" ,ocaml-ppx-here)
+ ("ocaml-ppx-inline-test" ,ocaml-ppx-inline-test)
+ ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
+ ("ocaml-ppx-variants-conv" ,ocaml-ppx-variants-conv)
+ ("ocaml-stdio" ,ocaml-stdio)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)
+ ("ocaml-re" ,ocaml-re)))
+ (properties `((upstream-name . "ppx_expect")))
+ (home-page "https://github.com/janestreet/ppx_expect")
+ (synopsis "Cram like framework for OCaml")
+ (description "Expect-test is a framework for writing tests in OCaml, similar
+to Cram. Expect-tests mimics the existing inline tests framework with the
+@code{let%expect_test} construct. The body of an expect-test can contain
+output-generating code, interleaved with @code{%expect} extension expressions
+to denote the expected output.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-js-style
+ (package
+ (name "ocaml-ppx-js-style")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_js_style-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "0z3fc55jdjhhsblla6z4fqc13kljpcz29q79rvs5h2vsraqrldr2"))))
+ (build-system dune-build-system)
+ (arguments
+ ;; No tests
+ `(#:tests? #f))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-octavius" ,ocaml-octavius)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_js_style")))
+ (home-page "https://github.com/janestreet/ppx_js_style")
+ (synopsis "Code style checker for Jane Street Packages")
+ (description "This packages is a no-op ppx rewriter. It is used as a
+@code{lint} tool to enforce some coding conventions across all Jane Street
+packages.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-typerep-conv
+ (package
+ (name "ocaml-ppx-typerep-conv")
+ (version "0.11.1")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/janestreet/ppx_typerep_conv.git")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "0a13dpfrrg0rsm8qni1bh7pqcda30l70z8r6yzi5a64bmwk7g5ah"))))
+ (build-system dune-build-system)
+ (arguments
+ `(#:test-target "."))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-typerep" ,ocaml-typerep)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_typerep_conv")))
+ (home-page "https://github.com/janestreet/ppx_typerep_conv")
+ (synopsis "Generation of runtime types from type declarations")
+ (description "This package can automatically generate runtime types
+from type definitions.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-base
+ (package
+ (name "ocaml-ppx-base")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_base-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "0aq206pg330jmj7lhcagiiwm3a0b3gsqm801m8ajd4ysyw7idkym"))))
+ (build-system dune-build-system)
+ (arguments
+ `(#:test-target "."))
+ (propagated-inputs
+ `(("ocaml-ppx-compare" ,ocaml-ppx-compare)
+ ("ocaml-ppx-enumerate" ,ocaml-ppx-enumerate)
+ ("ocaml-ppx-hash" ,ocaml-ppx-hash)
+ ("ocaml-ppx-js-style" ,ocaml-ppx-js-style)
+ ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_base")))
+ (home-page "https://github.com/janestreet/ppx_base")
+ (synopsis "Base set of ppx rewriters")
+ (description "Ppx_base is the set of ppx rewriters used for Base.
+
+Note that Base doesn't need ppx to build, it is only used as a
+verification tool.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-bin-prot
+ (package
+ (name "ocaml-ppx-bin-prot")
+ (version "0.11.1")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/janestreet/ppx_bin_prot.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1h60i75bzvhna1axyn662gyrzhh441l79vl142d235i5x31dmnkz"))))
+ (build-system dune-build-system)
+ (arguments
+ ;; Cyclic dependency with ocaml-ppx-jane
+ `(#:tests? #f))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-bin-prot" ,ocaml-bin-prot)
+ ("ocaml-ppx-here" ,ocaml-ppx-here)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_bin_prot")))
+ (home-page "https://github.com/janestreet/ppx_bin_prot")
+ (synopsis "Generation of bin_prot readers and writers from types")
+ (description "Generation of binary serialization and deserialization
+functions from type definitions.")
+ (license license:asl2.0)))
+
+(define-public ocaml-ppx-jane
+ (package
+ (name "ocaml-ppx-jane")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/ppx_jane-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "0lgppkw3aixrfnixihrsz2ipafv8fpvkdpy3pw8n0r615gg8x8la"))))
+ (build-system dune-build-system)
+ (arguments
+ `(#:test-target "."))
+ (propagated-inputs
+ `(("ocaml-ppx-assert" ,ocaml-ppx-assert)
+ ("ocaml-ppx-base" ,ocaml-ppx-base)
+ ("ocaml-ppx-bench" ,ocaml-ppx-bench)
+ ("ocaml-ppx-bin-prot" ,ocaml-ppx-bin-prot)
+ ("ocaml-ppx-custom-printf" ,ocaml-ppx-custom-printf)
+ ("ocaml-ppx-expect" ,ocaml-ppx-expect)
+ ("ocaml-ppx-fail" ,ocaml-ppx-fail)
+ ("ocaml-ppx-fields-conv" ,ocaml-ppx-fields-conv)
+ ("ocaml-ppx-here" ,ocaml-ppx-here)
+ ("ocaml-ppx-inline-test" ,ocaml-ppx-inline-test)
+ ("ocaml-ppx-let" ,ocaml-ppx-let)
+ ("ocaml-ppx-optcomp" ,ocaml-ppx-optcomp)
+ ("ocaml-ppx-optional" ,ocaml-ppx-optional)
+ ("ocaml-ppx-pipebang" ,ocaml-ppx-pipebang)
+ ("ocaml-ppx-sexp-message" ,ocaml-ppx-sexp-message)
+ ("ocaml-ppx-sexp-value" ,ocaml-ppx-sexp-value)
+ ("ocaml-ppx-typerep-conv" ,ocaml-ppx-typerep-conv)
+ ("ocaml-ppx-variants-conv" ,ocaml-ppx-variants-conv)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (properties `((upstream-name . "ppx_jane")))
+ (home-page "https://github.com/janestreet/ppx_jane")
+ (synopsis "Standard Jane Street ppx rewriters")
+ (description "This package installs a ppx-jane executable, which is a ppx
+driver including all standard Jane Street ppx rewriters.")
+ (license license:asl2.0)))
+
+(define-public ocaml-splittable-random
+ (package
+ (name "ocaml-splittable-random")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/splittable_random-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "0l1wbd881mymlnpzlq5q53mmdz3g5d7qjhyc7lfaq1x0iaccn5lc"))))
+ (build-system dune-build-system)
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-ppx-jane" ,ocaml-ppx-jane)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)))
+ (properties `((upstream-name . "splittable_random")))
+ (home-page "https://github.com/janestreet/splittable_random")
+ (synopsis "PRNG that can be split into independent streams")
+ (description "This package provides a splittable
+@acronym{PRNG,pseudo-random number generator} functions like a PRNG that can
+be used as a stream of random values; it can also be split to produce a
+second, independent stream of random values.
+
+This library implements a splittable pseudo-random number generator that sacrifices
+cryptographic-quality randomness in favor of performance.")
+ (license license:asl2.0)))
+
+(define-public ocaml-jane-street-headers
+ (package
+ (name "ocaml-jane-street-headers")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/jane-street-headers-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "0afhzm08l9v883fhpqqh2lmy7az609pxif40bp7x1sk8c0yszqsh"))))
+ (build-system dune-build-system)
+ (arguments
+ `(#:test-target "."))
+ (home-page "https://github.com/janestreet/jane-street-headers")
+ (synopsis "Jane Street C header files")
+ (description "This package provides C header files shared between the
+various Jane Street packages.")
+ (license license:asl2.0)))
+
+(define-public ocaml-configurator
+ (package
+ (name "ocaml-configurator")
+ (version "0.11.0")
+ (source (origin
+ (method url-fetch)
+ (uri (string-append "https://ocaml.janestreet.com/ocaml-core/v"
+ (version-major+minor version)
+ "/files/configurator-v" version ".tar.gz"))
+ (sha256
+ (base32
+ "0kwgi3sh92v4n242dk5hgpwd85zzgnczgbkqi0q0kr6m93zgbf7p"))))
+ (build-system dune-build-system)
+ (arguments
+ ;; No tests
+ `(#:tests? #f))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-stdio" ,ocaml-stdio)))
+ (home-page "https://github.com/janestreet/configurator")
+ (synopsis "Helper library for gathering system configuration")
+ (description "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.
+
+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")
+ (license license:asl2.0)))
+
+(define-public ocaml-spawn
+ (package
+ (name "ocaml-spawn")
+ (version "0.12.0")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/janestreet/spawn.git")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "0amgj7g9sjlbjivn1mg7yjdmxd21hgp4a0ak2zrm95dmm4gi846i"))))
+ (build-system dune-build-system)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-before 'check 'fix-tests
+ (lambda _
+ (substitute* "test/tests.ml"
+ (("/bin/pwd") (which "pwd"))
+ (("/bin/echo") (which "echo")))
+ #t)))))
+ (native-inputs
+ `(("ocaml-ppx-expect" ,ocaml-ppx-expect)))
+ (home-page "https://github.com/janestreet/spawn")
+ (synopsis "Spawning sub-processes")
+ (description
+ "Spawn is a small library exposing only one functionality: spawning sub-process.
+
+It has three main goals:
+
+@itemize
+@item provide missing features of Unix.create_process such as providing a
+working directory,
+@item provide better errors when a system call fails in the
+sub-process. For instance if a command is not found, you get a proper
+@code{Unix.Unix_error} exception,
+@item improve performances by using vfork when available. It is often
+claimed that nowadays fork is as fast as vfork, however in practice
+fork takes time proportional to the process memory while vfork is
+constant time. In application using a lot of memory, vfork can be
+thousands of times faster than fork.
+@end itemize")
+ (license license:asl2.0)))
+
+(define-public ocaml-core
+ (package
+ (name "ocaml-core")
+ (version "0.11.3")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/janestreet/core.git")
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "0pzl8n09z4f3i7z2wq4cjxfqrr8mj6xcdp7rbg0nxap2zdhjgvrq"))))
+ (build-system dune-build-system)
+ (arguments
+ `(#:jbuild? #t
+ ;; Require a cyclic dependency: core_extended
+ #:tests? #f))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-configurator" ,ocaml-configurator)
+ ("ocaml-core-kernel" ,ocaml-core-kernel)
+ ("ocaml-ppx-assert" ,ocaml-ppx-assert)
+ ("ocaml-ppx-jane" ,ocaml-ppx-jane)
+ ("ocaml-sexplib" ,ocaml-sexplib)
+ ("ocaml-spawn" ,ocaml-spawn)
+ ("ocaml-stdio" ,ocaml-stdio)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)
+ ("ocaml-ppxlib" ,ocaml-ppxlib)))
+ (home-page "https://github.com/janestreet/core")
+ (synopsis "Alternative to OCaml's standard library")
+ (description "The Core suite of libraries is an alternative to OCaml's
+standard library that was developed by Jane Street.")
+ ;; Also contains parts of OCaml, relicensed to asl2.0, as permitted
+ ;; by OCaml's license for consortium members (see THIRD-PARTY.txt).
+ (license license:asl2.0)))
+
+(define-public ocaml-core-kernel
+ (package
+ (name "ocaml-core-kernel")
+ (version "0.11.1")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/janestreet/core_kernel.git")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1dg7ygy7i64c5gaakb1cp1b26p9ks81vbxmb8fd7jff2q60j2z2g"))))
+ (build-system dune-build-system)
+ (arguments
+ ;; Cyclic dependency with ocaml-core
+ `(#:tests? #f))
+ (propagated-inputs
+ `(("ocaml-base" ,ocaml-base)
+ ("ocaml-bin-prot" ,ocaml-bin-prot)
+ ("ocaml-configurator" ,ocaml-configurator)
+ ("ocaml-fieldslib" ,ocaml-fieldslib)
+ ("ocaml-jane-street-headers" ,ocaml-jane-street-headers)
+ ("ocaml-ppx-assert" ,ocaml-ppx-assert)
+ ("ocaml-ppx-base" ,ocaml-ppx-base)
+ ("ocaml-ppx-hash" ,ocaml-ppx-hash)
+ ("ocaml-ppx-inline-test" ,ocaml-ppx-inline-test)
+ ("ocaml-ppx-jane" ,ocaml-ppx-jane)
+ ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
+ ("ocaml-ppx-sexp-message" ,ocaml-ppx-sexp-message)
+ ("ocaml-sexplib" ,ocaml-sexplib)
+ ("ocaml-splittable-random" ,ocaml-splittable-random)
+ ("ocaml-stdio" ,ocaml-stdio)
+ ("ocaml-typerep" ,ocaml-typerep)
+ ("ocaml-variantslib" ,ocaml-variantslib)
+ ("ocaml-migrate-parsetree" ,ocaml-migrate-parsetree)))
+ (properties `((upstream-name . "core_kernel")))
+ (home-page "https://github.com/janestreet/core_kernel")
+ (synopsis "Portable standard library for OCaml")
+ (description "Core is an alternative to the OCaml standard library.
+
+Core_kernel is the system-independent part of Core. It is aimed for cases when
+the full Core is not available, such as in Javascript.")
+ (license (list
+ ;; this package and parts of OCaml, relicensed by janestreet
+ license:asl2.0
+ ;; MLton and sjs
+ license:expat))))
generated by cgit v1.2.3 (git 2.25.4) at 2024-11-09 01:32:23 +0000