printf function, prints to the standard output stdout , i.e.
| ||
| printf [BatFormat] |
Same as
fprintf above, but output on std_formatter .
| ||
| println [BatString.Cap] | |||
| println [BatString] |
Print a string, end the line.
| ||
| printn [BatTuple.Tuple5] | |||
| printn [BatTuple.Tuple4] | |||
| printn [BatTuple.Tuple3] | |||
| printn [BatTuple.Tuple2] | |||
| promote [BatDllist] | promote n Swaps n with next n .
| ||
| protect [BatRef] |
Assign a reference temporarily.
| ||
| public_method_label [BatOo] |
As
Internal.public_method_label
| ||
| push [BatStack] | push x s adds the element x at the top of stack s .
| ||
| push [BatRefList] |
Adds an element at the head - O(1)
| ||
| push [BatQueue] | push is a synonym for add .
| ||
| push [BatPervasives] | push e x will add x at the beginning of e .
| ||
| push [BatEnum] | push e x will add x at the beginning of e .
| ||
| put [BatBitSet] | put s v n sets the nth-bit in the bitset s to v .
| ||
| putenv [BatUnix] | Unix.putenv name value sets the value associated to a
variable in the process environment.
| ||
Q | |||
| quick_stat [BatGc] |
Same as
stat except that live_words , live_blocks , free_words ,
free_blocks , largest_free , and fragments are set to 0.
| ||
| quo [BatNum] |
Additional operations
| ||
| quo_num [BatNum] | |||
| quomod_big_int [BatBig_int] |
Euclidean division of two big integers.
| ||
| quote [BatString.Cap] | |||
| quote [BatString] |
Add quotes around a string and escape any quote or escape
appearing in that string.
| ||
R | |||
| range [BatParserCo] |
Accept any element from a given range.
| ||
| range [BatList] | range 1 `To 3 = [1; 2; 3] .
| ||
| range [BatLazyList] |
Compute lazily a range of integers a ..
| ||
| range [BatEnum] | range p until:q creates an enumeration of integers [p, p+1, ..., q] .
| ||
| range [BatChar] | range from ?until produces an enumeration of the
characters from from to until included
until defaults to '\255'
| ||
| range [BatArray] | range a returns an enumeration of all valid indexes into the given
array.
| ||
| range_iter [BatText] | rangeiter f m n r applies f to all the characters whose
indices k satisfy m <= k < m + n .
| ||
| range_iteri [BatText] |
As
range_iter , but passes base + index of the character in the
subrope defined by next to arguments.
| ||
| rangeiter [BatVect] | rangeiter f m n r applies f to all the elements whose
indices k satisfy m <= k < m + n .
| ||
| ranges [BatISet] |
Returns a list of all contiguous ranges in the set
| ||
| ratio_of_num [BatNum] | |||
| raw_backtrace_length [BatPrintexc] | raw_backtrace_length bckt returns the number of slots in the
backtrace bckt .
| ||
| raw_backtrace_to_string [BatPrintexc] |
Return a string from a raw backtrace, in the same format
Printexc.get_backtrace uses.
| ||
| rchop [BatText] |
Returns the same rope but without the last character.
| ||
| rchop [BatString.Cap] | |||
| rchop [BatString] |
Returns the same string but without the last
n characters.
| ||
| rcontains_from [BatText] | rcontains_from s stop c tests if character c
appears in the subrope of s starting from the beginning
of s to index stop .
| ||
| rcontains_from [BatString.Cap] | |||
| rcontains_from [BatString] | String.rcontains_from s stop c tests if character c
appears in s before position stop+1 .
| ||
| rcontains_from [BatBytes] | rcontains_from s stop c tests if byte c appears in s before
position stop+1 .
| ||
| read [BatUnix] | read fd buff ofs len reads len characters from descriptor
fd , storing them in string buff , starting at position ofs
in string buff .
| ||
| read [BatInnerIO] |
Read a single char from an input or raise
No_more_input if
no input available.
| ||
| read [BatIO] |
Read a single char from an input or raise
No_more_input if
no input is available.
| ||
| read_all [BatText] |
Read the whole contents of a UTF-8 encoded input
| ||
| read_all [BatInnerIO] |
read all the contents of the input until
No_more_input is raised.
| ||
| read_byte [BatInnerIO] |
Read an unsigned 8-bit integer.
| ||
| read_char [BatText] |
Read one Unicode char from a UTF-8 encoded input
| ||
| read_double [BatInnerIO] |
Read an IEEE double precision floating point value.
| ||
| read_float [BatInnerIO] |
Read an IEEE single precision floating point value.
| ||
| read_i16 [BatInnerIO] |
Read a signed 16-bit word.
| ||
| read_i32 [BatInnerIO] |
Read a signed 32-bit integer.
| ||
| read_i64 [BatInnerIO] |
Read a signed 64-bit integer as an OCaml int64.
| ||
| read_line [BatText] |
Read a line of UTF-8
| ||
| read_line [BatInnerIO] |
Read a LF or CRLF terminated string.
| ||
| read_only [BatString.Cap] |
Drop capabilities to read only.
| ||
| read_only [BatHashtbl.Cap] |
Drop to read-only permissions.
| ||
| read_only [BatArray.Cap] |
Drop to read-only permissions.
| ||
| read_real_i32 [BatInnerIO] |
Read a signed 32-bit integer as an OCaml int32.
| ||
| read_signed_byte [BatInnerIO] |
Read an signed 8-bit integer.
| ||
| read_string [BatInnerIO] |
Read a null-terminated string.
| ||
| read_text [BatText] |
Read up to n chars from a UTF-8 encoded input
| ||
| read_ui16 [BatInnerIO] |
Read an unsigned 16-bit word.
| ||
| readdir [BatUnix] |
Return the next entry in a directory.
| ||
| readdir [BatSys] |
Return the names of all files present in the given directory.
| ||
| readlink [BatUnix] |
Read the contents of a link.
| ||
| really_input [BatPervasives] | really_input ic buf pos len reads len characters from channel ic ,
storing them in string buf , starting at character number pos .
| ||
| really_input [BatInnerIO] | really_input i s p l reads exactly l characters from the given input,
storing them in the string s , starting at position p .
| ||
| really_input [BatIO] | really_input i s p l reads exactly l characters from the
given input, storing them in the string s , starting at
position p .
| ||
| really_nread [BatInnerIO] | really_nread i n reads a string of exactly n characters
from the input.
| ||
| really_nread [BatIO] | really_nread i n reads a string of exactly n characters
from the input.
| ||
| really_output [BatInnerIO] | really_output o s p l writes exactly l characters from string s onto
the the output, starting with the character at offset p .
| ||
| really_output [BatIO] | really_output o s p l writes exactly l characters from string s onto
the the output, starting with the character at offset p .
| ||
| rear [BatFingerTree.S] | rear t returns None when t is empty,
or Some (init, last) where last is the last element of the
sequence and init is the rest of the sequence.
| ||
| rear [BatDeque] | rear dq returns Some (dq', x) iff x is at the rear of dq
and dq' is the rest of dq excluding x , and None if dq
has no elements.
| ||
| rear_exn [BatFingerTree.S] | rear t returns (init, last) when last is the last element of
the sequence and init is the rest of the sequence.
| ||
| record_backtrace [BatPrintexc] | Printexc.record_backtrace b turns recording of exception
backtraces on (if b = true ) or off (if b = false ).
| ||
| recv [BatUnix] |
Receive data from a connected socket.
| ||
| recvfrom [BatUnix] |
Receive data from an unconnected socket.
| ||
| reduce [BatVect] |
as
BatVect.fold_left , but no initial value - just applies reducing
function to elements from left to right.
| ||
| reduce [BatSeq.Exceptionless] | |||
| reduce [BatSeq] | reduce f (cons e s) is fold_left f e s .
| ||
| reduce [BatPervasives] |
Transformation loop on an enumeration, used to build a single value
from an enumeration.
| ||
| reduce [BatList] | List.reduce f h::t is fold_left f h t .
| ||
| reduce [BatEnum] |
A simplified version of
fold , which uses the first element
of the enumeration as a default value.
| ||
| reduce [BatArray] | Array.reduce f a is fold_left f a.(0) [|a.(1); ..; a.(n-1)|] .
| ||
| ref [BatRef] |
Return a fresh reference containing the given value.
| ||
| register_formatter [BatLogger] | register_formatter name formatter registers a named log
formatter.
| ||
| register_printer [BatPrintexc] | Printexc.register_printer fn registers fn as an exception
printer.
| ||
| relative_to_any [BatPathGen.PathType] | relative_to_any base sub returns relative path rel such that
normalize (base/:rel) = normalize sub , i.e.
| ||
| relative_to_parent [BatPathGen.PathType] | relative_to_parent parent sub returns relative path rel such that
(normalize parent)/:rel = normalize sub .
| ||
| rem [BatNativeint] |
Integer remainder.
| ||
| rem [BatInt64] |
Integer remainder.
| ||
| rem [BatInt32] |
Integer remainder.
| ||
| rem [BatInt.Safe_int] |
Integer remainder.
| ||
| rem [BatInt] |
Integer remainder.
| ||
| remove [BatVect] | remove m n r returns the vect resulting from deleting the
elements with indexes ranging from m to m + n - 1 (included)
from the original vect r .
| ||
| remove [BatText] | remove m n r returns the rope resulting from deleting the
characters with indexes ranging from m to m + n - 1 (included)
from the original rope r .
| ||
| remove [BatSys] |
Remove the given file name from the file system.
| ||
| remove [BatSet.PSet] | remove x s returns a set containing all elements of s ,
except x .
| ||
| remove [BatSet.S] | remove x s returns a set containing all elements of s ,
except x .
| ||
| remove [BatSet] | remove x s returns a set containing all elements of s ,
except x .
| ||
| remove [BatRefList] |
Remove an element from the ref list
raise
Not_found if the element is not found
| ||
| remove [BatMultiPMap] | remove k d m returns a map containing the same bindings as
m , except for k which is not bound to d anymore in the returned
map.
| ||
| remove [BatMultiMap] | remove k d m returns a map containing the same bindings as
m , except for k which is not bound to d anymore in the returned
map.
| ||
| remove [BatMap.PMap] | remove x m returns a map containing the same bindings as
m , except for x which is unbound in the returned map.
| ||
| remove [BatMap.S] | remove x m returns a map containing the same bindings as
m , except for x which is unbound in the returned map.
| ||
| remove [BatMap] | remove x m returns a map containing the same bindings as
m , except for x which is unbound in the returned map.
| ||
| remove [BatList] | remove l x returns the list l without the first element x found
or returns l if no element is equal to x .
| ||
| remove [BatLazyList] | remove l x returns the list l without the first element x found
or returns l if no element is equal to x .
| ||
| remove [BatInnerWeaktbl] | Weaktbl.remove tbl x removes the current binding of x in tbl ,
restoring the previous binding if it exists.
| ||
| remove [BatISet] |
Remove an element from the given set, returning a new set
| ||
| remove [BatIMap] |
Remove any bindings from the given value.
| ||
| remove [BatHashtbl.Cap] | |||
| remove [BatHashtbl.S] | |||
| remove [BatHashtbl] | Hashtbl.remove tbl x removes the current binding of x in tbl ,
restoring the previous binding if it exists.
| ||
| remove [BatDllist] |
Remove node from the list no matter where it is.
| ||
| remove [BatBitSet] | remove n s returns a copy of s with bit n false.
| ||
| remove_all [BatRefList] |
Remove all elements equal to the specified
element from the ref list
| ||
| remove_all [BatMultiPMap] | remove_all x m returns a map containing the same bindings as
m , except for x which is unbound in the returned map.
| ||
| remove_all [BatMultiMap] | remove_all x m returns a map containing the same bindings as
m , except for x which is unbound in the returned map.
| ||
| remove_all [BatList] | remove_all l x is similar to remove but removes all elements that
are equal to x and not only the first one.
| ||
| remove_all [BatLazyList] | remove_all l x is similar to remove but removes all elements that
are equal to x and not only the first one.
| ||
| remove_all [BatHashtbl.Cap] | |||
| remove_all [BatHashtbl.S] | |||
| remove_all [BatHashtbl] |
Remove all bindings for the given key
| ||
| remove_all_such [BatLazyList.Labels] | |||
| remove_all_such [BatLazyList] | remove_all_such f l is similar to remove but removes all elements
that satisfy the predicate f and not only the first one.
| ||
| remove_assoc [BatList] | remove_assoc a l returns the list of
pairs l without the first pair with key a , if any.
| ||
| remove_assq [BatList] |
Same as
List.remove_assoc , but uses physical equality instead
of structural equality to compare keys.
| ||
| remove_at [BatRefList.Index] |
Remove the element at the specified index
raise
Invalid_index if the index is outside 0 ; length-1
| ||
| remove_at [BatList] | remove_at i l returns the list l without the element at index i .
| ||
| remove_if [BatRefList] |
Remove the first element matching the
specified predicate
raise
Not_found if no element has been removed
| ||
| remove_if [BatList.Labels] | |||
| remove_if [BatList] | remove_if cmp l is similar to remove , but with cmp used
instead of ( = ).
| ||
| remove_if [BatLazyList.Labels] | |||
| remove_if [BatLazyList] | remove_if cmp l is similar to remove , but with cmp used
instead of ( = ).
| ||
| remove_range [BatISet] | remove_range lo hi t removes a range of elements from the given set, returning a new set
| ||
| remove_range [BatIMap] |
Remove any bindings within the given range
| ||
| rename [BatUnix] | rename old new changes the name of a file from old to new .
| ||
| rename [BatSys] |
Rename a file.
| ||
| repeat [BatString.Cap] | |||
| repeat [BatString] | repeat s n returns s ^ s ^ ... ^ s
| ||
| repeat [BatEnum] | repeat ~times:n x creates a enum sequence filled with n times of
x .
| ||
| replace [BatText] | replace ~str ~sub ~by returns a tuple constisting of a boolean
and a rope where the first occurrence of the rope sub
within str has been replaced by the rope by .
| ||
| replace [BatString.Cap] | |||
| replace [BatString] | replace ~str ~sub ~by returns a tuple consisting of a boolean
and a string where the first occurrence of the string sub
within str has been replaced by the string by .
| ||
| replace [BatInnerWeaktbl] | Weaktbl.replace tbl x y replaces the current binding of x
in tbl by a binding of x to y .
| ||
| replace [BatHashtbl.Cap.Labels] | |||
| replace [BatHashtbl.Cap] | |||
| replace [BatHashtbl.S.Labels] | |||
| replace [BatHashtbl.S] | |||
| replace [BatHashtbl.Labels] | |||
| replace [BatHashtbl] | Hashtbl.replace tbl x y replaces the current binding of x
in tbl by a binding of x to y .
| ||
| replace_chars [BatString.Cap] | |||
| replace_chars [BatString] | replace_chars f s returns a string where all chars c of s have been
replaced by the string returned by f c .
| ||
| reserved_names [BatGenlex.Languages.Definition] | |||
| reset [BatUTF8.Buf] |
Empty the buffer and de-allocate the internal storage.
| ||
| reset [BatBuffer] |
Empty the buffer and deallocate the internal string holding the
buffer contents, replacing it with the initial internal string
of length
n that was allocated by Buffer.create n .
| ||
| reshape [BatBigarray] | reshape b [|d1;...;dN|] converts the big array b to a
N -dimensional array of dimensions d1 ...
| ||
| reshape_1 [BatBigarray] |
Specialized version of
Bigarray.reshape for reshaping to
one-dimensional arrays.
| ||
| reshape_2 [BatBigarray] |
Specialized version of
Bigarray.reshape for reshaping to
two-dimensional arrays.
| ||
| reshape_3 [BatBigarray] |
Specialized version of
Bigarray.reshape for reshaping to
three-dimensional arrays.
| ||
| restart_on_EINTR [BatUnix] | restart_on_EINTR f x invokes f on x repetedly until the function returns
a value or raises another exception than EINTR.
| ||
| return [BatReturn] |
Return to a label.
| ||
| return [BatResult.Monad] |
Monadic return, just encapsulates the given value with Ok
| ||
| return [BatParserCo] |
A parser which always succeds
| ||
| return [BatOption.Monad] | return x puts a value in the Option monad, that is, returns Some x .
| ||
| return [BatInterfaces.Monad] |
Return a value, that is, put a value in the monad.
| ||
| return [BatEnum.Monad] |
This function puts a single value in the BatEnum monad, that is to say it creates an enumeration containing a single element.
| ||
| rev [BatString] | string s returns the reverse of string s
| ||
| rev [BatRefList] |
Reverses the ref list - O(n)
| ||
| rev [BatOrd] |
Reverse a given ordering.
| ||
| rev [BatList] |
List reversal.
| ||
| rev [BatLazyList] |
Eager list reversal.
| ||
| rev [BatDllist] |
List reversal.
| ||
| rev [BatDeque] | rev dq reverses dq .
| ||
| rev [BatArray.Cap] | |||
| rev [BatArray] |
Array reversal.
| ||
| rev_append [BatList] | List.rev_append l1 l2 reverses l1 and concatenates it to l2 .
| ||
| rev_append [BatLazyList] |
Eager reverse-and-append
| ||
| rev_comp [BatOrd] | |||
| rev_comp0 [BatOrd] | |||
| rev_drop [BatDllist] |
Remove node from the list no matter where it is.
| ||
| rev_enum [BatDllist] |
Create a reverse enum of the list.
| ||
| rev_in_place [BatString] | rev_in_place s mutates the string s , so that its new value is
the mirror of its old one: for instance if s contained "Example!" , after
the mutation it will contain "!elpmaxE" .
| ||
| rev_in_place [BatArray.Cap] | |||
| rev_in_place [BatArray] |
In-place array reversal.
| ||
| rev_map [BatList.Labels] | |||
| rev_map [BatList] | List.rev_map f l gives the same result as
List.rev ( List.map f l) .
| ||
| rev_map2 [BatList.Labels] | |||
| rev_map2 [BatList] | List.rev_map2 f l1 l2 gives the same result as
List.rev ( List.map2 f l1 l2) , but is tail-recursive and
more efficient.
| ||
| rev_ord [BatOrd] | |||
| rev_ord0 [BatOrd] | |||
| reverse [BatFingerTree.S] | reverse t is equivalent to of_list (List.rev (to_list t)) .
| ||
| rewinddir [BatUnix] |
Reposition the descriptor to the beginning of the directory
| ||
| rfind [BatText] | rfind s x returns the starting index of the last occurrence
of rope x within rope s .
| ||
| rfind [BatString.Cap.Exceptionless] | |||
| rfind [BatString.Cap] | |||
| rfind [BatString.Exceptionless] | rfind s x returns Some i , the starting index of the last occurrence
of string x within string s , or None if x is not a substring
of s .
| ||
| rfind [BatString] | rfind s x returns the starting index of the last occurrence
of string x within string s .
| ||
| rfind [BatRefList] |
Find the first element in the reversed ref list matching
the specified predicate
raise
Not_found if no element is found
| ||
| rfind [BatList.Labels.LExceptionless] | |||
| rfind [BatList.Labels] | |||
| rfind [BatList.Exceptionless] | rfind p l returns Some x where x is the last element of l
such
that p x returns true or None if such element as not been found.
| ||
| rfind [BatList] | rfind p l returns the last element x of l such as p x returns
true or
| ||
| rfind [BatLazyList.Labels.Exceptionless] | |||
| rfind [BatLazyList.Labels] | |||
| rfind [BatLazyList.Exceptionless] | rfind p l returns Some x where x is the last element of l such
that p x returns true or None if such element as not been found.
| ||
| rfind [BatLazyList] | rfind p l returns the last element x of l such as p x returns
true .
| ||
| rfind_exn [BatLazyList.Labels] | |||
| rfind_exn [BatLazyList] | find_exn p e l returns the last element of l such as p x
returns true or raises e if such an element has not been found.
| ||
| rfind_from [BatText] | rfind_from s ofs x behaves as rfind s x but starts searching
at offset ofs .
| ||
| rfind_from [BatString.Cap.Exceptionless] | |||
| rfind_from [BatString.Cap] | |||
| rfind_from [BatString.Exceptionless] | rfind_from s ofs x behaves as rfind s x but starts searching
at offset ofs .
| ||
| rfind_from [BatString] | rfind_from s pos x behaves as rfind s x but starts searching
from the right at position pos + 1 .
| ||
| rfindi [BatLazyList.Labels.Exceptionless] | |||
| rfindi [BatLazyList.Labels] | |||
| rfindi [BatLazyList.Exceptionless] | findi p e l returns Some (i, ai) where ai and i are respectively the
last element of l and its index, such that p i ai is true,
or None if no such element has been found.
| ||
| rfindi [BatLazyList] | findi p e l returns the last element ai of l along with its
index i such that p i ai is true.
| ||
| right [BatText] | left r len returns the rope containing the len last characters of r
| ||
| right [BatString.Cap] | |||
| right [BatString] | left r len returns the string containing the len last characters of r .
| ||
| right [BatArray] | left r len returns the array containing the len last characters of r .
| ||
| right_branch [BatAvlTree] | |||
| rindex [BatText] | Rope.rindex s c returns the position of the rightmost
occurrence of character c in rope s .
| ||
| rindex [BatSubstring] | rindex sus c returns the index of the last occurence of c in sus or
| ||
| rindex [BatString.Cap.Exceptionless] | |||
| rindex [BatString.Cap] | |||
| rindex [BatString.Exceptionless] | rindex s c returns Some p , the position of the rightmost
occurrence of character c in string s or
None if c does not occur in s .
| ||
| rindex [BatString] | String.rindex s c returns the character number of the last
occurrence of character c in string s .
| ||
| rindex [BatPathGen.StringType] | |||
| rindex [BatBytes] | rindex s c returns the index of the last occurrence of byte c
in s .
| ||
| rindex_from [BatText] |
Same as
BatText.rindex , but start
searching at the character position given as second argument.
| ||
| rindex_from [BatSubstring] | index_from sus i c returns the index of the last occurence of c in sus
before the index i or
| ||
| rindex_from [BatString.Cap.Exceptionless] | |||
| rindex_from [BatString.Cap] | |||
| rindex_from [BatString.Exceptionless] |
Same as
String.Exceptionless.rindex , but start
searching at the character position given as second argument.
| ||
| rindex_from [BatString] | String.rindex_from s i c returns the character number of the
last occurrence of character c in string s before position i+1 .
| ||
| rindex_from [BatBytes] | rindex_from s i c returns the index of the last occurrence of
byte c in s before position i+1 .
| ||
| rindex_of [BatList] | rindex_of e l returns the index of the last occurrence of e
in l , or None if there is no occurrence of e in l
| ||
| rindex_of [BatLazyList] | index_of e l returns the index of the last occurrence of e
in l , or None if there is no occurrence of e in l
| ||
| rindex_ofq [BatList] | rindex_ofq e l behaves as rindex_of e l except it uses
physical equality
| ||
| rindex_ofq [BatLazyList] | rindex_ofq e l behaves as rindex_of e l except it uses
physical equality
| ||
| rmdir [BatUnix] |
Remove an empty directory.
| ||
| root [BatPathGen.PathType] |
Root of the filesystem (
[""] ).
| ||
| root [BatFloat] | root x n calculates the nth root of x.
| ||
| root [BatAvlTree] | |||
| rope_enum [BatteriesPrint] | |||
| rope_pset [BatteriesPrint] | |||
| rotate_backward [BatDeque] |
A cyclic shift of deque elements from front to rear by one position.
| ||
| rotate_forward [BatDeque] |
A cyclic shift of deque elements from rear to front by one position.
| ||
| round [BatNum] | |||
| round [BatFloat] | round x rounds x to the nearest integral floating-point
(the nearest of floor x and ceil x ).
| ||
| round_num [BatNum] | |||
| round_to_int [BatFloat] | round_to_int x is int_of_float (round x) .
| ||
| round_to_string [BatFloat] | round_to_string ~digits:d x will return a string
representation of x -- in base 10 -- rounded to d digits
after the decimal point.
| ||
| rsplit [BatText] | rsplit s sep splits the rope s between the last
occurrence of sep .
| ||
| rsplit [BatString.Cap.Exceptionless] | |||
| rsplit [BatString.Cap] | |||
| rsplit [BatString.Exceptionless] | rsplit s sep splits the string s between the last
occurrence of sep , or returns None if the separator
is not found.
| ||
| rsplit [BatString] | rsplit s sep splits the string s between the last occurrence
of sep , and returns the two parts before and after the
occurence (excluded).
| ||
| run [BatParserCo] | run p s executes parser p on source s .
| ||
| run_and_read [BatUnix] | (stat, output) = run_and_read cmd run the command cmd
(via Unix.system) then return its exit status stat and
output string output as read from its standard output (which
was redirected to a temporary file).
| ||
S | |||
| s [BatPathGen.PathType] | |||
| sat [BatParserCo] | satisfy p accepts one value p x such that p x = true
| ||
| satisfy [BatParserCo] | satisfy p accepts one value p x such that p x = true
| ||
| saturate_of_ord [BatBounded] | saturate_of_ord ~bounds:(low, high) ord will returning a bounding
function using ord for value comparison and low and high for values
which fall outside of the requested range.
| ||
| scan [BatStream.StreamLabels] | |||
| scan [BatStream] | scan is similar to scanl but without the init value:
scanl f init [< 'e0; 'e1; 'e2; ... >] is equivalent to
[< 'e0; '(f e0 e1); '(f (f e0 e1) e2); ... >]
| ||
| scan [BatParserCo] |
Use a parser to extract list of tokens, but return
that list of tokens instead of whatever the original
parser returned.
| ||
| scan [BatEnum] | scan is similar to scanl but without the init value: if e
contains x0 , x1 , x2 ..., scan f e is the enumeration containing
x0 , f x0 x1 , f (f x0 x1) x2 ...
| ||
| scanf [BatScanf] |
Same as
Scanf.bscanf , but reads from the predefined scanning
buffer Scanf.Scanning.stdib that is connected to stdin .
| ||
| scanl [BatStream.StreamLabels] | |||
| scanl [BatStream] | scanl f init stream returns a stream of successive reduced
values from the left: scanl f init [< 'e0; 'e1; ... >] is
equivalent to
[< 'init; '(f init e0); '(f (f init e0) e1); ... >]
| ||
| scanl [BatPervasives] |
Functional loop on an enumeration, used to build an enumeration
from both an enumeration and an initial value.
| ||
| scanl [BatEnum] |
A variant of
fold producing an enumeration of its intermediate values.
| ||
| second [BatTuple.Tuple5] | |||
| second [BatTuple.Tuple4] | |||
| second [BatTuple.Tuple3] | |||
| second [BatTuple.Tuple2] |
Equivalent to
Pervasives.snd .
| ||
| select [BatUnix] |
Wait until some input/output operations become possible on
some channels.
| ||
| self_init [BatRandom] |
Initialize the generator with a more-or-less random seed chosen
in a system-dependent way.
| ||
| send [BatUnix] |
Send data over a connected socket.
| ||
| send_substring [BatUnix] |
Same as
send , but take the data from a string instead of a byte
sequence.
| ||
| sendto [BatUnix] |
Send data over an unconnected socket.
| ||
| sendto_substring [BatUnix] |
Same as
sendto , but take the data from a string instead of a
byte sequence.
| ||
| seq [BatLazyList] | seq init step cond creates a sequence of data, which starts
from init , extends by step , until the condition cond
fails.
| ||
| seq [BatEnum.Labels] | |||
| seq [BatEnum] | seq init step cond creates a sequence of data, which starts
from init , extends by step , until the condition cond
fails.
| ||
| sequence [BatEnum.WithMonad] | sequence e evaluates each monadic elements (of type 'a m ) contained in the enumeration e to get a monadic enumeration of 'a elements,
of type 'a BatEnum.t m .
| ||
| set [BatVect] | set v n c returns a copy of the v vect where the (n+1)th element
(see also get ) has been set to c .
| ||
| set [BatText] | set r n c returns a copy of rope r where the (n+1)th character
has been set to c .
| ||
| set [BatString.Cap] | |||
| set [BatString] | String.set s n c modifies string s in place,
replacing the character number n by c .
| ||
| set [BatRefList.Index] |
Change the element at the specified index
raise
Invalid_index if the index is outside 0 ; length-1
| ||
| set [BatRef] |
As
:=
| ||
| set [BatOptParse.Opt] |
Set the value of an option.
| ||
| set [BatGlobal] |
Set the global value contents.
| ||
| set [BatGc] | set r changes the GC parameters according to the control record r .
| ||
| set [BatFingerTree] | set t i v returns t where the i -th element is now v .
| ||
| set [BatDynArray] | set darr idx v sets the element of darr at index idx to value
v .
| ||
| set [BatDllist] |
Given a node, set the data associated with that node.
| ||
| set [BatBytes] | set s n c modifies s in place, replacing the byte at index n
with c .
| ||
| set [BatBitSet] | set s n sets the n th-bit in the bitset s to true.
| ||
| set [BatBigarray.Array3] | Array3.set a x y v , or alternatively a.{x,y,z} <- v ,
stores the value v at coordinates (x , y , z ) in a .
| ||
| set [BatBigarray.Array2] | Array2.set a x y v , or alternatively a.{x,y} <- v ,
stores the value v at coordinates (x , y ) in a .
| ||
| set [BatBigarray.Array1] | Array1.set a x v , also written a.{x} <- v ,
stores the value v at index x in a .
| ||
| set [BatBigarray.Genarray] |
Assign an element of a generic big array.
| ||
| set [BatArray.Cap] | |||
| set [BatArray] | Array.set a n x modifies array a in place, replacing
element number n with x .
| ||
| set_all_formatter_output_functions [BatFormat] | set_all_formatter_output_functions out flush outnewline outspace
redirects the pretty-printer output to the functions out and
flush as described in set_formatter_output_functions .
| ||
| set_browser [BatteriesConfig] | |||
| set_close_on_exec [BatUnix] |
Set the ``close-on-exec'' flag on the given descriptor.
| ||
| set_ellipsis_text [BatFormat] |
Set the text of the ellipsis printed when too many boxes
are opened (a single dot,
. , by default).
| ||
| set_formatter_out_channel [BatFormat] |
Redirect the pretty-printer output to the given channel.
| ||
| set_formatter_output [BatFormat] |
Sets the output of the formatter to the given argument
| ||
| set_formatter_output_functions [BatFormat] | set_formatter_output_functions out flush redirects the
relevant pretty-printer output functions to the functions out and
flush .
| ||
| set_formatter_tag_functions [BatFormat] | |||
| set_full_state [BatParserCo.Source] | |||
| set_margin [BatFormat] | set_margin d sets the value of the right margin
to d (in characters): this value is used to detect line
overflows that leads to split lines.
| ||
| set_mark_tags [BatFormat] | set_print_tags b turns on or off the printing of tags, while
set_mark_tags b turns on or off the output of tag markers.
| ||
| set_max_boxes [BatFormat] | set_max_boxes max sets the maximum number
of boxes simultaneously opened.
| ||
| set_max_indent [BatFormat] | set_max_indent d sets the value of the maximum
indentation limit to d (in characters):
once this limit is reached, boxes are rejected to the left,
if they do not fit on the current line.
| ||
| set_nonblock [BatUnix] |
Set the ``non-blocking'' flag on the given descriptor.
| ||
| set_permissions [BatFile] |
Set the permissions on a file.
| ||
| set_print_tags [BatFormat] | |||
| set_resizer [BatDynArray] |
Change the resizer for this array.
| ||
| set_signal [BatSys] |
Same as
Sys.signal but return value is ignored.
| ||
| set_state [BatRandom] |
Set the state of the generator used by the basic functions.
| ||
| set_tab [BatFormat] |
Sets a tabulation mark at the current insertion point.
| ||
| set_tags [BatFormat] | set_tags b turns on or off the treatment of tags (default is off).
| ||
| set_to_map [BatIMap] | set_to_map s x returns a map where every element of s is bound
to x .
| ||
| set_uncaught_exception_handler [BatPrintexc] | Printexc.set_uncaught_exception_handler fn registers fn as the handler
for uncaught exceptions.
| ||
| setgid [BatUnix] |
Set the real group id and effective group id for the process.
| ||
| setgroups [BatUnix] | setgroups groups sets the supplementary group IDs for the
calling process.
| ||
| setitimer [BatUnix] | setitimer t s sets the interval timer t and returns
its previous status.
| ||
| setsid [BatUnix] |
Put the calling process in a new session and detach it from
its controlling terminal.
| ||
| setsockopt [BatUnix] |
Set or clear a boolean-valued option in the given socket.
| ||
| setsockopt_float [BatUnix] |
Same as
Unix.setsockopt for a socket option whose value is a
floating-point number.
| ||
| setsockopt_int [BatUnix] |
Same as
Unix.setsockopt for an integer-valued socket option.
| ||
| setsockopt_optint [BatUnix] |
Same as
Unix.setsockopt for a socket option whose value is an
int option .
| ||
| setuid [BatUnix] |
Set the real user id and effective user id for the process.
| ||
| shift [BatVect] |
Return the first element of a vector and its last
n-1 elements.
| ||
| shift_left [BatNativeint] | Nativeint.shift_left x y shifts x to the left by y bits.
| ||
| shift_left [BatInt64] | Int64.shift_left x y shifts x to the left by y bits.
| ||
| shift_left [BatInt32] | Int32.shift_left x y shifts x to the left by y bits.
| ||
| shift_left_big_int [BatBig_int] | shift_left_big_int b n returns b shifted left by n bits.
| ||
| shift_right [BatNativeint] | Nativeint.shift_right x y shifts x to the right by y bits.
| ||
| shift_right [BatInt64] | Int64.shift_right x y shifts x to the right by y bits.
| ||
| shift_right [BatInt32] | Int32.shift_right x y shifts x to the right by y bits.
| ||
| shift_right_big_int [BatBig_int] | shift_right_big_int b n returns b shifted right by n bits.
| ||
| shift_right_logical [BatNativeint] | Nativeint.shift_right_logical x y shifts x to the right
by y bits.
| ||
| shift_right_logical [BatInt64] | Int64.shift_right_logical x y shifts x to the right by y bits.
| ||
| shift_right_logical [BatInt32] | Int32.shift_right_logical x y shifts x to the right by y bits.
| ||
| shift_right_towards_zero_big_int [BatBig_int] | shift_right_towards_zero_big_int b n returns b shifted
right by n bits.
| ||
| should [BatParserCo] |
Prevent backtracking.
| ||
| shuffle [BatRandom] | shuffle e returns a new array, containing the
same set of elements as e , but in a random order.
| ||
| shutdown [BatUnix] |
Shutdown a socket connection.
| ||
| shutdown_connection [BatUnix] |
``Shut down'' a connection established with
Unix.open_connection ;
that is, transmit an end-of-file condition to the server reading
on the other side of the connection.
| ||
| sigabrt [BatSys] |
Abnormal termination
| ||
| sigalrm [BatSys] |
Timeout
| ||
| sigbus [BatSys] |
Bus error
| ||
| sigchld [BatSys] |
Child process terminated
| ||
| sigcont [BatSys] |
Continue
| ||
| sigfpe [BatSys] |
Arithmetic exception
| ||
| sighup [BatSys] |
Hangup on controlling terminal
| ||
| sigill [BatSys] |
Invalid hardware instruction
| ||
| sigint [BatSys] |
Interactive interrupt (ctrl-C)
| ||
| sigkill [BatSys] |
Termination (cannot be ignored)
| ||
| sign [BatNum] |
Return
-1 , 0 or 1 according to the sign of the argument.
| ||
| sign_big_int [BatBig_int] |
Return
0 if the given big integer is zero,
1 if it is positive, and -1 if it is negative.
| ||
| sign_num [BatNum] | |||
| signal [BatSys] |
Set the behavior of the system on receipt of a given signal.
| ||
| signbit [BatFloat] | |||
| sigpending [BatUnix] |
Return the set of blocked signals that are currently pending.
| ||
| sigpipe [BatSys] |
Broken pipe
| ||
| sigpoll [BatSys] |
Pollable event
| ||
| sigprocmask [BatUnix] | sigprocmask cmd sigs changes the set of blocked signals.
| ||
| sigprof [BatSys] |
Profiling interrupt
| ||
| sigquit [BatSys] |
Interactive termination
| ||
| sigsegv [BatSys] |
Invalid memory reference
| ||
| sigstop [BatSys] |
Stop
| ||
| sigsuspend [BatUnix] | sigsuspend sigs atomically sets the blocked signals to sigs
and waits for a non-ignored, non-blocked signal to be delivered.
| ||
| sigsys [BatSys] |
Bad argument to routine
| ||
| sigterm [BatSys] |
Termination
| ||
| sigtrap [BatSys] |
Trace/breakpoint trap
| ||
| sigtstp [BatSys] |
Interactive stop
| ||
| sigttin [BatSys] |
Terminal read from background process
| ||
| sigttou [BatSys] |
Terminal write from background process
| ||
| sigurg [BatSys] |
Urgent condition on socket
| ||
| sigusr1 [BatSys] |
Application-defined signal 1
| ||
| sigusr2 [BatSys] |
Application-defined signal 2
| ||
| sigvtalrm [BatSys] |
Timeout in virtual time
| ||
| sigxcpu [BatSys] |
Timeout in cpu time
| ||
| sigxfsz [BatSys] |
File size limit exceeded
| ||
| sin [BatFloat.Safe_float] | |||
| sin [BatFloat] |
See
BatFloat.atan2 .
| ||
| single_write [BatUnix] |
Same as
write , but attempts to write only once.
| ||
| single_write_substring [BatUnix] |
Same as
single_write , but take the data from a string instead of
a byte sequence.
| ||
| singleton [BatVect] |
Returns a vect of length 1 holding only the given element.
| ||
| singleton [BatSet.PSet] |
Creates a new set with the single given element in it.
| ||
| singleton [BatSet.S] | singleton x returns the one-element set containing only x .
| ||
| singleton [BatSet] |
Creates a new set with the single given element in it.
| ||
| singleton [BatMap.PMap] |
creates a new map with a single binding
| ||
| singleton [BatMap.S] | singleton x y returns the one-element map that contains a binding y
for x .
| ||
| singleton [BatMap] |
creates a new map with a single binding
| ||
| singleton [BatList] |
Create a list consisting of exactly one element.
| ||
| singleton [BatISet] |
Return the singleton set containing only the given element
| ||
| singleton [BatIMap] | |||
| singleton [BatFingerTree.S] | singleton elt build the sequence containing elt as its sole
element.
| ||
| singleton [BatEnum] |
Create an enumeration consisting of exactly one element.
| ||
| singleton [BatArray] |
Create an array consisting of exactly one element.
| ||
| singleton_tree [BatAvlTree] | |||
| sinh [BatFloat.Safe_float] | |||
| sinh [BatFloat] |
See
BatFloat.tanh .
| ||
| size [BatSubstring] | size (s, i, n) returns the size of the substring, that is, n .
| ||
| size [BatNativeint] |
The size in bits of a native integer.
| ||
| size [BatHeap.H] |
See
BatHeap.size .
| ||
| size [BatHeap] |
Number of elements in the heap.
| ||
| size [BatFingerTree.S] | size t returns the number of elements in the sequence.
| ||
| size [BatFingerTree] | size t returns the number of elements in the sequence.
| ||
| size [BatDeque] | size dq is the number of elements in the dq .
| ||
| size_in_bytes [BatBigarray.Array3] | |||
| size_in_bytes [BatBigarray.Array2] | |||
| size_in_bytes [BatBigarray.Array1] | |||
| size_in_bytes [BatBigarray.Genarray] | |||
| size_of [BatFile] | size_of name returns the size of file name in bytes.
| ||
| size_of_big [BatFile] | size_of_big name returns the size of file name in bytes, as a 64-bit integer.
| ||
| skip [BatEnum] | skip n e removes the first n element from the enumeration, if any,
then returns e .
| ||
| skip [BatDllist] | skip n i Return the node that is i nodes after node n in the list.
| ||
| slazy [BatEnum] | |||
| sleep [BatUnix] |
Stop execution for the given number of seconds.
| ||
| slice [BatText] | slice ?first ?last s returns a "slice" of the rope
which corresponds to the characters s.[first] ,
s.[first+1] , ..., s[last-1] .
| ||
| slice [BatSubstring] | slice sus i' None returns the substring (s, i+i', n-i') ,
where sus = (s, i, n) .
| ||
| slice [BatString.Cap] | |||
| slice [BatString] | slice ?first ?last s returns a "slice" of the string
which corresponds to the characters s.[first] ,
s.[first+1] , ..., s[last-1] .
| ||
| slice_left [BatBigarray.Array2] |
Extract a row (one-dimensional slice) of the given two-dimensional
big array.
| ||
| slice_left [BatBigarray.Genarray] |
Extract a sub-array of lower dimension from the given big array
by fixing one or several of the first (left-most) coordinates.
| ||
| slice_left_1 [BatBigarray.Array3] |
Extract a one-dimensional slice of the given three-dimensional
big array by fixing the first two coordinates.
| ||
| slice_left_2 [BatBigarray.Array3] |
Extract a two-dimensional slice of the given three-dimensional
big array by fixing the first coordinate.
| ||
| slice_right [BatBigarray.Array2] |
Extract a column (one-dimensional slice) of the given
two-dimensional big array.
| ||
| slice_right [BatBigarray.Genarray] |
Extract a sub-array of lower dimension from the given big array
by fixing one or several of the last (right-most) coordinates.
| ||
| slice_right_1 [BatBigarray.Array3] |
Extract a one-dimensional slice of the given three-dimensional
big array by fixing the last two coordinates.
| ||
| slice_right_2 [BatBigarray.Array3] |
Extract a two-dimensional slice of the given
three-dimensional big array by fixing the last coordinate.
| ||
| snoc [BatFingerTree.S] | snoc t elt adds elt to the right of t .
| ||
| snoc [BatDeque] | snoc x dq adds x to the rear of dq .
| ||
| socket [BatUnix] |
Create a new socket in the given domain, and with the
given kind.
| ||
| socketpair [BatUnix] |
Create a pair of unnamed sockets, connected together.
| ||
| some [BatOption] | some x returns Some x .
| ||
| sort [BatRefList] |
Sort elements using the specified comparator
| ||
| sort [BatList] |
Sort a list in increasing order according to a comparison
function.
| ||
| sort [BatLazyList] |
Sort the list using optional comparator (by default
compare ).
| ||
| sort [BatArray.Cap.Labels] | |||
| sort [BatArray.Cap] | |||
| sort [BatArray.Labels] | |||
| sort [BatArray] |
Sort an array in increasing order according to a comparison
function.
| ||
| sort_uniq [BatList] | sort_uniq cmp l returns the list l sorted and without any
duplicate element.
| ||
| sort_unique [BatList] |
synonym for
sort_uniq
| ||
| source [BatPathGen.StringType.Parse] | |||
| source_map [BatParserCo] | |||
| source_of_enum [BatCharParser] |
Create a source from a latin-1 character.
| ||
| source_of_string [BatCharParser] |
Create a source from a latin-1 character string.
| ||
| span [BatSubstring] | span sus1 sus2 returns a substring spanning from the start of
sus1 to the end of sus2 , provided this is well-defined: sus1
and sus2 must have the same underlying string, and the start of
sus1 must not be to the right of the end of sus2 ; otherwise
| ||
| span [BatList] | span , applied to a predicate p and a list xs , returns a
tuple where first element is longest prefix (possibly empty) of xs
of elements that satisfy p and second element is the remainder of
the list.
| ||
| span [BatEnum] | span test e produces two enumerations (hd, tl) , such that
hd is the same as take_while test e and tl is the same
as drop_while test e .
| ||
| splice [BatText] | splice s off len rep returns the rope in which the section of s
indicated by off and len has been cut and replaced by rep .
| ||
| splice [BatString.Cap] | |||
| splice [BatString] | String.splice s off len rep cuts out the section of s
indicated by off and len and replaces it by rep
| ||
| splice [BatDllist] | splice n1 n2 Connects n1 and n2 so that
next n1 == n2 && prev n2 == n1 .
| ||
| split [BatText] | split s sep splits the rope s between the first
occurrence of sep .
| ||
| split [BatString.Cap.Exceptionless] | |||
| split [BatString.Cap] |
Splitting around
| ||
| split [BatString.Exceptionless] | split s sep splits the string s between the first
occurrence of sep , or returns None if the separator
is not found.
| ||
| split [BatString] | split s sep splits the string s between the first
occurrence of sep , and returns the two parts before
and after the occurence (excluded).
| ||
| split [BatStream] | split is the opposite of comb
| ||
| split [BatSet.PSet] | split x s returns a triple (l, present, r) , where
l is the set of elements of s that are
strictly less than x ;
r is the set of elements of s that are
strictly greater than x ;
present is false if s contains no element equal to x ,
or true if s contains an element equal to x .
| ||
| split [BatSet.S] | split x s returns a triple (l, present, r) , where
l is the set of elements of s that are
strictly less than x ;
r is the set of elements of s that are
strictly greater than x ;
present is false if s contains no element equal to x ,
or true if s contains an element equal to x .
| ||
| split [BatSet] | split x s returns a triple (l, present, r) , where
l is the set of elements of s that are
strictly less than x ;
r is the set of elements of s that are
strictly greater than x ;
present is false if s contains no element equal to x ,
or true if s contains an element equal to x .
| ||
| split [BatSeq] | split s = (map fst s, map snd s) .
| ||
| split [BatPathGen.PathType] |
Dissect the path to its components (parent path, core part of name and possibly an extension).
| ||
| split [BatMap.PMap] | split x m returns a triple (l, data, r) , where
l is the map with all the bindings of m whose key
is strictly less than x ;
r is the map with all the bindings of m whose key
is strictly greater than x ;
data is None if m contains no binding for x ,
or Some v if m binds v to x .
| ||
| split [BatMap.S] | split x m returns a triple (l, data, r) , where
l is the map with all the bindings of m whose key
is strictly less than x ;
r is the map with all the bindings of m whose key
is strictly greater than x ;
data is None if m contains no binding for x ,
or Some v if m binds v to x .
| ||
| split [BatMap] | split x m returns a triple (l, data, r) , where
l is the map with all the bindings of m whose key
is strictly less than x ;
r is the map with all the bindings of m whose key
is strictly greater than x ;
data is None if m contains no binding for x ,
or Some v if m binds v to x .
| ||
| split [BatList] |
Transform a list of pairs into a pair of lists:
split [(a0,b0); (a1,b1); ...; (an,bn)] is ([a0; a1; ...; an], [b0;
b1; ...; bn]) .
| ||
| split [BatFingerTree.Generic] | split p t , when p is monotonic, returns (t1, t2) where
t1 is the longest prefix of t whose measure does not satifies
p , and t2 is the rest of t .
| ||
| split [BatArray] | split cmp arr x assumes that arr is sorted w.r.t
cmp .
| ||
| split_at [BatSubstring] | split_at sus k returns the pair (sus1, sus2) of substrings,
where sus1 contains the first k characters of sus , and
sus2 contains the rest.
| ||
| split_at [BatList.Labels.LExceptionless] | |||
| split_at [BatList.Exceptionless] |
Whenever
n is inside of l size bounds, split_at n l returns
Ok(l1,l2) , where l1 contains the first n elements of l and l2
contains the others.
| ||
| split_at [BatList] | split_at n l returns two lists l1 and l2 , l1 containing the
first n elements of l and l2 the others.
| ||
| split_at [BatLazyList.Labels.Exceptionless] | |||
| split_at [BatLazyList.Exceptionless] |
Whenever
n is inside of l size bounds, split_at n l returns
`Ok (l1,l2) , where l1 contains the first n elements of l and l2
contains the others.
| ||
| split_at [BatLazyList] | split_at n l returns two lists l1 and l2 , l1 containing the
first n elements of l and l2 the others.
| ||
| split_at [BatFingerTree] | split_at is equivalent to List.split_at .
| ||
| split_le [BatSet.PSet] | split_le x s returns a pair of sets (l, r) , such that
l is the subset of s with elements <= x ;
r is the subset of s with elements > x .
| ||
| split_le [BatSet.S] | split_le x s returns a pair of sets (l, r) , such that
l is the subset of s with elements <= x ;
r is the subset of s with elements > x .
| ||
| split_le [BatSet] | split_le x s returns a pair of sets (l, r) , such that
l is the subset of s with elements <= x ;
r is the subset of s with elements > x .
| ||
| split_leftmost [BatAvlTree] | |||
| split_lt [BatSet.PSet] | split_lt x s returns a pair of sets (l, r) , such that
l is the subset of s with elements < x ;
r is the subset of s with elements >= x .
| ||
| split_lt [BatSet.S] | split_lt x s returns a pair of sets (l, r) , such that
l is the subset of s with elements < x ;
r is the subset of s with elements >= x .
| ||
| split_lt [BatSet] | split_lt x s returns a pair of sets (l, r) , such that
l is the subset of s with elements < x ;
r is the subset of s with elements >= x .
| ||
| split_nth [BatList] |
Obsolete.
| ||
| split_nth [BatLazyList] |
Obsolete.
| ||
| split_on_char [BatSubstring] | split_on_char c ss returns substrings of input ss as divided
by c
| ||
| split_on_comma [BatSubstring] | |||
| split_on_dot [BatSubstring] | |||
| split_on_pipe [BatSubstring] | |||
| split_on_slash [BatSubstring] | |||
| split_opt [BatSet.PSet] | split_opt x s returns a triple (l, maybe_v, r) , where
l is the set of elements of s that are
strictly less than x ;
r is the set of elements of s that are
strictly greater than x ;
maybe_v is None if s contains no element equal to x ,
or Some v if s contains an element v that compares equal to x .
| ||
| split_opt [BatSet.S] | split_opt x s returns a triple (l, maybe_v, r) , where
l is the set of elements of s that are
strictly less than x ;
r is the set of elements of s that are
strictly greater than x ;
maybe_v is None if s contains no element equal to x ,
or Some v if s contains an element v that compares equal to x .
| ||
| split_opt [BatSet] | split_opt x s returns a triple (l, maybe_v, r) , where
l is the set of elements of s that are
strictly less than x ;
r is the set of elements of s that are
strictly greater than x ;
maybe_v is None if s contains no element equal to x ,
or Some v if s contains an element v that compares equal to x .
| ||
| split_rightmost [BatAvlTree] | |||
| splitl [BatSubstring] | splitl p sus splits sus into a pair (sus1, sus2) of
substrings where sus1 is the longest prefix (left substring) all
of whose characters satisfy p , and sus2 is the rest.
| ||
| splitr [BatSubstring] | splitr p sus splits sus into a pair (sus1, sus2) of
substrings where sus2 is the longest suffix (right substring) all
of whose characters satisfy p , and sus1 is the rest.
| ||
| sprintf [BatPrintf] |
A function which doesn't print its result but returns it as a string.
| ||
| sprintf [BatFormat] |
Same as
printf above, but instead of printing on a formatter,
returns a string containing the result of formatting the arguments.
| ||
| sprintf2 [BatPrintf] |
A function which doesn't print its result but returns it as a string.
| ||
| sqrt [BatFloat] |
Square root.
| ||
| sqrt [BatComplex] |
Square root.
| ||
| sqrt2 [BatFloat] | sqrt 2.
| ||
| sqrt_big_int [BatBig_int] | sqrt_big_int a returns the integer square root of a ,
that is, the largest big integer r such that r * r <= a .
| ||
| sqrtpi2 [BatFloat] | 2. *. sqrt pi
| ||
| square [BatNum] | |||
| square_big_int [BatBig_int] |
Return the square of the given big integer
| ||
| square_num [BatNum] | |||
| sscanf [BatScanf] |
Same as
Scanf.bscanf , but reads from the given string.
| ||
| sscanf_format [BatScanf] |
Same as
Scanf.bscanf_format , but reads from the given string.
| ||
| stable_sort [BatList.Labels] | |||
| stable_sort [BatList] |
Same as
List.sort , but the sorting algorithm is guaranteed to
be stable (i.e.
| ||
| stable_sort [BatLazyList] | |||
| stable_sort [BatArray.Cap.Labels] | |||
| stable_sort [BatArray.Cap] | |||
| stable_sort [BatArray.Labels] | |||
| stable_sort [BatArray] |
Same as
Array.sort , but the sorting algorithm is stable (i.e.
| ||
| start [BatGenlex.Languages.Make] |
Medium-level API
| ||
| starts_with [BatText] | starts_with s x returns true if s is starting with x , false otherwise.
| ||
| starts_with [BatString.Cap] | |||
| starts_with [BatString] | starts_with s x returns true if s is starting with x , false otherwise.
| ||
| stat [BatUnix.LargeFile] | |||
| stat [BatUnix] |
Return the information for the named file.
| ||
| stat [BatGc] |
Return the current values of the memory management counters in a
stat record.
| ||
| state [BatParserCo] |
Succeed and return the state of the parser
| ||
| std_formatter [BatFormat] |
The standard formatter used by the formatting functions
above.
| ||
| stdbuf [BatFormat] |
The string buffer in which
str_formatter writes.
| ||
| stderr [BatUnix] |
File descriptor for standard error.
| ||
| stderr [BatPervasives] |
Standard error output, as per Unix/Windows conventions.
| ||
| stderr [BatInnerIO] |
Standard error output, as per Unix/Windows conventions.
| ||
| stderr [BatIO] |
Standard error output, as per Unix/Windows conventions.
| ||
| stderr_formatter [BatLogger] | stderr_formatter is a standard formatter that outputs log
events to stderr using the same format as
make_std_formatter .
| ||
| stdib [BatScanf.Scanning] |
The scanning buffer reading from
stdin .
| ||
| stdin [BatUnix] |
File descriptor for standard input.
| ||
| stdin [BatPervasives] |
Standard input, as per Unix/Windows conventions (by default, keyboard).
| ||
| stdin [BatInnerIO] |
Standard input, as per Unix/Windows conventions (by default, keyboard).
| ||
| stdin [BatIO] |
Standard input, as per Unix/Windows conventions (by default, keyboard).
| ||
| stdnull [BatPervasives] |
An output which discards everything written to it.
| ||
| stdnull [BatInnerIO] |
An output which discards everything written to it.
| ||
| stdnull [BatIO] |
An output which discards everything written to it.
| ||
| stdout [BatUnix] |
File descriptor for standard output.
| ||
| stdout [BatPervasives] |
Standard output, as per Unix/Windows conventions (by default, console).
| ||
| stdout [BatInnerIO] |
Standard output, as per Unix/Windows conventions (by default, console).
| ||
| stdout [BatIO] |
Standard output, as per Unix/Windows conventions (by default, console).
| ||
| step_resizer [BatDynArray] |
The stepwise resizer- another example of a resizer function, this
time of a parameterized resizer.
| ||
| store_const [BatOptParse.StdOpt] | store_const ?default const returns a flag option which
stores the constant value const when the option is
encountered on the command line.
| ||
| store_false [BatOptParse.StdOpt] | store_false () returns an option which is set to false when
it is encountered on the command line.
| ||
| store_true [BatOptParse.StdOpt] | store_true () returns an option which is set to true when
it is encountered on the command line.
| ||
| str_callback [BatOptParse.StdOpt] |
See
OptParse.StdOpt.int_callback .
| ||
| str_decode [BatBase64] |
Decode a string encoded into Base64, raise
Invalid_char if a
character in the input string is not a valid one.
| ||
| str_encode [BatBase64] |
Encode a string into Base64.
| ||
| str_formatter [BatFormat] |
A formatter to use with formatting functions below for
output to the
stdbuf string buffer.
| ||
| str_int_pmap [BatteriesPrint] | |||
| str_option [BatOptParse.StdOpt] |
See
OptParse.StdOpt.int_option .
| ||
| str_str_pmap [BatteriesPrint] | |||
| string [BatGenlex.Languages.Make] |
As
CharParser.string , but case-insensitive if specified
by case_sensitive .
| ||
| string [BatDigest] |
Return the digest of the given string.
| ||
| string [BatCharParser] |
Recognize exactly one string
| ||
| string_dynarray [BatteriesPrint] | |||
| string_enum [BatteriesPrint] | |||
| string_literal [BatGenlex.Languages.Make] |
Accepts a string, i.e.
| ||
| string_of [BatUnit] |
Convert the given unit to a string.
| ||
| string_of_big_int [BatBig_int] |
Return the string representation of the given big integer,
in decimal (base 10).
| ||
| string_of_cap [BatteriesPrint] | |||
| string_of_inet_addr [BatUnix] |
Return the printable representation of the given Internet address.
| ||
| string_of_num [BatNum] | |||
| string_of_token [BatGenlex] | |||
| string_pset [BatteriesPrint] | |||
| string_set [BatteriesPrint] | |||
| strip [BatText] |
Returns the rope without the chars if they are at the beginning or
at the end of the rope.
| ||
| strip [BatString.Cap] | |||
| strip [BatString] |
Returns the string without the chars if they are at the beginning or
at the end of the string.
| ||
| sub [BatVect] | sub m n r returns a sub-vect of r containing all the elements
whose indexes range from m to m + n - 1 (included).
| ||
| sub [BatText] | sub r m n returns a sub-rope of r containing all characters
whose indexes range from m to m + n - 1 (included).
| ||
| sub [BatString.Cap] | |||
| sub [BatString] | String.sub s start len returns a fresh string of length len ,
containing the substring of s that starts at position start and
has length len .
| ||
| sub [BatPathGen.StringType] |
As
String.sub , but indexed in specific way.
| ||
| sub [BatNumber.NUMERIC_BASE] | |||
| sub [BatNumber.Numeric] | |||
| sub [BatNum] | |||
| sub [BatNativeint] |
Subtraction.
| ||
| sub [BatInt64] |
Subtraction.
| ||
| sub [BatInt32] |
Subtraction.
| ||
| sub [BatInt.Safe_int] |
Substraction.
| ||
| sub [BatInt] |
Subtraction.
| ||
| sub [BatFloat.Safe_float] | |||
| sub [BatFloat] | |||
| sub [BatDynArray] | sub darr start len returns an array holding the subset of len
elements from darr starting with the element at index idx .
| ||
| sub [BatComplex] |
Subtraction
| ||
| sub [BatBytes] | 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 .
| ||
| sub [BatBuffer] | Buffer.sub b off len returns (a copy of) the substring of the
current contents of the buffer b starting at offset off of length
len bytes.
| ||
| sub [BatBool] | |||
| sub [BatBigarray.Array1] |
Extract a sub-array of the given one-dimensional big array.
| ||
| sub [BatBig_int] | |||
| sub [BatArray.Cap.Labels] | |||
| sub [BatArray.Cap] | |||
| sub [BatArray.Labels] | |||
| sub [BatArray] | Array.sub a start len returns a fresh array of length len ,
containing the elements number start to start + len - 1
of array a .
| ||
| sub_big_int [BatBig_int] |
Subtraction.
| ||
| sub_left [BatBigarray.Array3] |
Extract a three-dimensional sub-array of the given
three-dimensional big array by restricting the first dimension.
| ||
| sub_left [BatBigarray.Array2] |
Extract a two-dimensional sub-array of the given two-dimensional
big array by restricting the first dimension.
| ||
| sub_left [BatBigarray.Genarray] |
Extract a sub-array of the given big array by restricting the
first (left-most) dimension.
| ||
| sub_num [BatNum] | |||
| sub_right [BatBigarray.Array3] |
Extract a three-dimensional sub-array of the given
three-dimensional big array by restricting the second dimension.
| ||
| sub_right [BatBigarray.Array2] |
Extract a two-dimensional sub-array of the given two-dimensional
big array by restricting the second dimension.
| ||
| sub_right [BatBigarray.Genarray] |
Extract a sub-array of the given big array by restricting the
last (right-most) dimension.
| ||
| sub_string [BatBytes] |
Same as
sub but return a string instead of a byte sequence.
| ||
| subbytes [BatDigest] | Digest.subbytes s ofs len returns the digest of the subsequence
of s starting at index ofs and containing len bytes.
| ||
| subset [BatSet.PSet] | subset a b returns true if a is a subset of b .
| ||
| subset [BatSet.S] | subset s1 s2 tests whether the set s1 is a subset of
the set s2 .
| ||
| subset [BatSet] | subset a b returns true if a is a subset of b .
| ||
| subset [BatList.Labels] | |||
| subset [BatList] | subset cmp l l' check if all elements of the list l
is contained in the list l' by applying cmp as comparator.
| ||
| subset [BatISet] | subset t u returns true if t is a subset of u
| ||
| substring [BatSubstring] | substring s o l returns a substring with base-string s , offset
o and length l .
| ||
| substring [BatDigest] | Digest.substring s ofs len returns the digest of the substring
of s starting at character number ofs and containing len
characters.
| ||
| succ [BatNumber.NUMERIC_BASE] | |||
| succ [BatNumber.Discrete] | |||
| succ [BatNumber.Numeric] | |||
| succ [BatNum] | |||
| succ [BatNativeint] |
Successor.
| ||
| succ [BatInt64] |
Successor.
| ||
| succ [BatInt32] |
Successor.
| ||
| succ [BatInt.Safe_int] |
Successor.
| ||
| succ [BatInt] |
Successor.
| ||
| succ [BatFloat.Safe_float] |
Add
1. to a floating number.
| ||
| succ [BatFloat] |
Add
1. to a floating number.
| ||
| succ [BatComplex] |
Add
BatComplex.one to this number.
| ||
| succ [BatBool] | |||
| succ [BatBig_int] | |||
| succ_big_int [BatBig_int] |
Successor (add 1).
| ||
| succ_num [BatNum] | |||
| suffix_action [BatEnum] | suffix_action f e will behave as e but guarantees that f ()
will be invoked after the contents of e are exhausted.
| ||
| sum [BatList] | sum l returns the sum of the integers of l
| ||
| sum [BatEnum] | sum returns the sum of the given int enum.
| ||
| sum [BatArray] | sum l returns the sum of the integers of l
| ||
| suspend [BatParserCo] | suspend s returns the state of the parser in a form that can be
resumed by calling the returned function.
| ||
| swap [BatTuple.Tuple2] | |||
| swap [BatRef] | swap a b puts !b in a and !a in b
| ||
| switch [BatStream.StreamLabels] | |||
| switch [BatStream] | switch test stream split stream into two streams, where the first stream have
all the elements satisfying test , the second stream is opposite.
| ||
| switch [BatEnum.Labels] | |||
| switch [BatEnum] | switch test enum splits enum into two enums, where the first enum have
all the elements satisfying test , the second enum is opposite.
| ||
| sym_diff [BatSet.PSet] | sym_diff s t returns the set of all elements in s or t but not both.
| ||
| sym_diff [BatSet.S] | sym_diff s t returns the set of all elements in s or t
but not both.
| ||
| sym_diff [BatSet] | sym_diff s t returns the set of all elements in s or t but
not both, also known as the symmetric difference.
| ||
| sym_diff [BatBitSet] | sym_diff s t returns the symmetrical difference of s and t .
| ||
| symlink [BatUnix] |
Symbolic links
| ||
| sync [BatConcurrent] |
Specialized version of
synchronized .
| ||
| synchronize [BatRMutex] |
Protect a function.
| ||
| synchronize [BatMutex] |
Protect a function.
| ||
| synchronize [BatConcurrent.Lock] | |||
| synchronize [BatConcurrent] | synchronize locker f returns a function f' which behaves as
f but whose executions are protected by one lock obtained from
locker .
| ||
| system [BatUnix] |
Execute the given command, wait until it terminates, and return
its termination status.
| ||
T | |||
| tail [BatText] | tail r pos returns the rope containing all but the pos first characters of r
| ||
| tail [BatString.Cap] | |||
| tail [BatString] | tail r pos returns the string containing all but the pos first characters of r
| ||
| tail [BatFingerTree.S] | tail t returns None when t is empty,
or Some tl where tl is the sequence t where the first element
has been removed.
| ||
| tail [BatArray] | tail r pos returns the array containing all but the pos first characters of r
| ||
| tail_exn [BatFingerTree.S] | tail_exn t returns the sequence t where the first element
has been removed.
| ||
| take [BatStream] | take n stream returns the prefix of stream of length n , or stream
itself if n is greater than the length of stream
| ||
| take [BatSeq] | take n s returns up to the n first elements from sequence
s , if available.
| ||
| take [BatQueue.Exceptionless] | |||
| take [BatQueue] | take q removes and returns the first element in queue q ,
or raises Empty if the queue is empty.
| ||
| take [BatList] | take n l returns up to the n first elements from list l , if
available.
| ||
| take [BatLazyList] | take n l returns up to the n first elements from list l , if
available.
| ||
| take [BatEnum] | take n e returns the prefix of e of length n , or e
itself if n is greater than the length of e
| ||
| take_while [BatStream.StreamLabels] | |||
| take_while [BatStream] | take_while test stream returns the longest (possibly empty) prefix of
stream of elements that satisfy test .
| ||
| take_while [BatSeq] | take_while f s returns the first elements of sequence s
which satisfy the predicate f .
| ||
| take_while [BatList.Labels] | |||
| take_while [BatList] | take_while p xs returns the (possibly empty) longest prefix of
elements of xs that satisfy the predicate p .
| ||
| take_while [BatLazyList.Labels] | |||
| take_while [BatLazyList] | take_while f xs returns the first elements of list xs
which satisfy the predicate f .
| ||
| take_while [BatEnum.Labels] | |||
| take_while [BatEnum] | take_while f e produces a new enumeration in which only remain
the first few elements x of e such that f x
| ||
| takedrop [BatList] | take_drop n l is equivalent to (take n l, drop n l)
but is done in one pass.
| ||
| takel [BatSubstring] | takel p sus returns the longest prefix (left substring) of sus
all of whose characters satisfy predicate p .
| ||
| taker [BatSubstring] | taker p sus returns the longest suffix (right substring) of sus
all of whose characters satisfy predicate p .
| ||
| takewhile [BatList] |
obsolete, as
BatList.take_while
| ||
| tan [BatFloat.Safe_float] | |||
| tan [BatFloat] |
See
BatFloat.atan2 .
| ||
| tanh [BatFloat.Safe_float] |
The usual hyperbolic trigonometric functions.
| ||
| tanh [BatFloat] |
The usual hyperbolic trigonometric functions.
| ||
| tap [BatPervasives] |
Allows application of a function in the middle of a pipe
sequence without disturbing the sequence.
| ||
| tap [BatInnerPervasives] | |||
| tcdrain [BatUnix] |
Waits until all output written on the given file descriptor
has been transmitted.
| ||
| tcflow [BatUnix] |
Suspend or restart reception or transmission of data on
the given file descriptor, depending on the second argument:
TCOOFF suspends output, TCOON restarts output,
TCIOFF transmits a STOP character to suspend input,
and TCION transmits a START character to restart input.
| ||
| tcflush [BatUnix] |
Discard data written on the given file descriptor but not yet
transmitted, or data received but not yet read, depending on the
second argument:
TCIFLUSH flushes data received but not read,
TCOFLUSH flushes data written but not transmitted, and
TCIOFLUSH flushes both.
| ||
| tcgetattr [BatUnix] |
Return the status of the terminal referred to by the given
file descriptor.
| ||
| tcsendbreak [BatUnix] |
Send a break condition on the given file descriptor.
| ||
| tcsetattr [BatUnix] |
Set the status of the terminal referred to by the given
file descriptor.
| ||
| text_set [BatteriesPrint] | |||
| third [BatTuple.Tuple5] | |||
| third [BatTuple.Tuple4] | |||
| third [BatTuple.Tuple3] | |||
| time [BatUnix] |
Return the current time since 00:00:00 GMT, Jan.
| ||
| time [BatSys] |
Return the processor time, in seconds, used by the program
since the beginning of execution.
| ||
| times [BatUnix] |
Return the execution times of the process.
| ||
| times [BatParserCo] | times n p accepts a list of n expressions accepted by p
| ||
| titled_formatter [BatOptParse.Formatter] |
Creates a titled formatter which is quite similar to the
indented formatter.
| ||
| tl [BatSeq.Exceptionless] | |||
| tl [BatSeq] |
Returns the sequence without its first elements or raise
Invalid_argument if the sequence is empty.
| ||
| tl [BatRefList] |
Returns a ref list containing the same elements
but without the first one or
raises
Empty_list if the ref list is empty
| ||
| tl [BatList.Exceptionless] | tl l returns Some x such that x is the given list l without its
first element.
| ||
| tl [BatList] |
Return the given list without its first element.
| ||
| tl [BatLazyList] |
Return the given list without its first element.
| ||
| to_array [BatVect] | to_array r returns an array corresponding to the vect r .
| ||
| to_array [BatSet.PSet] |
Same as
to_list but with an array instead of a list.
| ||
| to_array [BatSet.S] |
Same as
to_list but with an array instead of a list.
| ||
| to_array [BatSet] |
Same as
to_list but with an array instead of a list.
| ||
| to_array [BatLazyList] |
Eager conversion to array.
| ||
| to_array [BatDynArray] | to_array darr returns the elements of darr in order as an array.
| ||
| to_array [BatBigarray.Array3] |
Build a three-dimensional array initialized from the
given big array.
| ||
| to_array [BatBigarray.Array2] |
Build a two-dimensional array initialized from the
given big array.
| ||
| to_array [BatBigarray.Array1] |
Build a one-dimensional array initialized from the
given big array.
| ||
| to_array [BatArray.Cap] |
Return a capability array as an array.
| ||
| to_buffer [BatMarshal] | Marshal.to_buffer buff ofs len v flags marshals the value v ,
storing its byte representation in the sequence buff ,
starting at index ofs , and writing at most
len bytes.
| ||
| to_byte [BatInt32] | |||
| to_bytes [BatMarshal] | Marshal.to_bytes v flags returns a byte sequence containing
the representation of v .
| ||
| to_bytes [BatBuffer] |
Return a copy of the current contents of the buffer.
| ||
| to_channel [BatMarshal] | |||
| to_enum_filter [BatGenlex] |
Apply the lexer to an enum.
| ||
| to_float [BatString.Cap.Exceptionless] | |||
| to_float [BatString.Cap] | |||
| to_float [BatString.Exceptionless] |
Returns the float represented by the given string or
None if the string does not represent a float.
| ||
| to_float [BatString] |
Returns the float represented by the given string
or
| ||
| to_float [BatNumber.NUMERIC_BASE] | |||
| to_float [BatNumber.Numeric] | |||
| to_float [BatNum] | |||
| to_float [BatNativeint] |
Convert the given native integer to a floating-point number.
| ||
| to_float [BatInt64] |
Convert the given 64-bit integer to a floating-point number.
| ||
| to_float [BatInt32] |
Convert the given 32-bit integer to a floating-point number.
| ||
| to_float [BatInt.Safe_int] |
Convert the given integer to a floating-point number.
| ||
| to_float [BatInt] |
Convert the given integer to a floating-point number.
| ||
| to_float [BatFloat.Safe_float] | |||
| to_float [BatFloat] | |||
| to_float [BatComplex] | Complex.to_float (a+bi) returns the float a
| ||
| to_float [BatBool] | |||
| to_float [BatBig_int] | |||
| to_hex [BatDigest] |
Return the printable hexadecimal representation of the given digest.
| ||
| to_int [BatString.Cap.Exceptionless] | |||
| to_int [BatString.Cap] | |||
| to_int [BatString.Exceptionless] |
Returns the integer represented by the given string or
None if the string does not represent an integer.
| ||
| to_int [BatString] |
Returns the integer represented by the given string
or
| ||
| to_int [BatNumber.NUMERIC_BASE] |
Convert an integer to the closest element of set
t .
| ||
| to_int [BatNumber.Discrete] | |||
| to_int [BatNumber.Numeric] | |||
| to_int [BatNum] | |||
| to_int [BatNativeint] |
Convert the given native integer (type
nativeint ) to an
integer (type int ).
| ||
| to_int [BatInt64] |
Convert the given 64-bit integer (type
int64 ) to an
integer (type int ).
| ||
| to_int [BatInt32] |
Convert the given 32-bit integer (type
int32 ) to an
integer (type int ).
| ||
| to_int [BatInt.Safe_int] | |||
| to_int [BatInt] | |||
| to_int [BatFloat.Safe_float] | |||
| to_int [BatFloat] | |||
| to_int [BatComplex] | to_int c is the integer part of the real part of c
| ||
| to_int [BatBool] | |||
| to_int [BatBig_int] | |||
| to_int32 [BatNativeint] |
Convert the given native integer to a
32-bit integer (type
int32 ).
| ||
| to_int32 [BatInt64] |
Convert the given 64-bit integer (type
int64 ) to a
32-bit integer (type int32 ).
| ||
| to_int64 [BatNativeint] |
Convert the given native integer to a
64-bit integer (type
int64 ).
| ||
| to_int64 [BatInt32] |
Convert the given 32-bit integer (type
int32 )
to a 64-bit integer (type int64 ).
| ||
| to_lazy_list_filter [BatGenlex] |
Apply the lexer to a lazy list.
| ||
| to_list [BatVect] |
Returns a list with the elements contained in the vect.
| ||
| to_list [BatString.Cap] | |||
| to_list [BatString] |
Converts a string to the list of its characters.
| ||
| to_list [BatStream] |
Convert a stream to a list
| ||
| to_list [BatSplay.Map] | |||
| to_list [BatSet.PSet] |
Alias for
elements .
| ||
| to_list [BatSet.S] |
Alias for
elements .
| ||
| to_list [BatSet] |
Alias for
elements .
| ||
| to_list [BatRefList] |
Returns the current elements as a list - O(1)
| ||
| to_list [BatLazyList] |
Eager conversion to string.
| ||
| to_list [BatHeap.H] |
See
BatHeap.to_list .
| ||
| to_list [BatHeap] |
Enumerate the elements of the heap.
| ||
| to_list [BatFingerTree.S] | to_list t is equivalent to BatList.of_enum (enum t) .
| ||
| to_list [BatDynArray] | to_list darr returns the elements of darr in order as a list.
| ||
| to_list [BatDllist] |
Converts a dllist to a normal list.
| ||
| to_list [BatDeque] | to_list dq is a list representation of the elements of dq .
| ||
| to_list [BatArray.Cap] | |||
| to_list [BatArray] | Array.to_list a returns the list of all the elements of a .
| ||
| to_list_backwards [BatFingerTree.S] | to_list_backwards t is equivalent to BatList.of_enum (backwards t) .
| ||
| to_nativeint [BatInt64] |
Convert the given 64-bit integer (type
int64 ) to a
native integer.
| ||
| to_nativeint [BatInt32] |
Convert the given 32-bit integer (type
int32 ) to a
native integer.
| ||
| to_object [BatEnum] | to_object e returns a representation of e as an object.
| ||
| to_option [BatResult] |
Convert a
result to an option
| ||
| to_stream [BatLazyList] |
Lazy conversion to stream.
| ||
| to_stream_filter [BatGenlex] |
Apply the lexer to a stream.
| ||
| to_string [BatText] | to_string t returns a UTF-8 encoded string representing t
| ||
| to_string [BatSubstring] | string sus is the string si..i+n-1 represented by sus = (s, i, n).
| ||
| to_string [BatString.Cap] |
Return a capability string as a regular string.
| ||
| to_string [BatStream] |
convert stream of chars to string, using buffer
| ||
| to_string [BatPrintexc] | Printexc.to_string e returns a string representation of the
exception e .
| ||
| to_string [BatPathGen.StringType] |
Convert to primitive string with UTF-8 content.
| ||
| to_string [BatPathGen.PathType] |
Convert to type primitive string with UTF-8 content.
| ||
| to_string [BatNumber.NUMERIC_BASE] | |||
| to_string [BatNumber.Numeric] | |||
| to_string [BatNum] |
Convert a number to a string, using fractional notation.
| ||
| to_string [BatNativeint] |
Return the string representation of its argument, in decimal.
| ||
| to_string [BatMarshal] |
Same as
to_bytes but return the result as a string instead of
a byte sequence.
| ||
| to_string [BatLog.Level_sig] |
The default level for loggers created with this; log messages
with level less than this won't be printed by default.
| ||
| to_string [BatInt64] |
Return the string representation of its argument, in decimal.
| ||
| to_string [BatInt32] |
Return the string representation of its argument, in signed decimal.
| ||
| to_string [BatInt.Safe_int] |
Return the string representation of its argument, in signed decimal.
| ||
| to_string [BatInt] |
Return the string representation of its argument, in signed decimal.
| ||
| to_string [BatFloat.Safe_float] | |||
| to_string [BatFloat] | |||
| to_string [BatComplex] | |||
| to_string [BatBytes] |
Return a new string that contains the same bytes as the given byte
sequence.
| ||
| to_string [BatBool] | |||
| to_string [BatBig_int] | |||
| to_string_fmt [BatStream.StreamLabels] | |||
| to_string_fmt [BatStream] |
convert stream to string, using Printf with given format
| ||
| to_string_fun [BatStream.StreamLabels] | |||
| to_string_fun [BatStream] |
convert stream to string, using given conversion function
| ||
| to_string_in_base [BatBig_int] | to_string_in_base b n returns the string representation in base b of
the given big integer n .
| ||
| to_string_in_binary [BatBig_int] |
as
string_of_big_int , but in base 2
| ||
| to_string_in_custom_base [BatBig_int] |
First argument, called
symbols , is the vector of the symbols used to
represent the digits in base b .
| ||
| to_string_in_hexa [BatBig_int] |
as
string_of_big_int , but in base 16
| ||
| to_string_in_octal [BatBig_int] |
as
string_of_big_int , but in base 8
| ||
| to_table [BatHashtbl.Cap] |
Return a capability hashtable as a regular hashtable.
| ||
| to_ustring [BatPathGen.PathType] |
Convert to the chosen
ustring type.
| ||
| toggle [BatRef] |
Invert the boolean stored in the reference
| ||
| toggle [BatBitSet] | toggle s n changes the nth-bit value in the bitset s .
| ||
| tokens [BatSubstring] | tokens p sus returns the list of tokens in sus , from left to
right, where a token is a non-empty maximal substring of sus not
containing any delimiter, and a delimiter is a character satisfying
p .
| ||
| top [BatStack.Exceptionless] | |||
| top [BatStack] | top s returns the topmost element in stack s ,
or
| ||
| top [BatQueue] | top is a synonym for peek .
| ||
| total_size [BatMarshal] |
See
Marshal.header_size .
| ||
| transfer [BatQueue] | transfer q1 q2 adds all of q1 's elements at the end of
the queue q2 , then clears q1 .
| ||
| transform [BatRefList] |
transform all elements in the ref list
using a function.
| ||
| translate [BatSubstring] | translate f sus applies f to every character of sus , from
left to right, and returns the concatenation of the results.
| ||
| transpose [BatList] |
Transposes a list of lists, turning rows of the input into columns
of the output and vice versa.
| ||
| trim [BatSubstring] |
removes whitespace from left and right ends of input
| ||
| trim [BatString.Cap] | |||
| trim [BatString] |
Return a copy of the argument, without leading and trailing
whitespace.
| ||
| trim [BatBytes] |
Return a copy of the argument, without leading and trailing
whitespace.
| ||
| triml [BatSubstring] | triml k sus returns sus less its leftmost k characters; or the
empty string at the end of sus if it has less than k characters.
| ||
| trimr [BatSubstring] | trimr k sus returns sus less its rightmost k characters; or the
empty string at the beginning of sus if it has less than k
characters.
| ||
| truncate [BatUnix.LargeFile] | |||
| truncate [BatUnix] |
Truncates the named file to the given size.
| ||
| try_lock [BatRMutex] |
Same as
RMutex.lock , but does not suspend the calling thread if
the mutex is already locked: just return false immediately
in that case.
| ||
| try_lock [BatConcurrent.BaseLock] | |||
| try_lock [BatConcurrent.Lock] | |||
U | |||
| uget [BatUref] | uget ur returns the value stored in the uref ur .
| ||
| umask [BatUnix] |
Set the process's file mode creation mask, and return the previous
mask.
| ||
| uncapitalize [BatString.Cap] | |||
| uncapitalize [BatString] |
Return a copy of the argument, with the first character set to lowercase.
| ||
| uncapitalize [BatBytes] |
Return a copy of the argument, with the first byte set to
lowercase.
| ||
| uncapitalize_ascii [BatString] |
Return a copy of the argument, with the first character set to lowercase,
using the US-ASCII character set.
| ||
| uncapitalize_ascii [BatBytes] |
Return a copy of the argument, with the first character set to lowercase,
using the US-ASCII character set.
| ||
| uncombine [BatLazyList] |
Divide a list of pairs into a pair of lists.
| ||
| uncombine [BatEnum] | uncombine is the opposite of combine
| ||
| uncurry [BatTuple.Tuple5] | |||
| uncurry [BatTuple.Tuple4] | |||
| uncurry [BatTuple.Tuple3] | |||
| uncurry [BatTuple.Tuple2] | |||
| uncurry [BatPervasives] |
Convert a function which accepts a two arguments into a function
which accepts a pair of arguments.
| ||
| uncurry [BatInnerPervasives] | |||
| undef [BatGlobal] |
Reset the global value contents to undefined.
| ||
| undefined [BatPervasives] |
The undefined function.
| ||
| unfold [BatList] | unfold init f creates a list by repeatedly applying f to the
second element of its own result, starting from the initial value
init .
| ||
| unfold [BatLazyList] | unfold data next creates a (possibly infinite) lazy list from
the successive results of applying next to data , then to the
result, etc.
| ||
| unfold [BatEnum.Labels] | |||
| unfold [BatEnum] |
As
from_loop , except uses option type to signal the end of the enumeration.
| ||
| unfold_exc [BatList] |
Creates a list containing the results of sequential calls
to
f() .
| ||
| union [BatSet.PSet] | union s t returns the union of s and t - the set containing
all elements in either s and t .
| ||
| union [BatSet.S] |
Set union.
| ||
| union [BatSet] | union s t returns the union of s and t - the set containing
all elements in either s and t .
| ||
| union [BatMap.PMap] | union m1 m2 merges two maps, using the comparison function of
m1 .
| ||
| union [BatMap] | union m1 m2 merges two maps, using the comparison function of
m1 .
| ||
| union [BatISet] |
Compute the union of two sets.
| ||
| union [BatIMap] |
Merge two maps, giving a value
| ||
| union [BatBitSet] | union s t return the union of sets s and t .
| ||
| uniq [BatEnum.Labels] | |||
| uniq [BatEnum] | uniq e returns a duplicate of e with repeated values
omitted (similar to unix's uniq command).
| ||
| uniq_by [BatEnum] | uniqq cmp e behaves as uniq e except it allows to specify a
comparison function.
| ||
| uniqq [BatEnum] | uniqq e behaves as uniq e except it uses physical equality
to compare consecutive elements.
| ||
| unique [BatPervasives] |
Returns an unique identifier every time it is called.
| ||
| unique [BatList] | unique cmp l returns the list l without any duplicate element.
| ||
| unique [BatLazyList] | unique cmp l returns the list l without any duplicate element.
| ||
| unique [BatInnerPervasives] | |||
| unique_cmp [BatList] |
As
unique , except comparator parameter returns an int.
| ||
| unique_eq [BatLazyList] |
as
unique except only uses an equality function.
| ||
| unique_hash [BatList] |
As
unique , except uses a hash table to cut down the expected
runtime to linear, assuming a good hash function.
| ||
| unique_value [BatInnerPervasives] | |||
| unit_big_int [BatBig_int] |
The big integer
1 .
| ||
| unite [BatUref] | unite ~sel ur1 ur2 unites the urefs ur1 and ur2 , selecting
the result of sel (uget ur1) (uget ur2) for the contents of
the resulting united uref.
| ||
| unite [BatBitSet] | unite s t sets s to the union of the sets s and t .
| ||
| unix [BatSys] |
True if
Sys.os_type = "Unix" .
| ||
| unix_perm [BatFile] |
Create a permission from a Unix-style octal integer.
| ||
| unlink [BatUnix] |
Removes the named file
| ||
| unlock [BatRMutex] |
Unlock the given mutex.
| ||
| unlock [BatConcurrent.BaseLock] | |||
| unlock [BatConcurrent.Lock] | |||
| unpack [BatInt32] | unpack str off reads 4 bytes from string str starting at
offset off as a little-endian int32
| ||
| unpack_big [BatInt32] | unpack str off reads 4 bytes from string str starting at
offset off as a big-endian int32
| ||
| unregister_formatter [BatLogger] | unregister_formatter name unregisters a named log formatter.
| ||
| unsafe_get [BatDynArray] | |||
| unsafe_get [BatBigarray.Array3] |
Like
Bigarray.Array3.get , but bounds checking is not always
performed.
| ||
| unsafe_get [BatBigarray.Array2] |
Like
Bigarray.Array2.get , but bounds checking is not always
performed.
| ||
| unsafe_get [BatBigarray.Array1] |
Like
Bigarray.Array1.get , but bounds checking is not always performed.
| ||
| unsafe_get [BatArray] | |||
| unsafe_of_string [BatBytes] |
Unsafely convert a shared string to a byte sequence that should
not be mutated.
| ||
| unsafe_set [BatDynArray] | |||
| unsafe_set [BatBigarray.Array3] |
Like
Bigarray.Array3.set , but bounds checking is not always
performed.
| ||
| unsafe_set [BatBigarray.Array2] |
Like
Bigarray.Array2.set , but bounds checking is not always
performed.
| ||
| unsafe_set [BatBigarray.Array1] |
Like
Bigarray.Array1.set , but bounds checking is not always performed.
| ||
| unsafe_set [BatArray] | |||
| unsafe_substring [BatSubstring] | unsafe_substring behaves like substring , but does not perform
any sanity check on the position and length.
| ||
| unsafe_to_string [BatBytes] |
Unsafely convert a byte sequence into a string.
| ||
| unset [BatBitSet] | unset s n sets the n th-bit in the bitset s to false.
| ||
| until [BatISet] | until x t returns the portion of t in the range min_int, x
| ||
| until [BatIMap] |
Return the sub-map of bindings in the range
min_int, x
| ||
| update [BatSet.PSet] | update x y s replace x by y in s .
| ||
| update [BatSet.S] | update x y s replace x by y in s .
| ||
| update [BatSet] | update x y s replace x by y in s .
| ||
| update [BatMap.PMap] | update k1 k2 v2 m replace the previous binding of k1 in m by
k2 associated to v2 .
| ||
| update [BatMap.S] | update k1 k2 v2 m replace the previous binding of k1 in m by
k2 associated to v2 .
| ||
| update [BatMap] | update k1 k2 v2 m replace the previous binding of k1 in m by
k2 associated to v2 .
| ||
| update [BatFingerTree] | update t i f returns t where the i -th element is now f (get i t) .
| ||
| uppercase [BatString.Cap] | |||
| uppercase [BatString] |
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.
| ||
| uppercase [BatCharParser] |
Recognizes one upper-case ASCII character, including
accentuated characters.
| ||
| uppercase [BatChar] |
Convert the given character to its equivalent uppercase character.
| ||
| uppercase [BatBytes] |
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.
| ||
| uppercase_ascii [BatString] |
Return a copy of the argument, with all lowercase letters
translated to uppercase, using the US-ASCII character set.
| ||
| uppercase_ascii [BatChar] |
Convert the given character to its equivalent uppercase character,
using the US-ASCII character set.
| ||
| uppercase_ascii [BatBytes] |
Return a copy of the argument, with all lowercase letters
translated to uppercase, using the US-ASCII character set.
| ||
| uppercase_latin1 [BatCharParser] |
Recognizes one upper-case Latin-1 character, including
accentuated characters.
| ||
| uref [BatUref] | uref x allocates a new uref and places the value x in it.
| ||
| usage [BatOptParse.OptParser] |
Display the usage message to the channel
chn (default is
Pervasives.stdout ) and return.
| ||
| user_exec [BatFile] |
Give the current user permission to execute the file.
| ||
| user_read [BatFile] |
Give the current user permission to read the file.
| ||
| user_write [BatFile] |
Give the current user permission to write the file
| ||
| uset [BatUref] | uset ur x updates the contents of ur with x .
| ||
| utimes [BatUnix] |
Set the last access time (second arg) and last modification time
(third arg) for a file.
| ||
V | |||
| validate [BatUTF8] | validate s
successes if s is valid UTF-8, otherwise raises Malformed_code.
| ||
| value_option [BatOptParse.Opt] |
Make an option which takes a single argument.
| ||
| values [BatMap.PMap] |
Return an enumeration of al the values of a map.
| ||
| values [BatMap.S] |
Return an enumeration of al the values of a map.
| ||
| values [BatMap] |
Return an enumeration of al the values of a map.
| ||
| values [BatHashtbl.Cap] | |||
| values [BatHashtbl.S] | |||
| values [BatHashtbl] |
Return an enumeration of all the values of a hashtable.
| ||
| verify_arg [BatPervasives] | verify_arg condition message will raise Invalid_argument message if
condition is false, otherwise it does nothing.
| ||
| version [BatteriesConfig] | |||
| version_option [BatOptParse.StdOpt] | version_option f returns the standard version option which
displays the string returned by f () (and nothing else) on
standard output and exits.
| ||
W | |||
| wait [BatUnix] |
Wait until one of the children processes die, and return its pid
and termination status.
| ||
| waitpid [BatUnix] |
Same as
Unix.wait , but waits for the child process whose pid is given.
| ||
| while_do [BatEnum] | while_do cont f e is a loop on e using f as body and cont as
condition for continuing.
| ||
| whitespace [BatCharParser] |
Recognizes white-space
| ||
| whitespaces [BatGenlex.Languages.Make] | |||
| win32 [BatSys] |
True if
Sys.os_type = "Win32" .
| ||
| with_dispose [BatPervasives] | with_dispose dispose f x invokes f on x , calling dispose x
when f terminates (either with a return value or an
exception).
| ||
| with_dispose [BatInnerPervasives] | |||
| with_file_in [BatFile] | with_file_in file_name f opens the file named file_name for reading,
invokes f to process the contents of that file then, once f has returned
or triggered an exception, closes the file before proceeding.
| ||
| with_file_out [BatFile] | with_file_out file_name f opens the file named file_name for writing,
invokes f to write onto that file then, once f has returned or triggered
an exception, closes the file before proceeding.
| ||
| with_label [BatReturn] |
as
label
| ||
| with_log [BatLogger] | with_log logger level event_fun ?result body logs an event
before and after calling body () .
| ||
| with_temporary_out [BatFile] | with_temporary_out f opens a new temporary file for writing, invokes f with
to write onto that file then, once f has returned or triggered an exception,
closes the file before proceeding.
| ||
| word_size [BatteriesConfig] | |||
| word_size [BatSys] |
Size of one word on the machine currently executing the OCaml
program, in bits: 32 or 64.
| ||
| would_at_fail [BatLazyList] | would_at_fail l n returns true if l contains strictly less
than n elements, false otherwise
| ||
| wrap [BatPervasives] | wrap f x wraps a function that would normally throw an exception
on failure such that it now returns a result with either the Ok
return value or the Bad exception.
| ||
| wrap [BatOptParse.Formatter] | wrap text width reflows the given text paragraph into lines
of width at most width (lines may exceed this if the are
single words that exceed this limit).
| ||
| wrap [BatInnerPervasives] | |||
| wrap_in [BatInnerIO] |
Fully create an input reading from other inputs by giving all the needed functions.
| ||
| wrap_out [BatInnerIO] |
Fully create an output that writes to one or more underlying outputs.
| ||
| write [BatUnix] | write fd buff ofs len writes len characters to descriptor
fd , taking them from string buff , starting at position ofs
in string buff .
| ||
| write [BatInnerIO] |
Write a single char to an output.
| ||
| write [BatIO] |
Write a single char to an output.
| ||
| write_byte [BatInnerIO] |
Write an unsigned 8-bit byte.
| ||
| write_char [BatText] |
Write one uchar to a UTF-8 encoded output.
| ||
| write_double [BatInnerIO] |
Write an IEEE double precision floating point value.
| ||
| write_float [BatInnerIO] |
Write an IEEE single precision floating point value.
| ||
| write_i16 [BatInnerIO] |
Write a signed 16-bit word.
| ||
| write_i32 [BatInnerIO] |
Write a signed 32-bit integer.
| ||
| write_i64 [BatInnerIO] |
Write an OCaml int64.
| ||
| write_line [BatText] |
Write one line onto a UTF-8 encoded output, followed by a \n.
| ||
| write_line [BatInnerIO] |
Write a line and append a LF (it might be converted
to CRLF on some systems depending on the underlying BatIO).
| ||
| write_lines [BatFile] | write_lines name lines writes strings given by lines to file name with newline character appended to each line.
| ||
| write_only [BatString.Cap] |
Drop capabilities to write only.
| ||
| write_only [BatHashtbl.Cap] |
Drop to write-only permissions.
| ||
| write_only [BatArray.Cap] |
Drop to write-only permissions.
| ||
| write_real_i32 [BatInnerIO] |
Write an OCaml int32.
| ||
| write_string [BatInnerIO] |
Write a string and append an null character.
| ||
| write_substring [BatUnix] |
Same as
write , but take the data from a string instead of a byte
sequence.
| ||
| write_text [BatText] |
Write a character text onto a UTF-8 encoded output.
| ||
| write_ui16 [BatInnerIO] |
Write an unsigned 16-bit word.
| ||
X | |||
| xor_big_int [BatBig_int] |
Bitwise logical ``exclusive or''.
| ||
Z | |||
| zero [BatNumber.NUMERIC_BASE] | |||
| zero [BatNumber.Numeric] | |||
| zero [BatNum] |
Usual operations
| ||
| zero [BatNativeint] |
The native integer 0.
| ||
| zero [BatInt64] |
The 64-bit integer 0.
| ||
| zero [BatInt32] |
The 32-bit integer 0.
| ||
| zero [BatInt.Safe_int] |
The integer
0 .
| ||
| zero [BatInt] |
The integer
0 .
| ||
| zero [BatFloat.Safe_float] |
Floating number zero.
| ||
| zero [BatFloat] |
Floating number zero.
| ||
| zero [BatComplex] |
The complex number
0 .
| ||
| zero [BatBool] | |||
| zero [BatBig_int] | |||
| zero_big_int [BatBig_int] |
The big integer
0 .
| ||
| zero_plus [BatParserCo] |
Accept a (possibly empty) list of expressions.
|


@sveltejs/gl changelog
0.0.37
- Fix
geometry.update(...)
when length changes
0.0.36
- Squelch missing prop warning
0.0.35
- Use
translate3d
with overlays, add will-change: transform
0.0.34
- Add
doubleSided
property to meshes
0.0.33
- Use
requestAnimationFrame
to batch renders
0.0.32
- Add
geometry.update(key, data)
method
0.0.31
- Squelch some prop warnings
- Add
GL.dodecahedron
geometry
0.0.30
- Add
snap
prop to <Overlay>
components, to snap to pixel
0.0.29
- Default to sensible blending
0.0.28
- Fix
alpha
uniform behaviour in default shader when using colormap
- Fix rendering of non-indexed geometry
0.0.27
- Add
<GL.Point>
component
- Add
emissive
and emissivemap
uniforms to default material
0.0.26
- Fix sorting of transparent meshes (#16)
0.0.25
- Lose context when scene is destroyed
0.0.24
- Work around apparent IntersectionObserver bug
0.0.23
- Render on entering viewport
0.0.22
- Add an orthographic camera
- Pass width and height into scene
- Sort transparent objects
0.0.21
- Make image loading scene-independent
0.0.20
- Add
fog
property to <Scene>
background
property on <Scene>
now takes an [r,g,b]
array or 0xrrggbb
value
backgroundOpacity
property controls background opacity
0.0.19
- Pass through
depthTest
and blend
- Allow more than one texture
0.0.18
0.0.17
- Default to crossOrigin images
0.0.16
- Allow meshes to receive frag, vert, blend properties
0.0.15
- Declare extensions first, due to change in Chrome 75
0.0.14
- Allow
pixelRatio
to be specified
0.0.13
- Fetch image data in
cors
mode
0.0.12
- Only update when canvas is visible
0.0.10-11
0.0.9
- Support primitives other than lines
0.0.8
0.0.7
- Default to
highp
floats
- Work around some shader bug I don’t understand
- Depth test by default
0.0.6
- Fix serialization of minified code sent to workers
0.0.5
- Add
<Target>
component
- Add
user-select: none
on overlays
- Load and decode images off the main thread
- Allow depth testing to be disabled per-material
0.0.4
- Bump mapping
- New
Sphere
implementation
0.0.3
- Don’t reinitialise element buffers unnecessarily
- Enable
minDistance
and maxDistance
on OrbitControls
0.0.2
- Throttle OrbitControls events
- Add touch support to OrbitControls
0.0.1
- First experimental release


These functions are wrappers around their `dplyr` equivalents that set Spark SQL-compliant values for the `suffix` argument by replacing dots (`.`) with underscores (`_`). See [join] for a description of the general purpose of the functions.
# S3 method for tbl_spark inner_join( x, y, by = NULL, copy = FALSE, suffix = c("_x", "_y"), auto_index = FALSE, ..., sql_on = NULL ) # S3 method for tbl_spark left_join( x, y, by = NULL, copy = FALSE, suffix = c("_x", "_y"), auto_index = FALSE, ..., sql_on = NULL ) # S3 method for tbl_spark right_join( x, y, by = NULL, copy = FALSE, suffix = c("_x", "_y"), auto_index = FALSE, ..., sql_on = NULL ) # S3 method for tbl_spark full_join( x, y, by = NULL, copy = FALSE, suffix = c("_x", "_y"), auto_index = FALSE, ..., sql_on = NULL )
| x | A pair of lazy data frames backed by database queries. |
|---|---|
| y | A pair of lazy data frames backed by database queries. |
| by | A character vector of variables to join by. If To join by different variables on To join by multiple variables, use a vector with length > 1.
For example, To perform a cross-join, generating all combinations of |
| copy | If This allows you to join tables across srcs, but it's potentially expensive operation so you must opt into it. |
| suffix | If there are non-joined duplicate variables in |
| auto_index | if |
| ... | Other parameters passed onto methods. |
| sql_on | A custom join predicate as an SQL expression.
Usually joins use column equality, but you can perform more complex
queries by supply |


Royals is an organization created by students to get to their goals.
We are the elite of the school.
We act when no ones there to act.
A tournament between classmates and teachers.
Organized for fun to win crazy prizes and tons of fame.
Want to join ? Click here!
To follow the game Click here.
Hungry as hell ? Wanna support us ?
We're all over the place selling food and drinks.
Wanna know when ? Ask one of the royals!
The upcoming weeks we are gonna play tons of music.
Want your song to be played for everyone to hear?
You can find us on the playground during the breaks and it only costs 50 cents!
For the first version of the website :


In order to complete this HIT, please answer the following questions about the dialogue that you just completed. Please do not include any personally identifying information about yourself (or any other person) in any open text questions on the survey.
Part 1: To what extent do you agree with these statements?


Making the suggstion list look fancy.
Here we are not matching on the beginning of the index. Note that completion isn't sane in such a case.
The list of suggestions should appear to the right of the input element.
This is a deprecated part of the API, included here to regression test against
Using autocomplete directly in this way is now deprecated.
Using autocomplete directly in this way is now deprecated.
This is the preferred way to do autocomplete.
Lorem ipsum clee chea saeff a. Enfreep gleepi whop heeth zogh, kucka thee shoogh ne gead ca. Hegh en, vee, fu dreati whim breest taeth ste faeck blea blea dro, plan, rae ha su koo, jooff wreap ho I gla trag ir slae ripi enmaev logher moo pog queeth I slaeing whooth bean draem, ir paers. Gu perki, ghee plae kae. Za beeing hews, bae posting ri blorling ceack wrirl, unjaeh musher fri. A, sla frashe hi; Rae bla ro I whad. Stushe I dust whea droo lae, I infrap truroer bloos troshen pi, troo cae tis, lurth gleth, precuth sea so, wu queaing see quu wha cli pla jockal cresh se la. Doopi, ches shoorl grae vaell hi jeah, op gle prega cloo, quath ke inlockall dreaw. Rea wreela, de, op, droo frae vi, furd stae du drist purth ne draing pij quoo.
Tord hea op, wra en, zash treeb; The perbrala cheath quee taed quaen, ghor sod; Blea bu a preree, glurl unseashew neeti chee fri bree la, bagh! Gi, concroshegher cuh unsheerd bloing, stohus, ju zem. Ruv faert, ungrupi, tesum. En degleed po ir stea. Conplerth a brogs, do.


 Sorry about that.
Maybe you'd like to try the home page?


App Services (Usergrid) Javascript SDK
<< examples
Dogs
Dogs is a simple application that shows how to create entities and collecitons, how to iterate through results, and how to display larger result sets in a paged format.
New Dog
No dogs yet!
Previous
Next
Dogs
Use this form to create a new dog.
Dog Name
Please correct the error
Create dog
Cancel


From a festival of Christmas Trees to the big band sounds of 16 Men Swinging - Here are five things to do in Blackpool today - Thursday, November 21, 2019
Each day we'll bring you a selection of shows and events happening in Blackpool that you won't want to miss. So if you're planning an impromptu night here are today's choices:
by Suzanne SteedmanChristmas Tree Festival
The annual event showcases dozens of uniquely decorated trees presented by local organisations, charities and businesses. Visitors to the event can vote for their favourites to decide the winner of the ‘BestTree’ prize and also enjoy loads of early festive fun. Derham Lounge, Winter Gardens, Church Street, Blackpool. 11am- 3.30pm. Admission £1.50 adults, children free.
Read more what's on news here
Nativity
A Flint Street Nativity: A fun play for adults and children however please be aware that it contains some very rude words which may not be suitable for the very young. Thornton Little Theatre, Fleetwood Road North, Thornton. 7.30pm.
Music
Les McKeown's Bay City Rollers: Bringing new energy to all the classic hits. Les brings back all the thrill and excitement of Rollermania, performing all the original hits. Viva!, The Promenade, Blackpool.
Big Band
Performed by 16 Men Swinging. Tickets £8 in aid of Trinity Hospice. The Glendower Hotel, St Annes. 8pm-10pm. Ring 01253 729097.
Coffee Morning
Friends of The Grand welcome guest speaker director Andy Vitolo on ‘Reminiscences and Visions’. The Grand Theatre, Church Street, Blackpool. 10.30am.