Index of values

mod and div operators that have the right behavior on negative numbers, that is, x % y always returns a value between 0 and y-1.

Basic operations on spans

float division of integers

t >>= f returns a computation that sequences the computations represented by two monad elements.

t >>| f is t >>= (fun a -> return (f a)).

same as Filename.concat

A 'pipe' operator.

Functions from function.ml

abbreviation zone t returns t abbreviation name such as EDT, EST, JST of given zone at the time t.

Abnormal termination

absolute value

abs_diff t1 t2 returns the absolute span of time t1 minus time t2.

Accept connections on the given socket.

Check that the process has the given permissions over the named file.

add t s adds the span s to time t and returns the resulting time.

add timer handler ?randomize ?interval span

add t s shifts the time of day t by the span s.

add t i add i to the set

add ru1 ru2 adds two rusage structures (e.g.

returns a new map with the specified new binding; if the key was already bound, its previous binding disappears.

add t v adds v to the bag t, returning an element that can later be removed from the bag.

adds the specified key and data to the tree destructively (previous t's are no longer valid) using the specified comparison function.

add_abs timer handler ?randomize ?interval time same as Timer.add, but takes an absolute time time for scheduling the event rather than a span.

add_buffer b1 b2 appends the current contents of buffer b2 at the end of buffer b1.

add_business_days t ~is_holiday n returns a business day even when n=0.

add_channel b ic n reads exactly n character from the input channel ic and stores them at the end of buffer b.

add_char b c appends the character c at the end of the buffer b.

add_months t n returns date with max days for the month if the date would be invalid.

if key is not present then add a singleton list, otherwise, cons data on the head of the existing list.

add_multi t ~key ~data if key is present in the table then cons data on the list, otherwise add key with a single element list.

add_range t i j add all the numbers between i and j (inclusive) to the set.

add_string b s appends the string s at the end of the buffer b.

add_substitute b f s appends the string pattern s at the end of the buffer b with substitution.

add_substring b s ofs len takes len characters from offset ofs in string s and appends them at the end of the buffer b.

add_weekdays t 0 returns the next weekday if t is a weekend and t otherwise.

Schedule a SIGALRM signal after the given number of seconds.

Return the total number of bytes allocated since the program was started.

Timeout

generator that always returns given value

E.g.

Array.append v1 v2 returns a fresh array containing the concatenation of the arrays v1 and v2.

apply x f run optional function on argument and return an option

Returns true iff a given set of intervals are disjoint

Returns true iff a given set of intervals would be disjoint if considered as open intervals.

The command line arguments given to the process.

A comparator that returns results in ascending order.

Printexc.get_backtrace

Respects the posix semantic.

Return a copy of the current contents of the buffer as a bigstring.

bind t f = t >>= f

Bind a socket to an address.

A special address, for use only with bind, representing all the Internet addresses that the host machine possesses.

These functions are the same as the basic functions, except that they use (and update) the given PRNG state instead of the default one.

Return 30 random bits in a nonnegative integer.

Array.blit v1 o1 v2 o2 len copies len elements from array v1, starting at element number o1, to array v2, starting at element number o2.

block_forever () will block the calling thread forever.

lock_blocking ?message path like lock, but sleeps for 1 second between lock attempts and does not return until it succeeds

blocking_create t tries to create the lock.

Random.bool () returns true or false with probability 0.5 each.

like bot_exn, but returns result optionally, without exception.

returns the bottom (most-recently enqueued element).

bound i x bounds the value x to the interval i.

call x f run optional function on argument

Warning: this function clobbers the Signal.int (SIGINT) handler.

char generator

change map key f updates the given map by changing the value stored under key according to f.

change t key f updates the given table by changing the value stored under key according to f, just like Map.change (see that for example).

Change the process working directory.

Change the current working directory of the process.

check_args ~loc ~pos ~len bstr checks the position and length arguments pos and len for bigstrings bstr.

check_heap_property h asserts that h has the heap property: that all nodes are less than their children by h's comparison function.

check_suffix name suff returns true if the filename name ends with the suffix suff.

Child process terminated

Change the permissions of the named file.

choose t returns some element in the bag.

Return the given file name without its extension.

chop_prefix s ~pref returns a copy s without the leading pref

chop_suffix name suff removes the suffix suff from the filename name.

chop_suffix s ~suf returns a copy s without the trailing suff

Change the owner uid and owner gid of the named file.

Change the process root directory.

clears the queue

clear the queue

clear t removes all elements from the list in constant time.

clear t discards all elements from t.

clear t discards all elements from t.

Empty the buffer.

clear t removes all elements from the bag.

Clear the ``close-on-exec'' flag on the given descriptor.

Clear the ``non-blocking'' flag on the given descriptor.

Close a file descriptor.

we have our own version of these two, the INRIA version doesn't release the runtime lock.

Close channels opened by UnixLabels.open_process, wait for the associated command to terminate, and return its termination status.

Close channels opened by UnixLabels.open_process_full, wait for the associated command to terminate, and return its termination status.

Close channels opened by UnixLabels.open_process_in, wait for the associated command to terminate, and return its termination status.

Close channels opened by UnixLabels.open_process_out, wait for the associated command to terminate, and return its termination status.

Close a directory descriptor.

combine ar combines two arrays to an array of pairs.

Execute the given shell command and return its exit code.

Perform a full major collection and compact the heap.

Total ordering between maps.

lexicographic

compose f g x is f (g x)

concatanate all strings in the list using separator sep (default sep "")

Concatenate a list of lists.

concat p1 p2 returns a path equivalent to p1 ^ "/" ^ p2.

Same as Array.append, but concatenates a list of arrays.

concat_array sep ar like String.concat, but operates on arrays

Like map, but allows replacement of a single character with zero or two or more characters.

concat_map t ~f is concat (map t ~f), except that there is no guarantee about the order in which f is applied to the elements of t.

concat_mapi t ~f is like concat_map, but passes the index as an argument

Same as concat but faster and without preserving any ordering (ie for lists that are essentially viewed as multi-sets.

cond_pop heap cond

cond_pop_heap_el heap cond

Connect a socket to an address.

produces a function that just returns its first argument

Continue

contains_dup True if there are any two elements in the list which are the same.

Return a copy of the current contents of the buffer.

copy heap

copy t returns a copy of t.

copy t returns a copy of t.

copy t returns a copy of t.

Array.copy a returns a copy of a, that is, a fresh array containing the same elements as a.

cores ()

count f l is the number of elements in l that satisfy the predicate f.

Return (minor_words, promoted_words, major_words).

Compute the 32-bit crc

String version of the crc, encoded in hex.

create name to_sexp

create var arg creates a new t from a constr and the argument to the constr.

create v returns a new object in its own equivalence class that has value v.

create ?min_size () creates a new timer.

create maxsize returns a synchronized queue bounded to have no more than maxsize elements.

create () returns a new, unlocked mutex.

create ?pos ?len base creates a substring of the base sequence of length len starting at position pos, i.e.

lock ?message path tries to lock the file at path by creating two new files path.nfs_lock and path.nfs_lock.msg.

create ?close_on_exec ?message path tries to create a file at path containing the text message, which defaults to the pid of the locking process.

create ?min_size cmp

create () returns an empty queue.

create f creates a new force_once

For create msg z sexp_of_z, be careful to use only immutable values for z, or be aware that z will be lazily converted to a sexp at a later point in time, which will pick up the then-current state of z.

creating doubly-linked lists

Thread.create funct arg creates a new thread of control, in which the function application funct arg is executed concurrently with the other threads of the program.

create () returns an empty stack.

create () returns an empty queue.

create n x creates an array of length n with the value x populated in each element

create ~num_keys ~key_to_int returns a table where the keys can map to 0 ..

create length

create n returns a fresh buffer, initially empty.

create () returns an empty bag.

create_alarm f will arrange for f to be called at the end of each major GC cycle, starting with the current cycle or the next one.

create_bin_prot reader returns an unpacker that reads the "size-prefixed" bin_prot encoding, in which a value is encoded by first writing the length of the bin_prot data as a 64-bit int, and then writing the data itself.

create_bin_prot reader returns an unpack buffer that unpacks the "size-prefixed" bin_prot encoding, in which a value is encoded by first writing the length of the bin_prot data as a 64-bit int, and then writing the bin_prot data itself.

create_ending_after ?zone (od1, od2) ~now returns the smallest interval (t1 t2) with minimum t2 such that t2 >= now, to_ofday t1 = od1, and to_ofday t2 = od2.

create_ending_before ?zone (od1, od2) ~ubound returns the smallest interval (t1 t2) with maximum t2 such that t2 <= ubound, to_ofday t1 = od1, and to_ofday t2 = od2.

lock_exn ?message path like lock, but throws an exception when it fails to obtain the lock

create_exn ?message path is like create except that it throws an exception on failure instead of returning a boolean value

create_exn ~y ~m ~d creates the date specified in the arguments.

create_process ~prog ~args forks a new process that executes the program prog with arguments args.

create_process_env ~prog ~args ~env as create process, but takes an additional parameter that extends, or replaces the current environment.

critical_section ?message path ~f wrap function f (including exceptions escaping it) by first locking (using Lock_file.Nfs.create_exn) and then unlocking the given lock file.

The conventional name for the current directory (e.g.

current_thread_has_lock t returns true iff the current thread has t locked.

daemonize ?(redirect_stdout=`Dev_null) ?(redirect_stderr=`Dev_null) ?(cd = "/") ?umask=[0] () makes the current executing process a daemon, and dups "/dev/null", redirect_stdout, redirect_stderr to stdin/stdout/stderr.

daemonize_wait ?(cd = "/") ?(umask=0) () makes the executing process a daemon, but delays full detachment from the calling shell/process until the returned "release" closure is called.

returns list of data in map

filter_inplace t ~f removes all the elements from t that don't satisfy f.

Standard hashtbl functions.

deactivate timer deactives a timer.

debug controls whether invariants are checked at each call.

set debug := true to turn on debugging, including potentially slow invariant checking.

dedup (de-duplicate).

default_sys_behavior t Query the default system behavior for a signal.

delay d suspends the execution of the calling thread for d seconds.

delete_alarm a will stop the calls to the function associated to a.

dequeue t returns the front element of the queue.

Like dequeue_exn, but returns result optionally, without exception.

dequeue t returns None if t is empty, otherwise it removes and returns the front of t

dequeue_all t ~f dequeues every element of the queue and applies f to each one.

dequeue_exn t removes and returns the front of t, raising Empty if t is empty.

dequeue_with_key t returns the front element of the queue and its key

Return the descriptor corresponding to an input channel.

Return the descriptor corresponding to an output channel.

diff t1 t2 returns time t1 minus time t2.

diff t1 t2 returns the difference in time between two ofdays, as if they occurred on the same day

diff t1 t2 returns date t1 minus date t2 in days.

digest t return the MD5 digest of the file the t was created from (if any)

The directory separator (e.g.

See Filename.basename.

Returns version of queue with top element removed.

Return the socket domain adequate for the given socket address.

drop iovec n drops n characters from iovec.

drop_prefix s n drops the longest prefix of s of length less than or equal to n

drop_suffix s n drops the longest suffix of s of length less than or equal to n

drop_while l ~f drops the longest prefix of l for which f is true.

Return a new file descriptor referencing the same file as the given descriptor.

dup2 fd1 fd2 duplicates fd1 to fd2, closing fd2 if already opened.

The empty queue

empty the empty I/O-vector.

the empty map

empty () creates an empty array

enqueue t k v adds the key-value pair (k, v) to the end of the queue, returning `Ok if the pair was added, or `Key_already_present if there is already a (k, v') in the queue.

enqueue t x returns a queue with adds x to the end of t.

enqueue t x adds x to the end of t.

enqueue a single element on the *top* of the queue.

Return the process environment, as an array of strings with the format ``variable=value''.

equal is phys_equal

predicates

fast equality function on strings, doesn't use compare_val

equal cmp m1 m2 tests whether the maps m1 and m2 are equal, that is, contain equal keys and associate them with equal data.

toplevel binding for polymorphic equality (=).

error message value sexp_of_value constructs an Error.t and returns it as a Result.Error.

Return a string describing the given error code.

Unknown error

escape ~escapeworthy ~escape_char s is

        escape_gen_exn ~escapeworthy_map:(List.zip_exn escapeworthy escapeworthy)
          ~escape_char
      

.

escape_gen_exn escapeworthy_map escape_char returns a function that will escape a string s as follows: if (c1,c2) is in escapeworthy_map, then all occurences of c1 are replaced by escape_char concatenated to c2.

Warning: Only returns a copy if changes are necessary! Special characters are represented by escape sequences, following the lexical conventions of Objective Caml.

Return a string representing the given character, with special characters escaped following the lexical conventions of Objective Caml.

Establish a server on the given address.

eval t f evaluates the proposition t relative to an environment f that assigns truth values to base propositions.

exec ~prog ~args ?search_path ?env execs prog with args.

The name of the file containing the executable currently running.

execv prog args execute the program in file prog, with the arguments args, and the current process environment.

Same as UnixLabels.execv, except that the third argument provides the environment to the program executed.

Same as UnixLabels.execv respectively, except that the program is searched in the path.

Same as UnixLabels.execve respectively, except that the program is searched in the path.

Same as List.exists, but for a two-argument predicate.

Terminate prematurely the currently executing thread.

exit_immediately exit_code immediately calls the exit system call with the given exit code without performing any other actions (unlike Pervasives.exit).

print to stderr; exit 1

exn_if_dup ?compare ?context t ~to_sexp will run find_a_dup on t, and raise Duplicate_found if a duplicate is found.

e.g.

raises Failure

failwiths message value sexp_of_value raises an exception with the supplied message and value, by constructing an Error.t and using Error.raise.

Change the permissions of an opened file.

Change the owner uid and owner gid of an opened file.

Synchronize the kernel buffers of a given file descriptor with disk, but do not necessarily write file attributes.

feed t buf ?pos ?len adds the specified substring of buf to t's buffer.

float generator (no nan, inf, etc.)

file_descr_realpath fd

file_exists ~follow_symlinks path

Same as file_exists but blows up on `Unknown

Socket

Array.fill a ofs len x modifies the array a in place, storing x in elements number ofs to ofs + len - 1.

if res = partition_tf set ~f then fst res are the elements on which f produced true, and snd res are the elements on which f produces false

filter p l returns all the elements of the list l that satisfy the predicate p.

filter ~f array removes the elements for which f returns false.

filter_inplace t ~f removes all elements of t that don't satisfy f.

filter_inplace t ~f removes all elements of t that don't satisfy f.

returns new map with bound values filtered by f applied to the bound values

filter_map f l is the sublist of l containing only elements for which f returns Some e.

returns new map with bound values filtered by f applied to the bound values

filter_map ~f array maps f over array and filters None out of the results.

like filter_map, but function takes both key and data as arguments

filter_mapi is just like filter_map, but it also passes in the index of each element as the first argument to the mapped function.

like filter_map, but function takes both key and data as arguments

Same as filter_map but uses Array.mapi.

filter_opt l is the sublist of l containing only elements which are Some e.

filter_opt array returns a new array where None entries are omitted and Some x entries are replaced with x.

Like filter except f also receives the index.

finalise f v registers f as a finalisation function for v.

A finalisation function may call finalise_release to tell the GC that it can launch the next finalisation function without waiting for the current one to return.

find name looks up a t by its name and returns it.

returns the value bound to the given key, raising Not_found if none such exists

find t k returns Some (the current binding) of k in t, or None if no such binding exists

find ?pos ?len char t returns Some i for the smallest i >= pos such that t.{i} = char, or None if there is no such i.

if the specified key exists in the tree, return the corresponding value.

find_a_dup returns a duplicate from the list (no guarantees about which duplicate you get), or None if there are no dups.

find_default t k ~default returns the current binding of k in t, or default () if no such binding exists.

find_elt t ~f finds the first element in t that satisfies f, by testing each of element of t in turn until f succeeds.

find_elt t ~f looks at elements in the bag one-by-one until it finds one elt such that f (Elt.value elt), in which case it returns Some elt.

find_exn t ~f returns the first element of t that satisfies f.

find_exn t k returns the current binding of k in t, or raises Not_found if no such binding exists.

find_exn f t returns the first a in t for which f t.(i) is true.

find_heap_el_exn heap el

find_office office a more type-safe interface for pulling timezones related to existing Jane Street offices/locations.

find_or_add t k ~default returns the data associated with key k if it is in the table t, otherwise it lets d = default() and adds it to the table.

findi t f returns the first index i of t for which f i t.(i) is true

findi_exn t f returns the first index i of t for which f i t.(i) is true.

constant-time extraction of first and last elements.

reverse the order of arguments for a binary function

Random.float bound returns a random floating-point number between 0 (inclusive) and bound (exclusive).

flock fd cmd places or releases a lock on the fd as per the flock C call of the same name.

folds over keys and data in map

fold over the tree

List.fold2_exn f a [b1; ...; bn] [c1; ...; cn] is f (... (f (f a b1 c1) b2 c2) ...) bn cn.

fold_elt t ~init ~f is the same as fold, except f is called with the 'a Elt.t's from the list instead of the contained 'a values.

fold_elt t ~init ~f is the same as fold, except f is called with the 'a Elt.t's from the bag instead of the contained 'a values.

fold_lines ?fix_win_eol t ~init ~f folds over the lines read from t using input_line.

fold_range_inclusive t ~min ~max ~init ~f folds f (with initial value ~init) over all keys (and their associated values) that are in the range min, max (inclusive).

folds over keys and data in map in reverse order

List.fold_right f [a1; ...; an] b is f a1 (f a2 (... (f an b) ...)).

Array.fold_right f a ~init computes f a.(0) (f a.(1) ( ... (f a.(n-1) init) ...)), where n is the length of the array a.

foldi works similarly to fold, but also pass in index of each character to f

foldi is just like fold, but it also passes in the index of each element as the first argument to the folded function.

same semantics as similar functions in List

for_all2 t1 t2 ~f fails if length t1 <> length t2.

Same as List.for_all, but for a two-argument predicate.

If this is called it asserts that use_new_string_and_sexp_formats has not been called, and will cause use_new_string_and_sexp_formats to throw an exception if it is called later

force t runs the thunk if it hadn't already been forced, else it raises an exception.

forever f runs f () until it throws an exception and returns the exception.

fork () forks a new process.

fork_exec ~prog ~args ?use_path ?env () forks and execs prog with args in the child process, returning the child pid to the parent.

format t fmt formats the given time according to fmt, which follows the formatting rules given in 'man strftime'.

Arithmetic exception

Given list of (frequency,value) pairs, returns value with probability proportional to given frequency

a gen-returning version of frequency

triple handling

Return the information for the file associated with the given descriptor.

Return the information for the file associated with the given descriptor.

Truncates the file corresponding to the given descriptor to the given size.

Same as Random.init but takes more data as seed.

Do a minor collection, finish the current major collection cycle, and perform a complete new cycle.

gather_conjuncts t gathers up all toplevel conjuncts in t.

gather_disjuncts t gathers up all toplevel disjuncts in t.

Returns memoized version of any function with a single argument.

get t returns the value of the class of t.

Return the current values of the GC parameters in a control record.

Array.get a n returns the element number n of array a.

get t pos returns the character at pos

get_cmp heap

Return Some i if is_digit c and None otherwise.

Return i if is_digit c.

get_event_interval event

get_event_time event

get_opt_len bstr ~pos opt_len

get_pos_len and get_pos_len_exn are intended to be used by functions that take a sequence (array, string, bigstring, ...) and an optional pos and len specifying a subrange of the sequence.

get_process_clock the clock measuring the CPU-time of a process.

Get a sockaddr from a hostname or IP, and a port

OCaml's Random.get_state makes a copy of the default state, which is almost certainly not what you want.

get_terminal_size ()

get_thread_clock the clock measuring the CPU-time of the current thread.

get_timer event

getaddrinfo host service opts returns a list of Unix.addr_info records describing socket parameters and addresses suitable for communicating with the given host and service.

Find an entry in hosts with the given address.

Find an entry in services with the given name.

Find an entry in protocols with the given name.

Find an entry in hosts with the given name.

Find an entry in protocols with the given protocol number.

Find an entry in services with the given service number.

Return the name of the current working directory.

Return the current working directory of the process.

Return the effective group id under which the process runs.

Return the value associated to a variable in the process environment.

Return the effective user id under which the process runs.

Return the group id of the user executing the process.

Return the list of groups to which the user executing the process belongs.

Return the name of the local host.

Return the current status of the given interval timer.

Return the login name of the user executing the process.

getnameinfo addr opts returns the host name and service name corresponding to the socket address addr.

Return the address of the host connected to the given socket.

Return the pid of the process.

Return the pid of the parent process.

Return the pid of the parent process, if you're really sure you're never going to be the init process.

getpwents is a thread-safe wrapper over the low-level passwd database functions.

Return the address of the given socket.

Return the current status of a boolean-valued option in the given socket.

Same as UnixLabels.getsockopt for a socket option whose value is a floating-point number.

Same as UnixLabels.getsockopt for an integer-valued socket option.

Same as UnixLabels.getsockopt for a socket option whose value is an int option.

gettcpopt_bool sock opt

Same as Unix.time above, but with resolution better than 1 second.

Return the user id of the user executing the process.

Convert a time in seconds, as returned by UnixLabels.time, into a date and a time.

group l ~break returns a list of lists (i.e., groups) whose concatenation is equal to the original list.

if equiv is an equivalence predicate, then group_by set ~equiv produces a list of equivalence classes (i.e., a set-theoretic quotient).

This is just like group, except that you get the index in the original list of the current element along with the two elements.

handle t f is set t (`Handle f).

handle_default t is set t `Default.

handle_uncaught ~exit f catches an exception escaping f and prints an error message to stderr.

handle_unix_error f runs f () and returns the result.

slightly faster hash function on strings

Values returned by hash must be non-negative.

Return the first element of the given list.

heap_el_get_el heap_el

heap_el_is_valid heap_el

heap_el_mem heap heap_el

Hangup on controlling terminal

The identity function

Return the identifier of the given thread.

ignore t is set t `Ignore.

ignore t = map t ~f:(fun _ -> ()).

ignore () = create (fun () -> ())

ignore is the same as Pervasives.ignore.

Invalid hardware instruction

Create an input channel reading from the given descriptor.

in_channel_realpath ic

index s ~escape_char char find the first literal (not escaped) instance of char in s starting from 0.

index_from s ~escape_char pos char find the first literal (not escaped) instance of char in s starting from pos and proceeding towards the end of s.

init () pre-load all available time zones from disk, this function has no effect if it is called multiple times.

init f n is [(f 0); (f 1); ...; (f (n-1))].

init n ~f creates an array of length n where the ith element is initialized with f i (starting at zero)

init n ~f creates a bigstring t of length n, with t.{i} = f i

Initialize the generator, using the argument as a seed.

initialized_zones () returns a sorted list of time zone names that have been loaded from disk thus far.

input ?min_len ic ?pos ?len bstr tries to read len bytes (guarantees to read at least min_len bytes (must be greater than or equal to zero and smaller or equal to len), if possible, before returning) from input channel ic, and writes them to bigstring bstr starting at position pos.

input_line ?fix_win_eol t reads a line from t and returns it, without the newline ("\n") character at the end, and, if fix_win_eol the trailing "\r\n" is dropped.

Completely reads an input channel and returns the results as a list of strings.

constant-time insertion of a new element.

Takes an int represented as a string ((-|+)?0-9+) and puts delimiter every 3 digits starting from the right.

Takes an int represented as a string ((-|+)?0-9+) and puts underscores every 3 digits starting from the right.

Interactive interrupt (ctrl-C)

Random.int bound returns a random integer between 0 (inclusive) and bound (exclusive).

Random.int32 bound returns a random integer between 0 (inclusive) and bound (exclusive).

Random.int64 bound returns a random integer between 0 (inclusive) and bound (exclusive).

This reference is initially set to false in standalone programs and to true if the code is being executed under the interactive toplevel system ocaml.

interruptible_pause span sleeps for span time unless interrupted (e.g.

(for profiling) decrements both when the process is running and when the system is running on behalf of the process; it sends SIGPROF when expired.

raises Invalid_arg

invariant t checks the invariants of the queue.

check invariants, raise an exception if any invariants fail

iround_nearest t rounds t to the nearest int.

iround_nearest returns None if iround_nearest_exn raises an exception

iround_towards_zero returns None if iround_towards_zero_exn raises an exception

iround_towards_zero_exn raises Invalid_argument when either trying to handle nan or trying to handle a float outside the range (-.

iround_nearest_exn raises Invalid_argument in the same cases as iround_towards_zero_exn

is_activated timer

'a' - 'z' or 'A' - 'Z'

'a' - 'z' or 'A' - 'Z' or '0' - '9'

is_char_escaped s ~escape_char pos return true if the char at pos is escaped, false otherwise.

Any char in an escaped string is either escaping, escaped or literal.

is_literal s ~escape_char pos return true if the char at pos is not escaped or escaping.

'0' - '9'

Returns `Yes if the file exists and is a directory

is_empty t returns true if t has no unconsumed bytes, and false if it does.

is_empty heap

is_empty s returns true iff s is empty (i.e.

Test whether a map is empty or not.

Returns `Yes if the file exists and is a regular file

Return true if the file name is relative and does not start with an explicit reference to the current directory (./ or ../ in Unix), false if it starts with an explicit reference to the root directory or the current directory.

includes positive and negative infinity