forked from rescript-lang/rescript
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathbytesLabels.mli
215 lines (162 loc) · 8.28 KB
/
bytesLabels.mli
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
(***********************************************************************)
(* *)
(* OCaml *)
(* *)
(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
(* *)
(* Copyright 1996 Institut National de Recherche en Informatique et *)
(* en Automatique. All rights reserved. This file is distributed *)
(* under the terms of the GNU Library General Public License, with *)
(* the special exception on linking described in file ../LICENSE. *)
(* *)
(***********************************************************************)
(** Byte sequence operations.
@since 4.02.0
*)
external length : bytes -> int = "%bytes_length"
(** Return the length (number of bytes) of the argument. *)
external get : bytes -> int -> char = "%bytes_safe_get"
(** [get s n] returns the byte at index [n] in argument [s].
Raise [Invalid_argument] if [n] not a valid index in [s]. *)
external set : bytes -> int -> char -> unit = "%bytes_safe_set"
(** [set s n c] modifies [s] in place, replacing the byte at index [n]
with [c].
Raise [Invalid_argument] if [n] is not a valid index in [s]. *)
external create : int -> bytes = "caml_create_string"
(** [create n] returns a new byte sequence of length [n]. The
sequence is uninitialized and contains arbitrary bytes.
Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *)
val make : int -> char -> bytes
(** [make n c] returns a new byte sequence of length [n], filled with
the byte [c].
Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *)
val init : int -> f:(int -> char) -> bytes
(** [init n f] returns a fresh byte sequence of length [n],
with character [i] initialized to the result of [f i].
Raise [Invalid_argument] if [n < 0] or [n > ]{!Sys.max_string_length}. *)
val empty : bytes
(** A byte sequence of size 0. *)
val copy : bytes -> bytes
(** Return a new byte sequence that contains the same bytes as the
argument. *)
val of_string : string -> bytes
(** Return a new byte sequence that contains the same bytes as the
given string. *)
val to_string : bytes -> string
(** Return a new string that contains the same bytes as the given byte
sequence. *)
val sub : bytes -> pos:int -> len:int -> bytes
(** [sub s start len] returns a new byte sequence of length [len],
containing the subsequence of [s] that starts at position [start]
and has length [len].
Raise [Invalid_argument] if [start] and [len] do not designate a
valid range of [s]. *)
val sub_string : bytes -> int -> int -> string
(** Same as [sub] but return a string instead of a byte sequence. *)
val fill : bytes -> pos:int -> len:int -> char -> unit
(** [fill s start len c] modifies [s] in place, replacing [len]
characters with [c], starting at [start].
Raise [Invalid_argument] if [start] and [len] do not designate a
valid range of [s]. *)
val blit :
src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int
-> unit
(** [blit src srcoff dst dstoff len] copies [len] bytes from sequence
[src], starting at index [srcoff], to sequence [dst], starting at
index [dstoff]. It works correctly even if [src] and [dst] are the
same byte sequence, and the source and destination intervals
overlap.
Raise [Invalid_argument] if [srcoff] and [len] do not
designate a valid range of [src], or if [dstoff] and [len]
do not designate a valid range of [dst]. *)
val concat : sep:bytes -> bytes list -> bytes
(** [concat sep sl] concatenates the list of byte sequences [sl],
inserting the separator byte sequence [sep] between each, and
returns the result as a new byte sequence. *)
val iter : f:(char -> unit) -> bytes -> unit
(** [iter f s] applies function [f] in turn to all the bytes of [s].
It is equivalent to [f (get s 0); f (get s 1); ...; f (get s
(length s - 1)); ()]. *)
val iteri : f:(int -> char -> unit) -> bytes -> unit
(** Same as {!Bytes.iter}, but the function is applied to the index of
the byte as first argument and the byte itself as second
argument. *)
val map : f:(char -> char) -> bytes -> bytes
(** [map f s] applies function [f] in turn to all the bytes of [s] and
stores the resulting bytes in a new sequence that is returned as
the result. *)
val mapi : f:(int -> char -> char) -> bytes -> bytes
(** [mapi f s] calls [f] with each character of [s] and its
index (in increasing index order) and stores the resulting bytes
in a new sequence that is returned as the result. *)
val trim : bytes -> bytes
(** Return a copy of the argument, without leading and trailing
whitespace. The bytes regarded as whitespace are the ASCII
characters [' '], ['\012'], ['\n'], ['\r'], and ['\t']. *)
val escaped : bytes -> bytes
(** Return a copy of the argument, with special characters represented
by escape sequences, following the lexical conventions of OCaml. *)
val index : bytes -> char -> int
(** [index s c] returns the index of the first occurrence of byte [c]
in [s].
Raise [Not_found] if [c] does not occur in [s]. *)
val rindex : bytes -> char -> int
(** [rindex s c] returns the index of the last occurrence of byte [c]
in [s].
Raise [Not_found] if [c] does not occur in [s]. *)
val index_from : bytes -> int -> char -> int
(** [index_from s i c] returns the index of the first occurrence of
byte [c] in [s] after position [i]. [Bytes.index s c] is
equivalent to [Bytes.index_from s 0 c].
Raise [Invalid_argument] if [i] is not a valid position in [s].
Raise [Not_found] if [c] does not occur in [s] after position [i]. *)
val rindex_from : bytes -> int -> char -> int
(** [rindex_from s i c] returns the index of the last occurrence of
byte [c] in [s] before position [i+1]. [rindex s c] is equivalent
to [rindex_from s (Bytes.length s - 1) c].
Raise [Invalid_argument] if [i+1] is not a valid position in [s].
Raise [Not_found] if [c] does not occur in [s] before position [i+1]. *)
val contains : bytes -> char -> bool
(** [contains s c] tests if byte [c] appears in [s]. *)
val contains_from : bytes -> int -> char -> bool
(** [contains_from s start c] tests if byte [c] appears in [s] after
position [start]. [contains s c] is equivalent to [contains_from
s 0 c].
Raise [Invalid_argument] if [start] is not a valid position in [s]. *)
val rcontains_from : bytes -> int -> char -> bool
(** [rcontains_from s stop c] tests if byte [c] appears in [s] before
position [stop+1].
Raise [Invalid_argument] if [stop < 0] or [stop+1] is not a valid
position in [s]. *)
val uppercase : bytes -> bytes
(** Return a copy of the argument, with all lowercase letters
translated to uppercase, including accented letters of the ISO
Latin-1 (8859-1) character set. *)
val lowercase : bytes -> bytes
(** Return a copy of the argument, with all uppercase letters
translated to lowercase, including accented letters of the ISO
Latin-1 (8859-1) character set. *)
val capitalize : bytes -> bytes
(** Return a copy of the argument, with the first byte set to
uppercase. *)
val uncapitalize : bytes -> bytes
(** Return a copy of the argument, with the first byte set to
lowercase. *)
type t = bytes
(** An alias for the type of byte sequences. *)
val compare: t -> t -> int
(** The comparison function for byte sequences, with the same
specification as {!Pervasives.compare}. Along with the type [t],
this function [compare] allows the module [Bytes] to be passed as
argument to the functors {!Set.Make} and {!Map.Make}. *)
(**/**)
(* The following is for system use only. Do not call directly. *)
external unsafe_get : bytes -> int -> char = "%bytes_unsafe_get"
external unsafe_set : bytes -> int -> char -> unit = "%bytes_unsafe_set"
external unsafe_blit :
src:bytes -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int ->
unit = "caml_blit_bytes" "noalloc"
external unsafe_fill :
bytes -> pos:int -> len:int -> char -> unit = "caml_fill_string" "noalloc"
val unsafe_to_string : bytes -> string
val unsafe_of_string : string -> bytes