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
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
(******************************************************************************
* Core *
* *
* Copyright (C) 2008- Jane Street Holding, LLC *
* Contact: opensource@janestreet.com *
* WWW: http://www.janestreet.com/ocaml *
* *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public *
* License as published by the Free Software Foundation; either *
* version 2 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this library; if not, write to the Free Software *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
* *
******************************************************************************)
(** An extension of the standard StringLabels. If you open Core.Std, you'll get
these in the String module. *)
type t = string
type identifiable = t
include Binable.S with type binable = t
include Comparable.S_binable with type comparable = t
include Container.S0 with type container = t with type elt = char
include Hashable.S_binable with type hashable = t
include Sexpable.S with type sexpable = t
include Stringable.S with type stringable = t
(* From the standard StringLabels *)
external length : t -> int = "%string_length"
external get : t -> int -> char = "%string_safe_get"
external set : t -> int -> char -> unit = "%string_safe_set"
external create : int -> t = "caml_create_string"
val make : int -> char -> t
val copy : t -> t
val init : int -> f:(int -> char) -> t
val sub : t -> pos:int -> len:int -> t
val fill : t -> pos:int -> len:int -> char -> unit
val blit : src:t -> src_pos:int -> dst:t -> dst_pos:int -> len:int -> unit
(** concatanate all strings in the list using separator [sep] (default sep "") *)
val concat : ?sep:t -> t list -> t
(* (** Like concat, but uses the Container typeclass *)
val tc_concat : (t, 'container) Container.tc -> sep:t -> 'container -> t *)
(** Warning: Only returns a copy if changes are necessary! Special characters are
represented by escape sequences, following the lexical conventions of Objective
Caml. *)
val escaped : t -> t
val contains : t -> char -> bool
val contains_from : t -> int -> char -> bool
val rcontains_from : t -> int -> char -> bool
val uppercase : t -> t
val lowercase : t -> t
val capitalize : t -> t
val uncapitalize : t -> t
val index : t -> char -> int option
val index_exn : t -> char -> int
val rindex : t -> char -> int option
val rindex_exn : t -> char -> int
val index_from : t -> int -> char -> int option
val index_from_exn : t -> int -> char -> int
val rindex_from : t -> int -> char -> int option
val rindex_from_exn : t -> int -> char -> int
(** [slice s start stop] gets a slice of [s] between [start] and [stop].
[start] and [stop] will be normalized before the access.
(viz. Core_array.normalize). *)
val slice : t -> int -> int -> t
(** Returns the reversed list of characters contained in a list. *)
val to_list_rev : t -> char list
(** [nget s i] Gets the char at normalized position [i] in [s]. *)
val nget : t -> int -> char
(** [nset s i c] Sets the char at normalized position [i] to [c]. *)
val nset : t -> int -> char -> unit
(** [is_suffix s ~suffix] returns [true] if [s] ends with [suffix]. *)
val is_suffix : t -> suffix:t -> bool
(** [is_prefix s ~prefix] returns [true] if [s] starts with [prefix]. *)
val is_prefix : t -> prefix:t -> bool
(** If the string [s] contains the character [on], then [lsplit2_exn
s ~on] returns a pair containing [s] split around the first
appearance of [on] (from the left).
@raise Not_found When [on] cannot be found in [s]
*)
val lsplit2_exn : t -> on:char -> t * t
(** If the string [s] contains the character [on], then [rsplit2_exn
s ~on] returns a pair containing [s] split around the first
appearance of [on] (from the right).
@raise Not_found When [on] cannot be found in [s]
*)
val rsplit2_exn : t -> on:char -> t * t
(** [lsplit2 line ~on] optionally returns [line] split into two strings around the
* first appearance of [on] from the left *)
val lsplit2 : t -> on:char -> (t * t) option
(** [rsplit2 line ~on] optionally returns [line] split into two strings around the
* first appearance of [on] from the right *)
val rsplit2 : t -> on:char -> (t * t) option
(** [split s ~on] @return a list of substrings of [s] that are separated by
[on]. Consecutive [on] characters will cause multiple empty strings
in the result. Splitting the empty string returns a list of the empty
string, not the empty list. *)
val split : t -> on:char -> t list
(** [split_on_chars s ~on] @return a list of all substrings of [s]
that are separated by one of the chars from [on]. [on]
are not grouped. So a grouping of [on] in the source string will
produce multiple empty string splits in the result. *)
val split_on_chars : t -> on:char list -> t list
(** [lfindi s ~f] returns the index [i] of the first character in [s]
satisfying [f i s.[i]]. *)
val lfindi : t -> f:(int -> char -> bool) -> int option
(** [rfindi s ~f] returns the index [i] of the last character in [s]
satisfying [f i s.[i]]. *)
val rfindi : t -> f:(int -> char -> bool) -> int option
(* Warning: the following strip functions have copy-on-write semantics (i.e. they may
return the same string passed in) *)
(** [lstrip s] returns a string with consecutive white space (tabs,
spaces, newlines, and carriage returns) stripped from the beginning of
[s]. *)
val lstrip : t -> t
(** [rstrip s] returns a string with consecutive white space (tabs,
spaces, newlines, and carriage returns) stripped from the end of
[s]. *)
val rstrip : t -> t
(** [strip s] returns a string with consecutive white space (tabs,
spaces, newlines, and carriage returns) stripped from the beginning
and end of [s]. *)
val strip : t -> t
(** [map f s] applies [f] to each character in [s], and returns the
resulting string. *)
val map : t -> f : (char -> char) -> t
(** [mapi f s] applies [f] to each character in [s] and its index, and returns the
resulting string. *)
val mapi : t -> f : (int -> char -> char) -> t
(** Like [map], but allows replacement of a single character with zero or two or more
characters. *)
val concat_map : ?sep:t -> t -> f : (char -> t) -> t
(** [tr target replacement s] replaces every instance of [target] in [s] with
[replacement]. *)
val tr : target : char -> replacement : char -> t -> t
(** [tr_inplace target replacement s] destructively modifies s (in place!)
replacing every instance of [target] in [s] with [replacement]. *)
val tr_inplace : target : char -> replacement : char -> t -> unit
(** [chop_suffix s ~suf] returns a copy [s] without the trailing [suff]
@raise Invalid_argument is [suff] is not a suffix of [s]
*)
val chop_suffix_exn : t -> suffix:t -> t
(** [chop_prefix s ~pref] returns a copy [s] without the leading [pref]
@raise Invalid_argument is [pref] is not a prefix of [s]
*)
val chop_prefix_exn : t -> prefix:t -> t
val chop_suffix : t -> suffix:t -> t option
val chop_prefix : t -> prefix:t -> t option
(** [suffix s n] returns the longest suffix of [s] of length less than or equal to [n] *)
val suffix : string -> int -> string
(** [prefix s n] returns the longest prefix of [s] of length less than or equal to [n] *)
val prefix : t -> int -> t
(** [drop_suffix s n] drops the longest suffix of [s] of length less than or equal to [n] *)
val drop_suffix : t -> int -> t
(** [drop_prefix s n] drops the longest prefix of [s] of length less than or equal to [n] *)
val drop_prefix : t -> int -> t
(** [concat_array sep ar] like {!String.concat}, but operates on arrays *)
val concat_array : ?sep : t -> t array -> t
(** slightly faster hash function on strings *)
val hash : t -> int
(** fast equality function on strings, doesn't use compare_val *)
val equal : t -> t -> bool
(** This has to be public for interactive top-levels. *)
val pp : Format.formatter -> t -> unit
(** [is_empty s] returns [true] iff [s] is empty (i.e. its length is 0). *)
val is_empty : t -> bool
module Infix : sig
val ( </> ) : t -> int * int -> t
end
val of_char : char -> t
|
