Extract Irmin_type and its PPX into their own new repository

Author: craigfe

.gitignore

@@ -0,0 +1,10 @@
+/_build
+/_opam
+*~
+*.install
+*.merlin
+.envrc
+\#*
+.#*
+.*.swp
+**/.DS_Store

.ocamlformat

@@ -0,0 +1,5 @@
+version = 0.15.0
+profile = conventional
+parse-docstrings
+break-infix = fit-or-vertical
+indicate-multiline-delimiters = no

LICENSE.md

@@ -0,0 +1,15 @@
+## ISC License
+
+Copyright (c) 2013-2020 Thomas Gazagnaire <[email protected]>
+
+Permission to use, copy, modify, and distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

README_PPX.md

@@ -1,16 +1,16 @@
-## ppx_irmin
+## ppx_repr
 
-PPX extension for automatically generating Irmin type representations.
+PPX extension for automatically generating type representations.
 
 ### Overview
 
-`ppx_irmin` automatically generates Irmin type representations (values of type
-`_ Irmin.Type.t`) corresponding to type declarations in your code. For example:
+`ppx_repr` automatically generates type representations (values of type
+`_ Repr.Type.t`) corresponding to type declarations in your code. For example:
 
 ```ocaml
 type 'a tree =
   | Branch of tree * bool option * tree
-  | Leaf of 'a [@@deriving irmin]
+  | Leaf of 'a [@@deriving repr]
 ```
 
 will be expanded to:
@@ -19,7 +19,7 @@ will be expanded to:
 type 'a tree = (* as above *)
 
 let tree_t leaf_t =
-  let open Irmin.Type in
+  let open Repr.Type in
   mu (fun tree_t ->
       variant "tree" (fun branch leaf -> function
           | Branch (x1, x2, x3) -> branch (x1, x2, x3)
@@ -34,36 +34,36 @@ extension point.
 
 ### Installation and usage
 
-`ppx_irmin` may be installed via [opam](https://opam.ocaml.org/):
+`ppx_repr` may be installed via [opam](https://opam.ocaml.org/):
 
 ```
-opam install ppx_irmin
+opam install ppx_repr
 ```
 
 If you're using the [dune](https://github.com/ocaml/dune) build system, add the
 following field to your `library`, `executable` or `test` stanza:
 
 ```
-(preprocess (pps ppx_irmin))
+(preprocess (pps ppx_repr))
 ```
 
-You can now use `[@@deriving irmin]` after a type declaration in your code to
-automatically derive an Irmin type representation with the same name.
+You can now use `[@@deriving repr]` after a type declaration in your code to
+automatically derive a type representation with the same name.
 
 ### Specifics
 
-`ppx_irmin` supports all of the type combinators exposed in the
-[Irmin.Type](https://docs.mirage.io/irmin/Irmin/Type/index.html) module (basic
+`ppx_repr` supports all of the type combinators exposed in the
+[Repr.Type](https://docs.mirage.io/irmin/Irmin.Type/index.html) module (basic
 types, records, variants (plain and closed polymorphic), recursive types etc.).
 Types with parameters will result in parameterised representations (i.e. type
 `'a t` is generated a representation of type `'a Type.t -> 'a t Type.t`).
 
-To supply base representations from a module other than `Irmin.Type` (such as
-when `Irmin.Type` is aliased to a different module path), the `lib` argument
-can be passed to `@@deriving irmin`:
+To supply base representations from a module other than `Repr.Type` (such as
+when `Repr.Type` is aliased to a different module path), the `lib` argument
+can be passed to `@@deriving repr`:
 
 ```ocaml
-type foo = unit [@@deriving irmin { lib = Some "Mylib.Types" }]
+type foo = unit [@@deriving repr { lib = Some "Mylib.Types" }]
 
 (* generates the value *)
 val foo_t = Mylib.Types.unit
@@ -79,50 +79,50 @@ type-name is `t`, in which case the representation is simply `t`. This
 behaviour can be overridden using the `name` argument, as in:
 
 ```ocaml
-type foo = string list * int32 [@@deriving irmin { name = "foo_repr" }]
+type foo = string list * int32 [@@deriving repr { name = "foo_repr" }]
 
 (* generates the value *)
-val foo_repr = Irmin.Type.(pair (list string) int32)
+val foo_repr = Repr.Type.(pair (list string) int32)
 ```
 
-If the type contains an abstract type, `ppx_irmin` will expect to find a
+If the type contains an abstract type, `ppx_repr` will expect to find a
 corresponding type representation using its own naming rules. This can be
 overridden using the `[@repr ...]` attribute, as in:
 
 ```ocaml
-type bar = (foo [@repr foo_repr], string) result [@@deriving irmin]
+type bar = (foo [@repr foo_repr], string) result [@@deriving repr]
 
 (* generates the value *)
-val bar_t = Irmin.Type.(result foo_repr string)
+val bar_t = Repr.Type.(result foo_repr string)
 ```
 
 Built-in abstract types such as `unit` are assumed to be represented in
-`Irmin.Type`. This behaviour can be overridden with the `[@nobuiltin]`
+`Repr.Type`. This behaviour can be overridden with the `[@nobuiltin]`
 attribute:
 
 ```ocaml
-type t = unit [@nobuiltin] [@@deriving irmin]
+type t = unit [@nobuiltin] [@@deriving repr]
 
 (* generates the value *)
-let t = unit_t (* not [Irmin.Type.unit] *)
+let t = unit_t (* not [Repr.Type.unit] *)
 ```
 
 #### Signature type definitions
 
-The `ppx_irmin` deriver can also be used in signatures to expose the
+The `ppx_repr` deriver can also be used in signatures to expose the
 auto-generated value:
 
 ```ocaml
 module Contents : sig
-  type t = int32 [@@deriving irmin]
+  type t = int32 [@@deriving repr]
 
   (* exposes repr in signature *)
-  val t : t Irmin.Type.t
+  val t : t Repr.Type.t
 
 end = struct
-  type t = int32 [@@deriving irmin]
+  type t = int32 [@@deriving repr]
 
   (* generates repr value *)
-  val t = Irmin.Type.int32
+  val t = Repr.Type.int32
 end
 ```

bench/irmin/dune renamed to bench/dune

@@ -1,19 +1,19 @@
 (executable
  (name main)
- (libraries irmin bechamel fpath yojson ppx_deriving_yojson.runtime unix)
+ (libraries repr bechamel fpath yojson ppx_deriving_yojson.runtime unix)
  (preprocess
-  (pps ppx_irmin ppx_deriving_yojson)))
+  (pps ppx_repr ppx_deriving_yojson)))
 
 (rule
  (alias bench)
- (package irmin-bench)
+ (package repr-bench)
  (deps main.exe)
  (action (progn)))
 
 ;; Require [main.ml] to compile during tests
 
 (rule
  (alias runtest)
- (package irmin-bench)
+ (package repr-bench)
  (deps main.exe)
  (action progn))

bench/irmin/main.ml renamed to bench/main.ml

@@ -1,7 +1,6 @@
 open Bechamel
 open Toolkit
-module T = Irmin.Type
-module Hash = Irmin.Hash.BLAKE2B
+module T = Repr.Type
 open Output
 
 module Generic_op = struct
@@ -96,10 +95,10 @@ module Faker = struct
   let triple a b c () = (a (), b (), c ())
 
   type record = { foo : string; bar : int64; baz : bool * unit }
-  [@@deriving irmin]
+  [@@deriving repr]
 
   type variant = Foo of string | Bar of int64 | Baz of bool * unit
-  [@@deriving irmin]
+  [@@deriving repr]
 
   let record () =
     { foo = string 10 (); bar = int64 (); baz = (bool (), unit ()) }
@@ -117,9 +116,9 @@ module Faker = struct
 
   let fixed_string () = string 5 ()
 
-  type 'a node = { left : 'a; v : fixed_string; right : 'a } [@@deriving irmin]
+  type 'a node = { left : 'a; v : fixed_string; right : 'a } [@@deriving repr]
 
-  type tree = Branch of tree node | Leaf of int [@@deriving irmin]
+  type tree = Branch of tree node | Leaf of int [@@deriving repr]
 
   let tree () =
     let rec inner depth =
@@ -164,9 +163,6 @@ module Data = struct
 
     let bool = mk_data T.bool Faker.bool
 
-    let hash =
-      mk_data Hash.t (fun () -> Hash.hash (fun f -> f (Faker.string 1024 ())))
-
     let string_1024 = mk_data T.string Faker.(string 1024)
 
     let bytes_1024 = mk_data T.bytes Faker.(bytes 1024)
@@ -239,7 +235,6 @@ let test_operation ~name (op : Generic_op.t) =
           test ~name:"short (8 <= b <= 15)" Data.short_int;
           test ~name:"long (16 <= b <= 32)" Data.long_int;
         ];
-      test ~name:"hash" Data.hash;
       test ~name:"string<1024>" Data.string_1024;
       test ~name:"bytes<1024>" Data.bytes_1024;
       test ~name:"int32" Data.int32;

bench/irmin/main.mli renamed to bench/main.mli

@@ -0,0 +1,59 @@
+(lang dune 2.7)
+(generate_opam_files true)
+(allow_approximate_merlin)
+
+(name repr)
+(source (github mirage/repr))
+(license ISC)
+(authors "Thomas Gazagnaire")
+(maintainers "[email protected]")
+
+(package
+ (name repr)
+ (depends
+  (ocaml (>= 4.08.0))
+  (fmt (>= 0.8.0))
+  uutf
+  (jsonm (>= 1.0.0))
+  (base64 (>= 2.0.0))
+  (alcotest (and (>= 1.1.0) :with-test)))
+ (synopsis "Dynamic type representaitons. Provides no stability guarantee")
+ (description "\
+!!!!!!!!!!!!!!!!!!!!
+!!!!! UNSTABLE !!!!!
+!!!!!!!!!!!!!!!!!!!!
+
+This package defines a library of combinators for building dynamic type
+representations and a set of generic operations over representable types, used
+in the implementation of Irmin and related packages.
+
+It is not intended for public consumption and provides no stability guarantee.
+"))
+
+(package
+ (name ppx_repr)
+ (depends
+  (repr (= :version))
+  (ppxlib (and (>= 0.12.0) (< 0.18.0))))
+ (synopsis "PPX deriver for type representations")
+ (description "PPX deriver for type representations"))
+
+(package
+ (name repr-bench)
+ (depends
+  (repr (= :version))
+  bechamel
+  yojson
+  ppx_deriving_yojson)
+ (synopsis "Benchmarks for the `repr` package")
+ (description "Benchmarks for the `repr` package"))
+
+(package
+ (name repr-fuzz)
+ (depends
+  (repr (= :version))
+  (crowbar (= 0.2))
+  (ppxlib (and (>= 0.12.0) (< 0.18.0))))
+ (synopsis "Fuzz tests for the `repr` package")
+ (description "Fuzz tests for the `repr` package"))
+  

bench/irmin/output.ml renamed to bench/output.ml

@@ -1,21 +1,20 @@
 (executable
- (name fuzz_types)
- (libraries digestif.c crowbar irmin)
+ (name main)
+ (libraries digestif.c crowbar repr)
  (preprocess
-  (pps irmin-fuzz.rewriter)))
+  (pps repr-fuzz.rewriter)))
 
 ;; Start fuzzing when calling `dune build @fuzz`.
 
 (rule
  (alias fuzz)
  (deps
-  (source_tree ./input)
-  fuzz_types.exe)
+  (source_tree ./input))
  (action
-  (run afl-fuzz -i ./input -o output ./fuzz_types.exe @@)))
+  (run afl-fuzz -i ./input -o output %{exe:fuzz_types.exe} @@)))
 
 (rule
  (alias runtest)
- (package irmin-fuzz)
- (deps fuzz_types.exe)
+ (package repr-fuzz)
+ (deps main.exe)
  (action progn))