~yoctocell/guix-yoctocell

53bb27a832d3159d3e85a5b61e025cbb2908d503 — Xinglu Chen 11 months ago 42a8cea master
Cleanup.
4 files changed, 0 insertions(+), 1711 deletions(-)

M Makefile.am
M yoctocell/gnu/packages/chicken.scm
D yoctocell/gnu/packages/ocaml.scm
D yoctocell/gnu/packages/purescript.scm
M Makefile.am => Makefile.am +0 -2
@@ 29,8 29,6 @@ SOURCES =	\
  yoctocell/gnu/packages/gerbil.scm	\
  yoctocell/gnu/packages/haskell.scm	\
  yoctocell/gnu/packages/idris.scm	\
  yoctocell/gnu/packages/ocaml.scm	\
  yoctocell/gnu/packages/purescript.scm	\
  yoctocell/gnu/packages/tex.scm	\
  yoctocell/gnu/packages/version-control.scm	\
  yoctocell/guix/build/idris2-build-system.scm	\

M yoctocell/gnu/packages/chicken.scm => yoctocell/gnu/packages/chicken.scm +0 -1
@@ 3,7 3,6 @@
  #:use-module (guix packages)
  #:use-module (yoctocell guix build-system chicken)
  #:use-module (guix build-system gnu)
  ;; #:use-module ((yoctocell guix build-system chicken) #:prefix yoctocell:)
  #:use-module (guix download)
  #:use-module (guix git-download)
  #:use-module (guix svn-download)

D yoctocell/gnu/packages/ocaml.scm => yoctocell/gnu/packages/ocaml.scm +0 -1631
@@ 1,1631 0,0 @@
(define-module (yoctocell gnu packages ocaml)
  #:use-module (gnu packages)
  #:use-module (gnu packages ocaml)
  #:use-module (gnu packages autotools)
  #:use-module (gnu packages base)
  #:use-module (gnu packages pkg-config)
  #:use-module (gnu packages bison)
  #:use-module (gnu packages gcc)
  #:use-module (gnu packages texinfo)
  #:use-module (gnu packages pcre)
  #:use-module (gnu packages time)
  #:use-module (gnu packages tls)
  #:use-module (gnu packages web)
  #:use-module (guix build-system dune)
  #:use-module (guix build-system emacs)
  #:use-module (guix build-system gnu)
  #:use-module (guix build-system ocaml)
  #:use-module (guix download)
  #:use-module (guix git-download)
  #:use-module (guix hg-download)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (guix packages)
  #:use-module (guix svn-download)
  #:use-module (guix utils))



(define-public ocaml-core
  (package
    (name "ocaml-core")
    (version "0.14.1")
    (source
     (origin
       (method url-fetch)
       (uri "https://github.com/janestreet/core/archive/v0.14.1.tar.gz")
       (sha256
        (base32
         "1862zsk85i00vsv2chgb156b1chp8f7p508hsz6sadjx6h98q5cc"))))
    (build-system dune-build-system)
    (propagated-inputs
     `(("ocaml-core-kernel" ,ocaml-core-kernel)
       ("ocaml-jst-config" ,ocaml-jst-config)
       ("ocaml-ppx-jane" ,ocaml-ppx-jane)
       ("ocaml-sexplib" ,ocaml-sexplib)
       ("ocaml-timezone" ,ocaml-timezone)
       ("ocaml-spawn" ,ocaml-spawn)))
    (home-page "https://github.com/janestreet/core")
    (synopsis
     "Industrial strength alternative to OCaml's standard library")
    (description "This package provides he core suite of libraries is
an industrial strength alternative to OCaml's standard library that
was developed by Jane Street. ")
    (license license:expat)))

(define-public ocaml-core-kernel
  (package
  (name "ocaml-core-kernel")
  (version "0.14.1")
  (source
    (origin
      (method url-fetch)
      (uri "https://github.com/janestreet/core_kernel/archive/v0.14.1.tar.gz")
      (sha256
        (base32
          "0f24sagyzhfr6x68fynhsn5cd1p72vkqm25wnfg8164sivas148x"))))
  (build-system dune-build-system)
  (propagated-inputs
    `(("ocaml-base" ,ocaml-base)
      ("ocaml-base-bigstring" ,ocaml-base-bigstring)
      ("ocaml-base-quickcheck" ,ocaml-base-quickcheck)
      ("ocaml-bin-prot" ,ocaml-bin-prot)
      ("ocaml-fieldslib" ,ocaml-fieldslib)
      ("ocaml-jane-street-headers"
       ,ocaml-jane-street-headers)
      ("ocaml-jst-config" ,ocaml-jst-config)
      ("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-time-now" ,ocaml-time-now)
      ("ocaml-typerep" ,ocaml-typerep)
      ("ocaml-variantslib" ,ocaml-variantslib)))
  (properties `((upstream-name . "core_kernel")))
  (home-page
    "https://github.com/janestreet/core_kernel")
  (synopsis
    "Industrial strength alternative to OCaml's standard library")
  (description
    "
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.

Core_kernel is the system-independent part of Core.
")
  (license license:expat)))


(define-public ocaml-base-quickcheck
  (package
  (name "ocaml-base-quickcheck")
  (version "0.14.1")
  (source
    (origin
      (method url-fetch)
      (uri "https://github.com/janestreet/base_quickcheck/archive/v0.14.1.tar.gz")
      (sha256
        (base32
          "0n5h0ysn593awvz4crkvzf5r800hd1c55bx9mm9vbqs906zii6mn"))))
  (build-system dune-build-system)
  (propagated-inputs
    `(("ocaml-base" ,ocaml-base)
      ("ocaml-ppx-base" ,ocaml-ppx-base)
      ("ocaml-ppx-fields-conv" ,ocaml-ppx-fields-conv)
      ("ocaml-ppx-let" ,ocaml-ppx-let)
      ("ocaml-ppx-sexp-message"
       ,ocaml-ppx-sexp-message)
      ("ocaml-ppx-sexp-value" ,ocaml-ppx-sexp-value)
      ("ocaml-splittable-random"
       ,ocaml-splittable-random)
      ("ocaml-ppxlib" ,ocaml-ppxlib)))
  (properties
    `((upstream-name . "base_quickcheck")))
  (home-page
    "https://github.com/janestreet/base_quickcheck")
  (synopsis
    "Randomized testing framework, designed for compatibility with Base")
  (description
    "
Base_quickcheck provides randomized testing in the style of Haskell's Quickcheck library,
with support for built-in types as well as types provided by Base.
")
  (license license:expat)))

(define-public ocaml-ppx-fixed-literal
  (package
  (name "ocaml-ppx-fixed-literal")
  (version "0.14.0")
  (source
    (origin
      (method url-fetch)
      (uri "https://ocaml.janestreet.com/ocaml-core/v0.14/files/ppx_fixed_literal-v0.14.0.tar.gz")
      (sha256
        (base32
          "0w0a06143mhmczbpr0lfb66r6im7075gck4p0idbcari63sximqj"))))
  (build-system dune-build-system)
  (propagated-inputs
    `(("ocaml-base" ,ocaml-base)
      ("ocaml-ppxlib" ,ocaml-ppxlib)))
  (properties
    `((upstream-name . "ppx_fixed_literal")))
  (home-page
    "https://github.com/janestreet/ppx_fixed_literal")
  (synopsis
    "Simpler notation for fixed point literals")
  (description
    "
A ppx rewriter that rewrites fixed point literal of the 
form 1.0v to conversion functions currently in scope.
")
  (license license:expat)))

(define-public ocaml-typerep
  (package
  (name "ocaml-typerep")
  (version "0.14.0")
  (source
    (origin
      (method url-fetch)
      (uri "https://ocaml.janestreet.com/ocaml-core/v0.14/files/typerep-v0.14.0.tar.gz")
      (sha256
        (base32
          "0rmp5jsjg6sgn5yx0pcvch0phs7nak2fg1d48g5sjcyyyj8n1279"))))
  (build-system dune-build-system)
  (propagated-inputs `(("ocaml-base" ,ocaml-base)))
  (home-page
    "https://github.com/janestreet/typerep")
  (synopsis
    "Typerep is a library for runtime types")
  (description "
")
  (license license:expat)))

(define-public ocaml-base-bigstring
  (package
    (name "ocaml-base-bigstring")
    (version "0.14.0")
    (source
     (origin
       (method url-fetch)
       (uri "https://ocaml.janestreet.com/ocaml-core/v0.14/files/base_bigstring-v0.14.0.tar.gz")
       (sha256
        (base32
         "1fhldk58w56ixkin763kpic512xvkkf9b4mrnjfsbm8in75kzndq"))))
    (build-system dune-build-system)
    (propagated-inputs
     `(("ocaml-base" ,ocaml-base)
       ("ocaml-ppx-jane" ,ocaml-ppx-jane)))
    (properties
     `((upstream-name . "base_bigstring")))
    (home-page
     "https://github.com/janestreet/base_bigstring")
    (synopsis
     "String type based on [Bigarray], for use in I/O and C-bindings")
    (description
     "
String type based on [Bigarray], for use in I/O and C-bindings.
")
    (license license:expat)))


(define-public ocaml-ppx-jane
  (package
  (name "ocaml-ppx-jane")
  (version "0.14.0")
  (source
    (origin
      (method url-fetch)
      (uri "https://ocaml.janestreet.com/ocaml-core/v0.14/files/ppx_jane-v0.14.0.tar.gz")
      (sha256
        (base32
          "18js98xdqf8d54sjn1gccjkwbv2p56qy7bhvjgk94pr3fipfz0v7"))))
  (build-system dune-build-system)
  (propagated-inputs
    `(("ocaml-base-quickcheck" ,ocaml-base-quickcheck)
      ("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-fields-conv" ,ocaml-ppx-fields-conv)
      ("ocaml-ppx-fixed-literal"
       ,ocaml-ppx-fixed-literal)
      ("ocaml-ppx-here" ,ocaml-ppx-here)
      ("ocaml-ppx-inline-test" ,ocaml-ppx-inline-test)
      ("ocaml-ppx-let" ,ocaml-ppx-let)
      ("ocaml-ppx-module-timer"
       ,ocaml-ppx-module-timer)
      ("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-stable" ,ocaml-ppx-stable)
      ("ocaml-ppx-string" ,ocaml-ppx-string)
      ("ocaml-ppx-typerep-conv"
       ,ocaml-ppx-typerep-conv)
      ("ocaml-ppx-variants-conv"
       ,ocaml-ppx-variants-conv)
      ("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:expat)))


(define-public ocaml-bin-prot
  (package
    (name "ocaml-bin-prot")
    (version "0.14.0")
    (source
     (origin
       (method url-fetch)
       (uri "https://ocaml.janestreet.com/ocaml-core/v0.14/files/bin_prot-v0.14.0.tar.gz")
       (sha256
        (base32
         "1f1ng6cixi3ci0nb765yfzqk9b3s752hy1i3702kh59gni1psycp"))))
    (build-system dune-build-system)
    (propagated-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-optcomp" ,ocaml-ppx-optcomp)
       ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
       ("ocaml-ppx-variants-conv"
        ,ocaml-ppx-variants-conv)))
    (properties `((upstream-name . "bin_prot")))
    (home-page
     "https://github.com/janestreet/bin_prot")
    (synopsis "A binary protocol generator")
    (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)))

(define-public ocaml-ppx-sexp-message
  (package
  (name "ocaml-ppx-sexp-message")
  (version "0.14.1")
  (source
    (origin
      (method url-fetch)
      (uri "https://github.com/janestreet/ppx_sexp_message/archive/v0.14.1.tar.gz")
      (sha256
        (base32
          "06d1cx8nh6chgx09lqjgsagc02lfsvv18fydrviqjvydx52m2qjf"))))
  (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-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
    "
Part of the Jane Street's PPX rewriters collection.
")
  (license license:expat)))

(define-public ocaml-timezone
  (package
  (name "ocaml-timezone")
  (version "0.14.0")
  (source
    (origin
      (method url-fetch)
      (uri "https://ocaml.janestreet.com/ocaml-core/v0.14/files/timezone-v0.14.0.tar.gz")
      (sha256
        (base32
          "095xni0szjqqax2r9zh9820l72ixfga2pl0njnarp3795vkw0rdp"))))
  (build-system dune-build-system)
  (propagated-inputs
    `(("ocaml-core-kernel" ,ocaml-core-kernel)
      ("ocaml-ppx-jane" ,ocaml-ppx-jane)))
  (home-page
    "https://github.com/janestreet/timezone")
  (synopsis "Time-zone handling")
  (description
    "
Timezone handles parsing timezone data and create [Timezone.t] that
can later be used to manipulate time in core_kernel or core.
")
  (license license:expat)))


(define-public ocaml-spawn
  (package
  (name "ocaml-spawn")
  (version "0.13.0")
  (source
    (origin
      (method url-fetch)
      (uri "https://github.com/janestreet/spawn/releases/download/v0.13.0/spawn-v0.13.0.tbz")
      (sha256
        (base32
          "00kcdy6lrqllh7n00d7lkvjvqf4kj0y9a2hj2shp0bjqphnjd9nh"))))
  (build-system dune-build-system)
  (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:

1. provide missing features of Unix.create_process such as providing a
working directory

2. provide better errors when a system call fails in the
sub-process. For instance if a command is not found, you get a proper
[Unix.Unix_error] exception

3. 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.
")
  (license license:asl2.0)))

(define-public ocaml-splittable-random
  (package
  (name "ocaml-splittable-random")
  (version "0.14.0")
  (source
    (origin
      (method url-fetch)
      (uri "https://ocaml.janestreet.com/ocaml-core/v0.14/files/splittable_random-v0.14.0.tar.gz")
      (sha256
        (base32
          "185rpmdnrzs80br138pnjbx9hfp1046zvj1ap0brq1sxdwzak6lf"))))
  (build-system dune-build-system)
  (propagated-inputs
    `(("ocaml-base" ,ocaml-base)
      ("ocaml-ppx-assert" ,ocaml-ppx-assert)
      ("ocaml-ppx-bench" ,ocaml-ppx-bench)
      ("ocaml-ppx-inline-test" ,ocaml-ppx-inline-test)
      ("ocaml-ppx-sexp-message"
       ,ocaml-ppx-sexp-message)))
  (properties
    `((upstream-name . "splittable_random")))
  (home-page
    "https://github.com/janestreet/splittable_random")
  (synopsis
    "PRNG that can be split into independent streams")
  (description
    "
PRNG that can be split into independent streams

A splittable pseudo-random number generator (SPRNG) functions like a PRNG in that it 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:expat)))

(define-public ocaml-ppx-sexp-value
  (package
  (name "ocaml-ppx-sexp-value")
  (version "0.14.0")
  (source
    (origin
      (method url-fetch)
      (uri "https://ocaml.janestreet.com/ocaml-core/v0.14/files/ppx_sexp_value-v0.14.0.tar.gz")
      (sha256
        (base32
          "0yc6i1yx9mb8pwjkswy09aqg5kz1hgrpjyniq2v6whfjvxl1qrkj"))))
  (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-ppxlib" ,ocaml-ppxlib)))
  (properties
    `((upstream-name . "ppx_sexp_value")))
  (home-page
    "https://github.com/janestreet/ppx_sexp_value")
  (synopsis
    "A ppx rewriter that simplifies building s-expressions from ocaml values")
  (description
    "
Part of the Jane Street's PPX rewriters collection.
")
  (license license:expat)))

(define-public ocaml-ppx-bench
  (package
  (name "ocaml-ppx-bench")
  (version "0.14.1")
  (source
    (origin
      (method url-fetch)
      (uri "https://github.com/janestreet/ppx_bench/archive/v0.14.1.tar.gz")
      (sha256
        (base32
          "1jr3cf4zsk894x64c8ir9ap9l412q35b2605pr7flrlxbm4vkf3f"))))
  (build-system dune-build-system)
  (propagated-inputs
    `(("ocaml-ppx-inline-test" ,ocaml-ppx-inline-test)
      ("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
   "Part of the Jane Street's PPX rewriters collection.")
  (license license:expat)))

(define-public ocaml-ppx-bin-prot
  (package
    (name "ocaml-ppx-bin-prot")
    (version "0.14.0")
    (source
     (origin
       (method url-fetch)
       (uri "https://ocaml.janestreet.com/ocaml-core/v0.14/files/ppx_bin_prot-v0.14.0.tar.gz")
       (sha256
        (base32
         "0wa2jmvm2k88b37pbcafy1mdf5iaip0yxg5dw774sbh28nm08m2s"))))
    (build-system dune-build-system)
    (native-inputs
     `(("ocaml-ppx-jane" ,ocaml-ppx-jane)))
    (propagated-inputs
     `(("ocaml-base" ,ocaml-base)
       ("ocaml-bin-prot" ,ocaml-bin-prot)
       ("ocaml-ppx-here" ,ocaml-ppx-here)
       ("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
     "Part of the Jane Street's PPX rewriters collection.")
    (license license:expat)))

(define-public ocaml-ppx-module-timer
  (package
  (name "ocaml-ppx-module-timer")
  (version "0.14.0")
  (source
    (origin
      (method url-fetch)
      (uri "https://ocaml.janestreet.com/ocaml-core/v0.14/files/ppx_module_timer-v0.14.0.tar.gz")
      (sha256
        (base32
          "04a7vzk4s3jn6wj94q0hn8kd9vxlzkpcq5ifpvz3bdfgmypjks5z"))))
  (build-system dune-build-system)
  (propagated-inputs
    `(("ocaml-base" ,ocaml-base)
      ("ocaml-ppx-base" ,ocaml-ppx-base)
      ("ocaml-stdio" ,ocaml-stdio)
      ("ocaml-time-now" ,ocaml-time-now)
      ("ocaml-ppxlib" ,ocaml-ppxlib)))
  (properties
    `((upstream-name . "ppx_module_timer")))
  (home-page
    "https://github.com/janestreet/ppx_module_timer")
  (synopsis "PPX rewriter that records top-level module startup times")
  (description
   "Part of the Jane Street's PPX rewriters collection.")
  (license license:expat)))

(define-public ocaml-ppx-pipebang
  (package
  (name "ocaml-ppx-pipebang")
  (version "0.14.0")
  (source
    (origin
      (method url-fetch)
      (uri "https://ocaml.janestreet.com/ocaml-core/v0.14/files/ppx_pipebang-v0.14.0.tar.gz")
      (sha256
        (base32
          "19afbbvy72i1347prvkpy3ms75xnk7kl2hn83h40p6yh27100hky"))))
  (build-system dune-build-system)
  (propagated-inputs
    `(("ocaml-ppxlib" ,ocaml-ppxlib)))
  (properties `((upstream-name . "ppx_pipebang")))
  (home-page "https://github.com/janestreet/ppx_pipebang")
  (synopsis
    "A PPX rewriter that inlines reverse application operators `|>` and `|!`")
  (description
   "Part of the Jane Street's PPX rewriters collection.")
  (license license:expat)))

(define-public ocaml-ppx-stable
  (package
  (name "ocaml-ppx-stable")
  (version "0.14.1")
  (source
    (origin
      (method url-fetch)
      (uri "https://github.com/janestreet/ppx_stable/archive/v0.14.1.tar.gz")
      (sha256
        (base32
          "1dw8ilrvi5lssxnbflnzskmyi3k93ij2kbyz49y93agv0b8dsq01"))))
  (build-system dune-build-system)
  (propagated-inputs
    `(("ocaml-base" ,ocaml-base)
      ("ocaml-ppxlib" ,ocaml-ppxlib)))
  (properties `((upstream-name . "ppx_stable")))
  (home-page "https://github.com/janestreet/ppx_stable")
  (synopsis "Stable types conversions generator")
  (description
   "This package provides a PPX extension for easier implementation of
conversion functions between almost identical types.")
  (license license:expat)))

(define-public ocaml-ppx-string
  (package
  (name "ocaml-ppx-string")
  (version "0.14.1")
  (source
    (origin
      (method url-fetch)
      (uri "https://github.com/janestreet/ppx_string/archive/v0.14.1.tar.gz")
      (sha256
        (base32
          "1a8f7bplbxvwm4lh0m57j89jkwkxfm9r5ndcvvlj5v6py8pv69wj"))))
  (build-system dune-build-system)
  (propagated-inputs
    `(("ocaml-base" ,ocaml-base)
      ("ocaml-ppx-base" ,ocaml-ppx-base)
      ("ocaml-stdio" ,ocaml-stdio)
      ("ocaml-ppxlib" ,ocaml-ppxlib)))
  (properties `((upstream-name . "ppx_string")))
  (home-page "https://github.com/janestreet/ppx_string")
  (synopsis "PPX extension for string interpolation")
  (description "Part of the Jane Street's PPX rewriters collection.")
  (license license:expat)))

(define-public ocaml-ppx-typerep-conv
  (package
    (name "ocaml-ppx-typerep-conv")
    (version "0.14.2")
    (source
     (origin
       (method url-fetch)
       (uri "https://github.com/janestreet/ppx_typerep_conv/archive/v0.14.2.tar.gz")
       (sha256
        (base32
         "1g1sb3prscpa7jwnk08f50idcgyiiv0b9amkl0kymj5cghkdqw0n"))))
    (build-system dune-build-system)
    (propagated-inputs
     `(("ocaml-base" ,ocaml-base)
       ("ocaml-typerep" ,ocaml-typerep)
       ("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
     "Part of the Jane Street's PPX rewriters collection.")
    (license license:expat)))



;;; Ready

(define-public ocaml-monadic
  ;; Latest tag is from 2015.
  ;; Commit from 2021-06-16.
  (let ((commit "017b157a0026b3d68f6d63d047e4720912200789")
        (revision "0"))
    (package
      (name "ocaml-monadic")
      (version (git-version "0.5" revision commit))
      (source
       (origin
         (method git-fetch)
         (uri (git-reference
               (url "http://github.com/zepalmer/ocaml-monadic")
               (commit commit)))
         (file-name (git-file-name name version))
         (sha256
          (base32
           "1bgn077jlr1z9ggdxigwv4fndgphky732nfnr2nrxcbq1z55c8rd"))))
      (build-system dune-build-system)
      (propagated-inputs
       `(("ocaml-ppxlib" ,ocaml-ppxlib)))
      (arguments
       `(#:test-target
         "src_test"
         #:phases
         (modify-phases %standard-phases
           (add-after 'unpack 'make-files-writable
             (lambda _
               (make-file-writable "ocaml-monadic.opam"))))))
      (properties `((upstream-name . "ocaml-monadic")))
      (home-page "http://github.com/zepalmer/ocaml-monadic")
      (synopsis
       "A PPX extension to provide an OCaml-friendly monadic syntax")
      (description "This package provides a PPX extension for OCaml to
support natural monadic syntax.")
      (license license:bsd-3))))

(define-public ocaml-uri-sexp
  (package
    (name "ocaml-uri-sexp")
    (version "4.2.0")
    (source
      (origin
        (method url-fetch)
        (uri "https://github.com/mirage/ocaml-uri/releases/download/v4.2.0/uri-v4.2.0.tbz")
        (sha256
          (base32
            "0szifda6yism5vn5jdizkha3ad0xk6zw4xgfl8g77dnv83ci7h65"))))
    (build-system dune-build-system)
    (arguments
     '(#:package "uri-sexp"
       #:test-target "."))
    (propagated-inputs
      `(("ocaml-uri" ,ocaml-uri)
        ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
        ("ocaml-sexplib0" ,ocaml-sexplib0)))
    (native-inputs `(("ocaml-ounit" ,ocaml-ounit)))
    (home-page "https://github.com/mirage/ocaml-uri")
    (synopsis "An RFC3986 URI/URL parsing library")
    (description "This package add S-exp support to ocaml-uri.")
    (license license:isc)))

(define-public ocaml-cohttp
  (package
    (name "ocaml-cohttp")
    (version "4.0.0")
    (source
      (origin
        (method url-fetch)
        (uri "https://github.com/mirage/ocaml-cohttp/releases/download/v4.0.0/cohttp-v4.0.0.tbz")
        (sha256
          (base32
            "1lnimhmmw5899200k19xrdj4qcj0gbpf6jbwxn84jx425k6s8ymx"))))
    (build-system dune-build-system)
    (arguments
     '(#:package "cohttp"
       #:test-target "cohttp_test/src"))
    (propagated-inputs
      `(("ocaml-re" ,ocaml-re)
        ("ocaml-uri" ,ocaml-uri)
        ("ocaml-uri-sexp" ,ocaml-uri-sexp)
        ("ocaml-sexplib0" ,ocaml-sexplib0)
        ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
        ("ocaml-stringext" ,ocaml-stringext)
        ("ocaml-base64" ,ocaml-base64)))
    (native-inputs
      `(("ocaml-fmt" ,ocaml-fmt)
        ("ocaml-jsonm" ,ocaml-jsonm)
        ("ocaml-alcotest" ,ocaml-alcotest)))
    (home-page "https://github.com/mirage/ocaml-cohttp")
    (synopsis "An OCaml library for HTTP clients and servers")
    (description
      "Cohttp is an OCaml library for creating HTTP daemons. It has a portable
HTTP parser, and implementations using various asynchronous programming
libraries.")
    (license license:isc)))

(define-public ocaml-cohttp-lwt
  (package
    (inherit ocaml-cohttp)
    (name "ocaml-cohttp-lwt")
    (arguments
     ;; No tests.
     '(#:package "cohttp-lwt"
       #:tests? #f))
    (propagated-inputs
      `(("ocaml-cohttp" ,ocaml-cohttp)
        ("ocaml-lwt" ,ocaml-lwt)
        ("ocaml-sexplib0" ,ocaml-sexplib0)
        ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
        ("ocaml-logs" ,ocaml-logs)
        ("ocaml-uri" ,ocaml-uri)))
    (synopsis
      "CoHTTP implementation using the Lwt concurrency library")
    (description
      "This package provides a portable implementation of HTTP that uses the
Lwt concurrency library to multiplex IO.   It implements as much of the
logic in an OS-independent way as possible, so that more specialised
modules can be tailored for different targets.")
    (license license:isc)))


;; (define-public ocaml-cohttp-lwt-unix
;;   (package
;;     (name "ocaml-cohttp-lwt-unix")
;;     (version "4.0.0")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri "https://github.com/mirage/ocaml-cohttp/releases/download/v4.0.0/cohttp-v4.0.0.tbz")
;;        (sha256
;;         (base32
;;          "1lnimhmmw5899200k19xrdj4qcj0gbpf6jbwxn84jx425k6s8ymx"))))
;;     (build-system dune-build-system)
;;     (propagated-inputs
;;      `(("ocaml-conduit-lwt" ,ocaml-conduit-lwt)
;;        ("ocaml-conduit-lwt-unix"
;;         ,ocaml-conduit-lwt-unix)
;;        ("ocaml-cmdliner" ,ocaml-cmdliner)
;;        ("ocaml-magic-mime" ,ocaml-magic-mime)
;;        ("ocaml-logs" ,ocaml-logs)
;;        ("ocaml-fmt" ,ocaml-fmt)
;;        ("ocaml-cohttp-lwt" ,ocaml-cohttp-lwt)
;;        ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
;;        ("ocaml-lwt" ,ocaml-lwt)))
;;     (native-inputs `(("ocaml-ounit" ,ocaml-ounit)))
;;     (home-page "https://github.com/mirage/ocaml-cohttp")
;;     (synopsis "CoHTTP implementation for Unix using Lwt")
;;     (description
;;      "This package provides an implementation of an HTTP client and server
;; using the Unix bindings for Lwt concurrency library.")
;;     (license license:isc)))
;; 
;; (define-public ocaml-conduit
;;   (package
;;     (name "ocaml-conduit")
;;     (version "4.0.0")
;;     (source
;;       (origin
;;         (method url-fetch)
;;         (uri "https://github.com/mirage/ocaml-conduit/releases/download/v4.0.0/conduit-v4.0.0.tbz")
;;         (sha256
;;           (base32
;;             "0andvrb3rjyi3crp3idr30qr5952sl517rnaqkawbba7pxr9vckl"))))
;;     (build-system dune-build-system)
;;     (arguments
;;      '(#:package "conduit"
;;                  #:test-target "tests"))
;;     (propagated-inputs
;;       `(("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
;;         ("ocaml-sexplib" ,ocaml-sexplib)
;;         ("ocaml-astring" ,ocaml-astring)
;;         ("ocaml-uri" ,ocaml-uri)
;;         ("ocaml-logs" ,ocaml-logs)
;;         ("ocaml-ipaddr" ,ocaml-ipaddr)
;;         ("ocaml-ipaddr-sexp" ,ocaml-ipaddr-sexp)))
;;     (home-page "https://github.com/mirage/ocaml-conduit")
;;     (synopsis "Network connection establishment library")
;;     (description
;;      "This package takes care of establishing and listening for
;; TCP and SSL/TLS connections for the Lwt and Async libraries.
;; 
;; By default, OpenSSL is used as the preferred connection library, but
;; you can force the use of the pure OCaml TLS stack by setting the
;; environment variable @code{CONDUIT_TLS=native} when starting your program. ")
;;     (license license:isc)))
;; 
;; (define-public ocaml-conduit-lwt
;;   (package
;;     (inherit ocaml-conduit)
;;     (name "ocaml-conduit-lwt")
;;     (arguments
;;      '(#:package "conduit-lwt"
;;                  #:test-target "tests"))
;;     (propagated-inputs
;;       `(("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
;;         ("ocaml-sexplib" ,ocaml-sexplib)
;;         ("ocaml-conduit" ,ocaml-conduit)
;;         ("ocaml-lwt" ,ocaml-lwt)))
;;     (home-page "https://github.com/mirage/ocaml-conduit")
;;     (synopsis "Portable network connection establishment library using Lwt")
;;     (description
;;      "This package provides the portable Lwt implementation for Conduit.")
;;     (license license:isc)))
;; 
;; (define-public ocaml-magic-mime
;;   (package
;;     (name "ocaml-magic-mime")
;;     (version "1.1.3")
;;     (source
;;       (origin
;;         (method url-fetch)
;;         (uri "https://github.com/mirage/ocaml-magic-mime/releases/download/v1.1.3/magic-mime-v1.1.3.tbz")
;;         (sha256
;;           (base32
;;             "1xqjs8bba567yzrzgnr88j5ck97d36zw68zr9v29liya37k6rcvz"))))
;;     (build-system dune-build-system)
;;     (home-page "https://github.com/mirage/ocaml-magic-mime")
;;     (synopsis "Map filenames to common MIME types")
;;     (description
;;       "This library contains a database of MIME types that maps filename extensions
;; into MIME types suitable for use in many Internet protocols such as HTTP or
;; e-mail.  It is generated from the `mime.types` file found in Unix systems, but
;; has no dependency on a filesystem since it includes the contents of the
;; database as an ML datastructure.")
;;     (license license:isc)))
;; 
;; (define-public ocaml-ptime
;;   (package
;;     (name "ocaml-ptime")
;;     (version "0.8.5")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri "https://erratique.ch/software/ptime/releases/ptime-0.8.5.tbz")
;;        (sha256
;;         (base32
;;          "1fxq57xy1ajzfdnvv5zfm7ap2nf49znw5f9gbi4kb9vds942ij27"))))
;;     (build-system ocaml-build-system)
;;     (propagated-inputs
;;      `(("ocaml-result" ,ocaml-result)))
;;     (native-inputs
;;      `(("ocaml-findlib" ,ocaml-findlib)
;;        ("ocamlbuild" ,ocamlbuild)
;;        ("ocaml-topkg" ,ocaml-topkg)))
;;     (home-page "https://erratique.ch/software/ptime")
;;     (synopsis "POSIX time for OCaml")
;;     (description
;;      "Ptime has platform independent POSIX time support in pure OCaml. It
;; provides a type to represent a well-defined range of POSIX timestamps
;; with picosecond precision, conversion with date-time values,
;; conversion with [RFC 3339 timestamps][rfc3339] and pretty printing to a
;; human-readable, locale-independent representation.")
;;     (license license:isc)))
;; 
;; (define-public ocaml-mirage-crypto
;;   (package
;;     (name "ocaml-mirage-crypto")
;;     (version "0.10.2")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri "https://github.com/mirage/mirage-crypto/releases/download/v0.10.2/mirage-crypto-v0.10.2.tbz")
;;        (sha256
;;         (base32
;;          "01nr4819xmb0ic303k5j43gy6fq0vwjzmm8wl8mrsb2kldpq5i4n"))))
;;     (build-system dune-build-system)
;;     (propagated-inputs
;;      `(("dune-configurator" ,dune-configurator)
;;        ("ocaml-cstruct" ,ocaml-cstruct)
;;        ("ocaml-eqaf" ,ocaml-eqaf)
;;        ("ocaml-bigarray-compat" ,ocaml-bigarray-compat)))
;;     (native-inputs
;;      `(("pkg-config" ,pkg-config)
;;        ("ocaml-ounit" ,ocaml-ounit)))
;;     (home-page "https://github.com/mirage/mirage-crypto")
;;     (synopsis "Simple symmetric cryptography for the modern age")
;;     (description
;;      "Mirage-crypto provides symmetric ciphers (DES, AES, RC4, ChaCha20/Poly1305), and
;; hashes (MD5, SHA-1, SHA-2).")
;;     (license license:isc)))
;; 
;; (define-public ocaml-eqaf
;;   (package
;;     (name "ocaml-eqaf")
;;     (version "0.7")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri "https://github.com/mirage/eqaf/releases/download/v0.7/eqaf-v0.7.tbz")
;;        (sha256
;;         (base32
;;          "1q09pwhs121vpficl2af1yzs4y7dd9bc1lcxbqyfc4x4m6p6drhh"))))
;;     (build-system dune-build-system)
;;     (native-inputs
;;      `(("ocaml-base64" ,ocaml-base64)
;;        ("ocaml-alcotest" ,ocaml-alcotest)
;;        ("ocaml-crowbar" ,ocaml-crowbar)))
;;     (home-page "https://github.com/mirage/eqaf")
;;     (synopsis "Constant-time equal function on string")
;;     (description
;;      "This package provides an equal function on string in constant-time to avoid timing-attack with crypto stuff.")
;;     (license license:expat)))
;; 
;; (define-public ocaml-ca-certs
;;   (package
;;     (name "ocaml-ca-certs")
;;     (version "0.2.1")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri "https://github.com/mirage/ca-certs/releases/download/v0.2.1/ca-certs-v0.2.1.tbz")
;;        (sha256
;;         (base32
;;          "1wqabp1z0z1vqh2s95k88l88nvzrd9apqmbxjvzzwaaid94hjcfl"))))
;;     (build-system dune-build-system)
;;     (propagated-inputs
;;      `(("ocaml-astring" ,ocaml-astring)
;;        ("ocaml-bos" ,ocaml-bos)
;;        ("ocaml-fpath" ,ocaml-fpath)
;;        ("ocaml-rresult" ,ocaml-rresult)
;;        ("ocaml-ptime" ,ocaml-ptime)
;;        ("ocaml-logs" ,ocaml-logs)
;;        ("ocaml-mirage-crypto" ,ocaml-mirage-crypto)
;;        ("ocaml-x509" ,ocaml-x509)))
;;     (native-inputs
;;      `(("ocaml-alcotest" ,ocaml-alcotest)))
;;     (home-page "https://github.com/mirage/ca-certs")
;;     (synopsis
;;      "Detect root CA certificates from the operating system")
;;     (description
;;      "TLS requires a set of root anchors (Certificate Authorities) to
;; authenticate servers. This library exposes this list so that it can be
;; registered with ocaml-tls.")
;;     (license license:isc)))
;; 
;; (define-public ocaml-x509
;;   (package
;;     (name "ocaml-x509")
;;     (version "0.14.0")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri "https://github.com/mirleft/ocaml-x509/releases/download/v0.14.0/x509-v0.14.0.tbz")
;;        (sha256
;;         (base32
;;          "167lp6rwk44g51n1i74lhzh4i364crjhjbv6xs9j26r6f50z6hlv"))))
;;     (build-system dune-build-system)
;;     (propagated-inputs
;;      `(("ocaml-cstruct" ,ocaml-cstruct)
;;        ("ocaml-asn1-combinators"
;;         ,ocaml-asn1-combinators)
;;        ("ocaml-ptime" ,ocaml-ptime)
;;        ("ocaml-base64" ,ocaml-base64)
;;        ("ocaml-mirage-crypto" ,ocaml-mirage-crypto)
;;        ("ocaml-mirage-crypto-pk"
;;         ,ocaml-mirage-crypto-pk)
;;        ("ocaml-mirage-crypto-ec"
;;         ,ocaml-mirage-crypto-ec)
;;        ("ocaml-mirage-crypto-rng"
;;         ,ocaml-mirage-crypto-rng)
;;        ("ocaml-rresult" ,ocaml-rresult)
;;        ("ocaml-fmt" ,ocaml-fmt)
;;        ("ocaml-gmap" ,ocaml-gmap)
;;        ("ocaml-domain-name" ,ocaml-domain-name)
;;        ("ocaml-logs" ,ocaml-logs)
;;        ("ocaml-pbkdf" ,ocaml-pbkdf)))
;;     (native-inputs
;;      `(("ocaml-alcotest" ,ocaml-alcotest)
;;        ("ocaml-cstruct-unix" ,ocaml-cstruct-unix)))
;;     (home-page "https://github.com/mirleft/ocaml-x509")
;;     (synopsis "Public Key Infrastructure (RFC 5280, PKCS) purely in OCaml")
;;     (description
;;      "X.509 is a public key infrastructure used mostly on the Internet.  It consists
;; of certificates which include public keys and identifiers, signed by an
;; authority. Authorities must be exchanged over a second channel to establish the
;; trust relationship. This library implements most parts of RFC5280 and RFC6125.
;; The Public Key Cryptography Standards (PKCS) defines encoding and decoding
;; (in ASN.1 DER and PEM format), which is also implemented by this library -
;; namely PKCS 1, PKCS 5, PKCS 7, PKCS 8, PKCS 9, PKCS 10, and PKCS 12. ")
;;     (license license:bsd-2)))
;; 
;; (define-public ocaml-crowbar
;;   (package
;;     (name "ocaml-crowbar")
;;     (version "0.2")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri "https://github.com/stedolan/crowbar/archive/v0.2.tar.gz")
;;        (sha256
;;         (base32
;;          "02arkqv0xzmxmpcdmmki2r2bpdk3kzrgllnm36pmr8dw6gw52pjl"))))
;;     (build-system dune-build-system)
;;     (propagated-inputs
;;      `(("ocaml-ocplib-endian" ,ocaml-ocplib-endian)
;;        ("ocaml-cmdliner" ,ocaml-cmdliner)
;;        ("ocaml-afl-persistent" ,ocaml-afl-persistent)))
;;     (native-inputs
;;      `(("ocaml-calendar" ,ocaml-calendar)
;;        ("ocaml-fpath" ,ocaml-fpath)
;;        ("ocaml-uucp" ,ocaml-uucp)
;;        ("ocaml-uunf" ,ocaml-uunf)
;;        ("ocaml-uutf" ,ocaml-uutf)))
;;     (home-page "https://github.com/stedolan/crowbar")
;;     (synopsis "Write tests, let a fuzzer find failing cases")
;;     (description
;;      "Crowbar is a library for testing code, combining QuickCheck-style
;; property-based testing and the magical bug-finding powers of
;; [afl-fuzz](http://lcamtuf.coredump.cx/afl/).")
;;     (license license:expat)))
;; 
;; (define-public ocaml-afl-persistent
;;   (package
;;     (name "ocaml-afl-persistent")
;;     (version "1.3")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri "https://github.com/stedolan/ocaml-afl-persistent/archive/v1.3.tar.gz")
;;        (sha256
;;         (base32
;;          "0p8flm9h2qj6fc3j4qn727mkwc5v00kxslcrdcafx9s8jlxw8j0i"))))
;;     (build-system ocaml-build-system)
;;     (home-page
;;      "https://github.com/stedolan/ocaml-afl-persistent")
;;     (synopsis "Use afl-fuzz in persistent mode")
;;     (description
;;      "@code{afl-persistent} allows one run @code{afl-fuzz} in
;; ``persistent mode'', which avoids repeated forking and is much
;; faster.")
;;     (license license:expat)))
;; 
;; (define-public ocaml-asn1-combinators
;;   (package
;;     (name "ocaml-asn1-combinators")
;;     (version "0.2.5")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri "https://github.com/mirleft/ocaml-asn1-combinators/releases/download/v0.2.5/asn1-combinators-v0.2.5.tbz")
;;        (sha256
;;         (base32
;;          "1pbcdwm12hnfpd1jv2b7cjfkj5r7h61xp2gr8dysb8waa455kwln"))))
;;     (build-system dune-build-system)
;;     (propagated-inputs
;;      `(("ocaml-cstruct" ,ocaml-cstruct)
;;        ("ocaml-zarith" ,ocaml-zarith)
;;        ("ocaml-bigarray-compat" ,ocaml-bigarray-compat)
;;        ("ocaml-stdlib-shims" ,ocaml-stdlib-shims)
;;        ("ocaml-ptime" ,ocaml-ptime)))
;;     (native-inputs
;;      `(("ocaml-alcotest" ,ocaml-alcotest)))
;;     (home-page
;;      "https://github.com/mirleft/ocaml-asn1-combinators")
;;     (synopsis "Embed typed ASN.1 grammars in OCaml")
;;     (description
;;      "@code{asn1-combinators} is a library for expressing ASN.1 in OCaml. Skip the notation
;; part of ASN.1, and embed the abstract syntax directly in the language. These
;; abstract syntax representations can be used for parsing, serialization, or
;; random testing.")
;;     (license license:isc)))
;; 
;; 
;; 
;; 
;; (define-public ocaml-domain-name
;;   (package
;;     (name "ocaml-domain-name")
;;     (version "0.3.0")
;;     (source
;;       (origin
;;         (method url-fetch)
;;         (uri "https://github.com/hannesm/domain-name/releases/download/v0.3.0/domain-name-v0.3.0.tbz")
;;         (sha256
;;           (base32
;;             "12kc9p2a2fi1ipc2hyhbzivxpph3npglxwdgvhd6v20rqqdyvnad"))))
;;     (build-system dune-build-system)
;;     (arguments
;;      '(#:test-target "."))
;;     (propagated-inputs
;;       `(("ocaml-fmt" ,ocaml-fmt)
;;         ("ocaml-astring" ,ocaml-astring)))
;;     (native-inputs
;;       `(("ocaml-alcotest" ,ocaml-alcotest)))
;;     (home-page
;;       "https://github.com/hannesm/domain-name")
;;     (synopsis "RFC 1035 Internet domain names")
;;     (description
;;       "This package provides a domain name is a sequence of labels
;; separated by dots.  Each label may contain any
;; bytes.  The length of each label may not exceed 63 charactes.  The
;; total length of a domain name is limited to 253 (byte representation
;; is 255), but other protocols (such as SMTP) may apply even smaller
;; limits.  A domain name label is case preserving, comparison is done in
;; a case insensitive manner.")
;;     (license license:isc)))
;; 
;; (define-public ocaml-macaddr
;;   (package
;;     (name "ocaml-macaddr")
;;     (version "5.1.0")
;;     (source
;;       (origin
;;         (method url-fetch)
;;         (uri "https://github.com/mirage/ocaml-ipaddr/releases/download/v5.1.0/ipaddr-v5.1.0.tbz")
;;         (sha256
;;           (base32
;;             "0nmzdy0xifnbx8k83m1g12qbshm84xzcvbhvfnq3jpqs5hi2i4vy"))))
;;     (build-system dune-build-system)
;;     (arguments
;;      '(#:package "macaddr"
;;        #:test-target "lib_test"))
;;     (native-inputs
;;       `(("ocaml-ounit" ,ocaml-ounit)
;;         ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)))
;;     (home-page "https://github.com/mirage/ocaml-ipaddr")
;;     (synopsis "Library for manipulation of MAC address representations")
;;     (description
;;       "This package provides an OCaml library for manipulation of MAC
;; address representations.  Features include:
;; 
;; @itemize
;; @item oUnit-based tests
;; @item MAC-48 (Ethernet) address support
;; @item @code{Macaddr} is a @code{Map.OrderedType}
;; @item All types have sexplib serializers/deserializers optionally via
;; the @code{Macaddr_sexp} library
;; @end itemize")
;;     (license license:isc)))
;; 
;; (define-public ocaml-ipaddr
;;   (package
;;     (inherit ocaml-macaddr)
;;     (name "ocaml-ipaddr")
;;     (arguments
;;      '(#:package "ipaddr"
;;        #:test-target "lib_test"))
;;     (propagated-inputs
;;      `(("ocaml-macaddr" ,ocaml-macaddr)
;;        ("ocaml-stdlib-shims" ,ocaml-stdlib-shims)
;;        ("ocaml-domain-name" ,ocaml-domain-name)))
;;     (native-inputs
;;      `(("ocaml-ounit" ,ocaml-ounit)
;;        ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)))
;;     (synopsis
;;      "Library for manipulation of IP (and MAC) address representations")
;;     (description
;;      "This package provides for IP and MAC address manipulation.
;; Features include:
;; 
;; @itemize
;; @item oUnit-based tests
;; @item IPv4 and IPv6 support
;; @item IPv4 and IPv6 CIDR prefix support
;; @item IPv4 and IPv6 CIDR-scoped address support
;; @item IP address scope classification
;; @item IPv4-mapped addresses in IPv6 (::ffff:0:0/96) are an embedding of IPv4
;; @item MAC-48 (Ethernet) address support
;; @item All types have sexplib serializers/deserializers
;; @end itemize")))
;; 
;; 
;; (define-public ocaml-ipaddr-cstruct
;;   (package
;;     (inherit ocaml-ipaddr)
;;     (name "ocaml-ipaddr-cstruct")
;;         (arguments
;;      '(#:package "ipaddr-cstruct"
;;        #:test-target "lib_test"))
;;     (propagated-inputs
;;       `(("ocaml-ipaddr" ,ocaml-ipaddr)
;;         ("ocaml-cstruct" ,ocaml-cstruct)))
;;     (home-page "https://github.com/mirage/ocaml-ipaddr")
;;     (synopsis
;;       "Library for manipulation of IP address representations using Cstructs")
;;     (description "This package provides Cstruct convertions for macaddr.")
;;     (license license:isc)))
;; 
;; (define-public ocaml-ipaddr-sexp
;;   (package
;;     (inherit ocaml-ipaddr)
;;     (name "ocaml-ipaddr-sexp")
;;     (arguments
;;      '(#:package "ipaddr-sexp"
;;                  #:test-target "lib_test"))
;;     (propagated-inputs
;;      `(("ocaml-ipaddr" ,ocaml-ipaddr)
;;        ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
;;        ("ocaml-sexplib0" ,ocaml-sexplib0)))
;;     (native-inputs
;;      `(("ocaml-ipaddr-cstruct" ,ocaml-ipaddr-cstruct)
;;        ("ocaml-ounit" ,ocaml-ounit)))
;;     (synopsis
;;      "Library for manipulation of IP address representations using S-exp")
;;     (description "This package provides S-exp convertions for ipaddr.")))






;;; Testing


;; (define-public ocaml-conduit-lwt-unix
;;   (package
;;     (inherit ocaml-conduit)
;;     (name "ocaml-conduit-lwt-unix")
;;     (arguments
;;      '(#:package "conduit-lwt-unix"
;;                  #:test-target "tests"))
;;   (propagated-inputs
;;     `(("ocaml-logs" ,ocaml-logs)
;;       ("ocaml-ppx-sexp-conv" ,ocaml-ppx-sexp-conv)
;;       ("ocaml-conduit-lwt" ,ocaml-conduit-lwt)
;;       ("ocaml-lwt" ,ocaml-lwt)
;;       ("ocaml-uri" ,ocaml-uri)
;;       ("ocaml-ipaddr" ,ocaml-ipaddr)
;;       ("ocaml-ipaddr-sexp" ,ocaml-ipaddr-sexp)
;;       ("ocaml-ca-certs" ,ocaml-ca-certs)))
;;   (native-inputs
;;     `(("ocaml-lwt-log" ,ocaml-lwt-log)
;;       ("ocaml-ssl" ,ocaml-ssl)
;;       ("ocaml-lwt-ssl" ,ocaml-lwt-ssl)))
;;     (home-page "https://github.com/mirage/ocaml-conduit")
;;     (synopsis "Portable network connection establishment library using Lwt")
;;     (description
;;      "This package provides the portable Lwt Unix implementation for Conduit.")
;;     (license license:isc)))
;; 
;; 
;; 
;; 
;; (define-public ocaml-charinfo-width
;;   (package
;;     (name "ocaml-charinfo-width")
;;     (version "1.1.0")
;;     (source (origin
;;               (method git-fetch)
;;               (uri (git-reference
;;                     (url "https://github.com/kandu/charInfo_width")
;;                     (commit version)))
;;               (file-name (git-file-name name version))
;;               (sha256
;;                (base32
;;                 "1ypsk8144gn2vc8ivhn60cq2651ay4zi5qf7r8q0bha2b5cbhpng"))))
;;     (build-system dune-build-system)
;;     (propagated-inputs
;;      `(("ocaml-result" ,ocaml-result)
;;        ("ocaml-camomile" ,ocaml-camomile)))
;;     (native-inputs
;;      `(("ocaml-ppx-expect" ,ocaml-ppx-expect)))
;;     (properties
;;      `((upstream-name . "charInfo_width")))
;;     (home-page "https://github.com/kandu/charInfo_width")
;;     (synopsis "Determine column width for a character")
;;     (description "This module is implements purely in OCaml a character width
;; function that follows the prototype of POSIX's wcwidth.")
;;     (license license:expat)))
;; 
;; (define-public ocaml-zed
;;   (package
;;     (name "ocaml-zed")
;;     (version "3.1.0")
;;     (source
;;      (origin
;;        (method git-fetch)
;;        (uri (git-reference
;;              (url "https://github.com/diml/zed")
;;              (commit version)))
;;        (file-name (git-file-name name version))
;;        (sha256
;;         (base32 "04vr1a94imsghm98iigc35rhifsz0rh3qz2qm0wam2wvp6vmrx0p"))))
;;     (build-system dune-build-system)
;;     (arguments
;;      `(#:test-target "."))
;;     (propagated-inputs
;;      `(("ocaml-camomile" ,ocaml-camomile)
;;        ("ocaml-charinfo-width" ,ocaml-charinfo-width)
;;        ("ocaml-react" ,ocaml-react)))
;;     (home-page "https://github.com/diml/zed")
;;     (synopsis "Abstract engine for text editing in OCaml")
;;     (description "Zed is an abstract engine for text edition.  It can be used
;; to write text editors, edition widgets, readlines, etc.  You just have to
;; connect an engine to your inputs and rendering functions to get an editor.")
;;     (license license:bsd-3)))
;; 
;; (define-public ocaml-lambda-term
;;   (package
;;     (name "ocaml-lambda-term")
;;     (version "3.1.0")
;;     (source
;;      (origin
;;        (method git-fetch)
;;        (uri (git-reference
;;              (url "https://github.com/diml/lambda-term")
;;              (commit version)))
;;        (file-name (git-file-name name version))
;;        (sha256
;;         (base32 "1k0ykiz0vhpyyj9fkss29ajas4fh1xh449j702xkvayqipzj1mkg"))))
;;     (build-system dune-build-system)
;;     (arguments
;;      `(#:build-flags (list "--profile" "release")
;;        #:tests? #f))
;;     (propagated-inputs
;;      `(("ocaml-lwt" ,ocaml-lwt)
;;        ("ocaml-lwt-log" ,ocaml-lwt-log)
;;        ("ocaml-lwt-react" ,ocaml-lwt-react)
;;        ("ocaml-zed" ,ocaml-zed)
;;        ("ocaml-mew-vi" ,ocaml-mew-vi)))
;;     (home-page "https://github.com/diml/lambda-term")
;;     (synopsis "Terminal manipulation library for OCaml")
;;     (description "Lambda-Term is a cross-platform library for manipulating the
;; terminal.  It provides an abstraction for keys, mouse events, colors, as well as
;; a set of widgets to write curses-like applications.  The main objective of
;; Lambda-Term is to provide a higher level functional interface to terminal
;; manipulation than, for example, ncurses, by providing a native OCaml interface
;; instead of bindings to a C library.")
;;     (license license:bsd-3)))
;; 
;; (define-public ocaml-trie
;;   (package
;;     (name "ocaml-trie")
;;     (version "1.0.0")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;               (url "https://github.com/kandu/trie/")
;;               (commit version)))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32
;;             "0s7p9swjqjsqddylmgid6cv263ggq7pmb734z4k84yfcrgb6kg4g"))))
;;     (build-system dune-build-system)
;;     (arguments
;;      ;; No tests.
;;      '(#:tests? #f))
;;     (home-page "https://github.com/kandu/trie/")
;;     (synopsis "Strict impure trie tree")
;;     (description
;;      "This package provides strict impure trie tree data structure.")
;;     (license license:expat)))
;; 
;; (define-public ocaml-mew
;;   (package
;;     (name "ocaml-mew")
;;     (version "0.1.0")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;               (url "https://github.com/kandu/mew")
;;               (commit version)))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32
;;             "0417xsghj92v3xa5q4dk4nzf2r4mylrx2fd18i7cg3nzja65nia2"))))
;;     (build-system dune-build-system)
;;     (native-inputs
;;      `(("ocaml-ppx-expect" ,ocaml-ppx-expect)))
;;     (propagated-inputs
;;       `(("ocaml-result" ,ocaml-result)
;;         ("ocaml-trie" ,ocaml-trie)))
;;     (home-page "https://github.com/kandu/mew")
;;     (synopsis "Modal editing witch")
;;     (description
;;       "This package provides a general modal editing engine generator.")
;;     (license license:expat)))
;; 
;; (define-public ocaml-mew-vi
;;   (package
;;     (name "ocaml-mew-vi")
;;     (version "0.5.0")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;               (url "https://github.com/kandu/mew_vi")
;;               (commit version)))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32
;;             "0lihbf822k5zasl60w5mhwmdkljlq49c9saayrws7g4qc1j353r8"))))
;;     (build-system dune-build-system)
;;     (native-inputs
;;      `(("ocaml-ppx-expect" ,ocaml-ppx-expect)))
;;     (propagated-inputs
;;       `(("ocaml-mew" ,ocaml-mew)
;;         ("ocaml-react" ,ocaml-react)))
;;     (properties `((upstream-name . "mew_vi")))
;;     (home-page "https://github.com/kandu/mew_vi")
;;     (synopsis "Modal editing witch, VI interpreter")
;;     (description
;;      "This package provides a vi-like modal editing engine generator.")
;;     (license license:expat)))
;; 
;; (define-public ocaml-utop
;;   (package
;;     (name "ocaml-utop")
;;     (version "2.8.0")
;;     (source
;;      (origin
;;        (method git-fetch)
;;        (uri (git-reference
;;              (url "https://github.com/ocaml-community/utop")
;;              (commit version)))
;;        (file-name (git-file-name name version))
;;        (sha256
;;         (base32 "1zf4hg33sblzh2f65vk0292jg4jlwa8702kfwpsg1kcg4w6nsfdp"))))
;;     (build-system dune-build-system)
;;     (arguments
;;      `(#:test-target "."))
;;     (native-inputs
;;      `(("ocaml-cppo" ,ocaml-cppo)))
;;     (propagated-inputs
;;      `(("ocaml-lambda-term" ,ocaml-lambda-term)
;;        ("ocaml-lwt" ,ocaml-lwt)
;;        ("ocaml-lwt-react" ,ocaml-lwt-react)
;;        ("ocaml-react" ,ocaml-react)
;;        ("ocaml-camomile" ,ocaml-camomile)
;;        ("ocaml-zed" ,ocaml-zed)))
;;     (home-page "https://github.com/ocaml-community/utop")
;;     (synopsis "Improved interface to the OCaml toplevel")
;;     (description "UTop is an improved toplevel for OCaml.  It can run in a
;; terminal or in Emacs.  It supports line editing, history, real-time and context
;; sensitive completion, colors, and more.")
;;     (license license:bsd-3)))
;; 
;; 
;; 
;; 
;; ;;; ocaml-spin
;; 
;; (define-public ocaml-spin
;;   (package
;;     (name "ocaml-spin")
;;     (version "0.8.3")
;;     (source
;;      (origin
;;        (method url-fetch)
;;        (uri (git-reference
;;              (url "https://github.com/tmattio/spin")
;;              (commit version)))
;;        (file-name (git-file-name name version))
;;        (sha256
;;         (base32
;;          "1dpnn6bj5cnqqhkrji7in2si9griw772b93vskc9d9yci4xrvvzf"))))
;;     (build-system dune-build-system)
;;     (propagated-inputs
;;      `(("ocaml-odoc" ,ocaml-odoc)
;;        ("ocaml-sexplib" ,ocaml-sexplib)
;;        ("ocaml-spawn" ,ocaml-spawn)
;;        ("ocaml-jingoo" ,ocaml-jingoo)
;;        ("ocaml-fmt" ,ocaml-fmt)
;;        ("ocaml-fpath" ,ocaml-fpath)
;;        ("ocaml-cmdliner" ,ocaml-cmdliner)
;;        ("ocaml-logs" ,ocaml-logs)))
;;     (native-inputs
;;      `(("ocaml-alcotest" ,ocaml-alcotest)
;;        ("js-of-ocaml" ,js-of-ocaml)
;;        ("ocaml-ppxlib" ,ocaml-ppxlib)
;;        ("ocaml-ctypes" ,ocaml-ctypes)
;;        ("ocaml-crunch" ,ocaml-crunch)))
;;     (home-page "https://github.com/tmattio/spin")
;;     (synopsis "OCaml project generator")
;;     (description
;;      "This package provides a program for generating an OCaml project
;; template.")
;;     (license license:isc)))
;; 
;; (define-public ocaml-crunch
;;   (package
;;     (name "ocaml-crunch")
;;     (version "3.2.0")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;               (url "https://github.com/mirage/ocaml-crunch")
;;               (commit (string-append "v" version))))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32
;;             "1pn6x2978fxxdxdmwvhynhf6x30n9mp09h5mjg8ksr5bhsxlw6ha"))))
;;     (build-system dune-build-system)
;;     (propagated-inputs
;;       `(("ocaml-cmdliner" ,ocaml-cmdliner)
;;         ("ocaml-ptime" ,ocaml-ptime)))
;;     (native-inputs
;;       `(("ocaml-lwt" ,ocaml-lwt)
;;         ("ocaml-mirage-kv" ,ocaml-mirage-kv)
;;         ("ocaml-mirage-kv-mem" ,ocaml-mirage-kv-mem)))
;;     (home-page "https://github.com/mirage/ocaml-crunch")
;;     (synopsis "Convert a filesystem into a static OCaml module")
;;     (description
;;      "@code{ocaml-crunch} takes a directory of files and compiles them into
;; a standalone OCaml module which serves the contents directly from
;; memory.  This can be convenient for libraries that need a few embedded
;; files (such as a web server) and do not want to deal with all the
;; trouble of file configuration.")
;;     (license license:isc)))
;; 
;; (define-public ocaml-mirage-kv
;;   (package
;;     (name "ocaml-mirage-kv")
;;     (version "3.0.1")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;               (url "https://github.com/mirage/mirage-kv")
;;               (commit (string-append "v" version))))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32
;;             "1n736sjvdd8rkbc2b5jm9sn0w6hvhjycma5328r0l03v24vk5cki"))))
;;     (build-system dune-build-system)
;;     (propagated-inputs
;;       `(("ocaml-mirage-device" ,ocaml-mirage-device)
;;         ("ocaml-fmt" ,ocaml-fmt)
;;         ("ocaml-lwt" ,ocaml-lwt)))
;;     (native-inputs
;;       `(("ocaml-alcotest" ,ocaml-alcotest)))
;;     (home-page "https://github.com/mirage/mirage-kv")
;;     (synopsis "MirageOS signatures for key/value devices")
;;     (description
;;      "@code{ocaml-mirage-kv} provides the @code{Mirage_kv.RO} and
;; @code{Mirage_kv.RW} signatures the MirageOS key/value devices should
;; implement.")
;;     (license license:isc)))
;; 
;; (define-public ocaml-mirage-device
;;   (package
;;     (name "ocaml-mirage-device")
;;     (version "2.0.0")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;               (url "https://github.com/mirage/mirage-device")
;;               (commit (string-append "v" version))))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32
;;             "18alxyi6wlxqvb4lajjlbdfkgcajsmklxi9xqmpcz07j51knqa04"))))
;;     (build-system dune-build-system)
;;     (propagated-inputs
;;       `(("ocaml-fmt" ,ocaml-fmt)
;;         ("ocaml-lwt" ,ocaml-lwt)))
;;     (home-page "https://github.com/mirage/mirage-device")
;;     (synopsis "Abstract devices for MirageOS")
;;     (description
;;      "@code{ocaml-mirage-device} defines @code{Mirage_device.S}, the
;; signature for basic abstract devices for MirageOS and a
;; pretty-printing function for device errors.")
;;     (license license:isc)))
;; 
;; (define-public ocaml-mirage-kv-mem
;;   (package
;;     (name "ocaml-mirage-kv-mem")
;;     (version "3.0.0")
;;     (source
;;       (origin
;;         (method git-fetch)
;;         (uri (git-reference
;;               (url "https://github.com/mirage/mirage-kv-mem")
;;               (commit (string-append "v" version))))
;;         (file-name (git-file-name name version))
;;         (sha256
;;           (base32
;;             "13gcndrg7p351wjlr6gl6mdpp967zwj2hs3f03ai624xpxa168my"))))
;;     (build-system dune-build-system)
;;     (propagated-inputs
;;       `(("ocaml-mirage-clock" ,ocaml-mirage-clock)
;;         ("ocaml-mirage-kv" ,ocaml-mirage-kv)
;;         ("ocaml-rresult" ,ocaml-rresult)
;;         ("ocaml-fmt" ,ocaml-fmt)
;;         ("ocaml-ptime" ,ocaml-ptime)
;;         ("ocaml-mirage-clock-unix"
;;          ,ocaml-mirage-clock-unix)))
;;     (native-inputs
;;       `(("ocaml-alcotest" ,ocaml-alcotest)
;;         ("ocaml-ppx-deriving" ,ocaml-ppx-deriving)))
;;     (home-page "https://github.com/mirage/mirage-kv-mem")
;;     (synopsis "In-memory key value store for MirageOS")
;;     (description
;;      "This OCaml package provides an in-memory key value store implementing
;; the @code{mirage-kv-lwt} interface.")
;;     (license license:isc)))
;; 
;; ocaml-crunch

D yoctocell/gnu/packages/purescript.scm => yoctocell/gnu/packages/purescript.scm +0 -77
@@ 1,77 0,0 @@
(define-module (yoctocell gnu packages purescript)
  #:use-module (gnu packages)
  #:use-module (gnu packages haskell-xyz)
  #:use-module (gnu packages haskell-check)
  #:use-module (gnu packages haskell-crypto)
  #:use-module (gnu packages haskell-web)
  #:use-module (gnu packages purescript)
  #:use-module ((gnu packages python) #:select (python))
  #:use-module (guix download)
  #:use-module (guix git-download)
  #:use-module (guix packages)
  #:use-module (guix build-system haskell)
  #:use-module ((guix licenses) #:prefix license:))


;; (define-public spago
;;   (name "spago")
;;   (version "0.20.3")
;;   (source
;;    (origin (method git-fetch)
;;            (uri (git-reference
;;                  (url "https://github.com/purescript/spago")
;;                  (commit version)))
;;            (file-name (git-file-name name version))
;;            (sha256
;;             (base32 ""))))
;;   (build-system haskell-build-system)
;;   (inputs
;;    `(("ghc-glob" ,ghc-glob)
;;      ("ghc-aeson" ,ghc-aeson)
;;      ("ghc-aeson-pretty" ,ghc-aeson-pretty)
;;      ("ghc-ansi-terminal" ,ghc-ansi-terminal)
;;      ("ghc-async-pool" ,ghc-async-pool)
;;      ("ghc-bower-json" ,ghc-bower-json)
;;      , "ghc- bytestring"
;;        , "ghc- containers"
;;          , "ghc- cryptonite"
;;            , "ghc- dhall" >=1.38.0
;;              , "ghc- directory" >=1.3.4.0
;;                , "ghc- either"
;;                  , "ghc- file-embed"
;;                    , "ghc- filepath"
;;                      , "ghc- foldl"
;;                        , "ghc- fsnotify"
;;                          , "ghc- generic-lens"
;;                            , "ghc- http-client"
;;                              , "ghc- http-conduit"
;;                           , "ghc- http-types"
;;                             , "ghc- lens-family-core"
;;                               , "ghc- megaparsec"
;;                                 , "ghc- mtl"
;;                                   , "ghc- network-uri"
;;                                     , "ghc- open-browser"
;;                                       , "ghc- optparse-applicative"
;;                                         , "ghc- prettyprinter"
;;                                           , "ghc- process"
;;                                             , "ghc- retry"
;;                                               , "ghc- rio" >=0.1.16.0
;;                                                 , "ghc- rio-orphans"
;;                                                   , "ghc- safe"
;;                                                     , "ghc- semver-range"
;;                                                       , "ghc- stm"
;;                                                         , "ghc- stringsearch"
;;                                                           , "ghc- tar"
;;                                                             , "ghc- template-haskell"
;;                                                               , "ghc- temporary"
;;                                                                 , "ghc- text" <1.3
;;                                                                   , "ghc- time"
;;                                                                                      , "ghc- transformers"
;;                                                                                        , "ghc- turtle"
;;                                                                                          , "ghc- unliftio"
;;                                                                                            , "ghc- unordered-containers"
;;                                                                                              , "ghc- utf8-string"
;;                                                                                                , "ghc- versions"
;;                                                                                                  , "ghc- with-utf8"
;;                                                                                                    , "ghc- zlib"
;; )))