Source file stdcompat__digest_s.ml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
module type S = sig
type t = string
(** Alias for {!Digest.t} *)

(*
module type S =
sig type t = string val hash_length : int val compare : t -> t -> int
val equal : t -> t -> bool val string : string -> t val bytes : bytes -> t
val substring : string -> int -> int -> t
val subbytes : bytes -> int -> int -> t val channel : in_channel -> int -> t
val file : string -> t val output : out_channel -> t -> unit
val input : in_channel -> t val to_hex : t -> string val of_hex : string -> t
end
*)

module type S =
sig type t = string val hash_length : int val compare : t -> t -> int
val equal : t -> t -> bool val string : string -> t
val bytes : Stdcompat__init.bytes -> t
val substring : string -> int -> int -> t
val subbytes : Stdcompat__init.bytes -> int -> int -> t
val channel : in_channel -> int -> t val file : string -> t
val output : out_channel -> t -> unit val input : in_channel -> t
val to_hex : t -> string val of_hex : string -> t end

(** @since 5.2.0:
    module type S  =
      sig
        type t = string
        val hash_length : int
        val compare : t -> t -> int
        val equal : t -> t -> bool
        val string : string -> t
        val bytes : bytes -> t
        val substring : string -> int -> int -> t
        val subbytes : bytes -> int -> int -> t
        val channel : in_channel -> int -> t
        val file : string -> t
        val output : out_channel -> t -> unit
        val input : in_channel -> t
        val to_hex : t -> string
        val of_hex : string -> t
      end
 *)

(*
module BLAKE128 = Digest.BLAKE128
*)

module BLAKE128 : S

(** @since 5.2.0: module BLAKE128 = Digest.BLAKE128
 *)

(*
module BLAKE256 = Digest.BLAKE256
*)

module BLAKE256 : S

(** @since 5.2.0: module BLAKE256 = Digest.BLAKE256
 *)

(*
module BLAKE512 = Digest.BLAKE512
*)

module BLAKE512 : S

(** @since 5.2.0: module BLAKE512 = Digest.BLAKE512
 *)

(*
module MD5 = Digest.MD5
*)

module MD5 : S

(** @since 5.2.0: module MD5 = Digest.MD5
 *)

val of_hex : string -> t
(** @since 5.2.0: val of_hex : string -> t *)

val equal : t -> t -> bool
(** @since 4.03.0: val equal : t -> t -> bool *)


val bytes : bytes -> t

(*
val bytes : Stdcompat__init.bytes -> t
*)
(** @since 4.02.0: val bytes : bytes -> t
 *)


val subbytes : bytes -> int -> int -> t

(*
val subbytes : Stdcompat__init.bytes -> int -> int -> t
*)
(** @since 4.02.0: val subbytes : bytes -> int -> int -> t
 *)

val compare : t -> t -> int
(** @since 4.00.0: val compare : t -> t -> int *)

val from_hex : string -> t
(** @since 4.00.0: val from_hex : string -> t *)

val string : string -> t
(** Alias for {!Digest.string} *)

val substring : string -> int -> int -> t
(** Alias for {!Digest.substring} *)

(*
val channel : in_channel -> int -> t
*)


external channel : in_channel -> int -> t = "caml_md5_chan"

(*
external channel : in_channel -> int -> t = "md5_chan"
*)


(** @since 5.2.0: val channel : in_channel -> int -> t
@since 3.08.0: external channel : in_channel -> int -> t = "caml_md5_chan"
@since 3.07.0: external channel : in_channel -> int -> t = "md5_chan"
 *)

val file : string -> t
(** Alias for {!Digest.file} *)

val output : out_channel -> t -> unit
(** Alias for {!Digest.output} *)

val input : in_channel -> t
(** Alias for {!Digest.input} *)

val to_hex : t -> string
(** Alias for {!Digest.to_hex} *)

end