FSharp.PowerPack.Compatibility

The spec value describes the action of the argument, and whether it expects a following parameter.

"usage specs use" prints the help for each argument.

"parse specs f use" parses the arguments given by Sys.argv according to the argument processing specifications "specs". Arguments begin with "-". Non-arguments are passed to "f" in order. "use" is printed as part of the usage line if an error occurs. Permitted arguments are specified using triples: (arg, action, help). Actions are: Unit(f): call f, no subseq. arg Set(br): set ref to 'true', no subseq. arg. Clear(br): set ref to 'false, no subseq. arg. String(f): pass the subseq. arg to f Int(f): pass the subseq. arg to f Float(f): pass the subseq. arg to f Rest(f): pass all subseq. args to f in order

A simple command-line argument processor.

As for Array2D.pin, except that the caller is responsible for calling Free on the returned GCHandle in order to release the pin.

Pin the given array for the duration of a single call to the given function. A native pointer to the first element in the array is passed to the given function. Cleanup the GCHandle associated with the pin when the function completes, even if an exception is raised.

Apply a function to each element of the array, threading an accumulator argument through the computation. If the input function is <c>f</c> and the elements are <c>i0...iN</c> then computes <c>f i0 (...(f iN s))</c>

Create a jagged 2 dimensional array. Synonym for createJaggedMatrix.

As for Array.pin, except that the caller is responsible for calling Free on the returned GCHandle in order to release the pin.

Like reduceBack, but return both the intermediary and final results

Like reduce, but return both the intermediary and final results

Is an element in the array, uses (=) equality.

Create a jagged 2 dimensional array.

Compatibility operations on arrays.

Read the given number of bytes as ASCII and add the resulting string to the buffer. Warning: this assumes an ASCII encoding for the I/O channel, i.e. it uses Pervasives.really_input and then use ascii_to_string to produce the string to add.

Clears the buffer (same as Buffer.clear).

Number of characters in the buffer.

Create a buffer with suggested size.

Gets the string built from the buffer.

Clears the buffer.

Given a string, start position and length add that substring to the buffer.

Add string to the buffer.

Add character to the buffer.

Add second buffer to the first.

Imperative buffers for building strings, a shallow interface to <c>System.Text.StringBuilder</c>

Converts a byte to a string

Converts a string to a byte

Converts a byte to an unsigned 32-bit integer

Converts an unsigned 32-bit integer to a byte

Converts a byte to a 16-bit integer

Converts a 16-bit integer to a byte

Converts a byte to a 32-bit integer

Converts a 32-bit integer to a byte

Converts a byte to a 32-bit integer

Converts a 32-bit integer to a byte

Converts a byte to a char

Converts a char to a byte

Shifts the binary representation a by n bits to the right

Shifts the binary representation a by n bits to the left

Combines the binary representation of a and b by bitwise xor

Combines the binary representation of a and b by bitwise or

Returns the bitwise logical negation of a

Combines the binary representation of a and b by bitwise and

Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b

Returns the remainder of a divided by b

Returns a minus b

Returns a multiplied by b

Returns a divided by b

Returns the sum of a and b

Returns the predeccessor of the argument wrapped around 0uy

Returns the successor of the argument wrapped around 255uy

The value one as a System.Byte

The value zero as a System.Byte

Byte (8-bit) operations.

Converts the value of a Unicode character to its uppercase equivalent

Converts the value of a Unicode character to its lowercase equivalent

Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b

Converts the value of the specified Unicode character to the equivalent 32-bit signed integer

Converts the value of the specified 32-bit signed integer to its equivalent Unicode character

Unicode characters, i.e. the <c>System.Char</c> type. see also the operations in <c>System.Char</c> and the <c>System.Text.Encoding</c> interfaces if necessary.

"temp_file f s" returns a hitherto unused new file name. "f" and "s" are hints as to a suitable file name and suffix for the file.

"quote s" is designed for use to quote a filename when using it for a system command. It returns ("\'" ^ s ^ "\'").

Returns true if the path is relative to the current directory but does not begin with an explicit "." or ".."

Is the path is relative to the current directory or absolute.

Return true if the filename has a "." extension

"parent_dir_name" returns the name for the directory above the current directory on this OS.

The name used for the current directory on this OS.

"dirname" and "basename" decompose a filename into a directory name and a filename, i.e. "concat (dirname s) (basename s) = s"

"concat a b" returns System.IO.Path.Combine(a,b), i.e. the two names conjoined by the appropriate directory separator character for this architecture.

Assuming "check_suffix f s" holds, "chop_suffix f s" returns the filename "f" with the suffix "s" removed.

"chop_extension f" removes the extension from the given filename. Raises ArgumentException if no extension is present.

"check_suffix f s" returns true if filename "f" ends in suffix "s", e.g. check_suffix "abc.fs" ".fs" returns true.

Common filename operations. This module is included to make it possible to cross-compile code with other ML compilers. See also <c>System.IO.Path</c>

Converts a 64-bit float to raw 64-bit representation

Converts a raw 64-bit representation to a 64-bit float

Converts a 64-bit float to a string

Converts a string to a 64-bit float

Converts a 64-bit float to a 32-bit float

Converts a 32-bit float to a 64-bit float

Converts a 64-bit float to a 64-bit integer

Converts a 64-bit integer to a 64-bit float

Converts a 64-bit float to a 32-bit integer

Converts a 32-bit integer to a 64-bit float

Converts a 64-bit float to a 32-bit integer

Converts a 32-bit integer to a 64-bit float

Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b

Returns a minus b

Returns -a

Returns a multiplied by b

Returns a divided by b

Returns the sum of a and b

ML-like operations on 64-bit System.Double floating point numbers.

A collection of operations for creating and using hash tables based on particular type-tracked hash/equality functions. Generated by the Hashtbl.Make and Hashtbl.MakeTagged functors. This type is for use when you wish to specify a comparison function once and carry around an object that is a provider of (i.e. a factory for) hashtables that utilize that comparison function. The 'Tag' type parameter is used to track information about the comparison function, which helps ensure that you don't mixup maps created with different comparison functions

OCaml compatible type name, for use when not opening module, e.g. Hashtbl.t

Build a collection of operations for creating and using hashtables based on the given hash/equality functions. This returns a record that contains the functions you use to create and manipulate tables of this kind. The returned value is much like an ML module. You should call Make once for each new pair of key/value types. You may need to constrain the result to be an instantiation of Provider. let MyStringHashProvider : Provider<string,int> = Hashtbl.Make(myStringHash,myStringEq)

Same as Make, except track the comparison function being used through an additional type parameter. To use this function accurately you need to define a new named class that implements IEqualityComparer and pass an instance of that class as the first argument. For example: type MyHasher = class new() = { } interface IEqualityComparer<string> with member self.GetHashCode(x) = ... member self.Equals(x,y) = ... end end let MyStringHashProvider : Hashtbl.Provider<string,int> = Hashtbl.MakeTagged(new MyStringHasher())

Hash on the identity of an object.

Hash on the structure of a value according to the F# structural hashing conventions

Lookup the key's data in the table

Replace the latest binding for the given key

Remove the latest binding for the given key

Test for the existence of any bindings for the given key

Apply the given function to each binding in the hash table

Fold over all bindings

Return all bindings for the given key

Lookup key's data in the table. Raises exception is key not in table, if this could happen you should be using tryFind.

Create a copy of the table. Remember they are imperative and get mutated.

Empty the table.

Create hash table using the given data

Create a hash table using the given data

Add key and data to the table.

Create a hash table with the suggested initial size. Inlined to enable generation of efficient hash routines for the key type in the common case.

Multi-entry hash tables using the structural "hash" and "equals" functions. These tables can be used with keys of any type, but you should check that structural hashing and equality are correct for your key type. Structural hashing is efficient but not a suitable choice in all circumstances, e.g. may not hash efficiently on non-reference types and deeply-structured types. Better efficiency is typically achieved if key types are F#-generated types. These hash tables may map items to multiple keys (see find_all). The implementations are not safe for concurrent reading/writing, and so users of these tables should take an appropriate lock before reading/writing if used in a concurrent setting.

Converts a 32-bit float to a raw 32-bit representation

Converts a raw 32-bit representation to a 32-bit float

Converts a 64-bit float to a raw 32-bit representation

Converts a raw 32-bit representation to a 64-bit float

Converts a 32-bit integer to a string

Converts a string to a 32-bit integer

Converts a 32-bit unsigned integer to a 32-bit integer

Converts a 32-bit unsigned integer to a 64-bit integer

Converts a 64-bit unsigned integer to a 32-bit integer

Converts a 32-bit integer to a 32-bit unsigned integer

Converts a 32-bit unsigned integer to a 32-bit integer

Converts a 32-bit integer to a 32-bit integer (included for ML compatability)

Converts a 32-bit integer to a 32-bit float

Converts a 32-bit float to a 32-bit integer

Converts a 32-bit integer to a 64-bit float

Converts a 64-bit float to a 32-bit integer

Shifts the binary representation a by n bits to the right; high-order bits are zero-filled

Shifts the binary representation a by n bits to the right; high-order empty bits are set to the sign bit

Shifts the binary representation a by n bits to the left

Combines the binary representation of a and b by bitwise xor

Combines the binary representation of a and b by bitwise or

Returns the bitwise logical negation of a

Combines the binary representation of a and b by bitwise and

Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b

Returns a minus b

Returns the remainder of a divided by b

Returns -a

Returns a multiplied by b

Returns a divided by b

Returns the sum of a and b

Returns the absolute value of the argument

Returns the successor of the argument

Returns the smallest 32-bit signed integer

Returns the largest 32-bit signed integer

Returns the predeccessor of the argument

The value minus one as a System.Int32

The value one as a System.Int32

The value zero as a System.Int32

Basic operations on 32-bit integers. The type int32 is identical to <c>System.Int32</c>.

Converts a 64-bit float to a raw 64-bit representation

Converts a raw 64-bit representation to a 64-bit float

Converts a 64-bit integer to a string

Converts a string to a 64-bit integer

Converts a 64-bit integer to a native integer

Converts a native integer to a 64-bit integer

Converts a 64-bit integer to an unsigned 64-bit integer

Converts an unsigned 64-bit integer to a 64-bit integer

Converts a 64-bit integer to a 32-bit integer

Converts a 32-bit integer to a 64-bit integer

Converts a 64-bit integer to a 32-bit integer

Converts a 32-bit integer to a 64-bit integer

Converts a 64-bit integer to a 64-bit float

Converts a 64-bit float to a 64-bit integer

Converts a 64-bit integer to a 32-bit float

Converts a 32-bit float to a 64-bit integer

Shifts the binary representation a by n bits to the right; high-order bits are zero-filled

Shifts the binary representation a by n bits to the right; high-order empty bits are set to the sign bit

Shifts the binary representation a by n bits to the left

Combines the binary representation of a and b by bitwise xor

Combines the binary representation of a and b by bitwise or

Returns the bitwise logical negation of a

Combines the binary representation of a and b by bitwise and

Compares a and b and returns 1 if a > b, -1 if b < a and 0 if a = b

Returns a minus b

Returns the remainder of a divided by b

Returns -a

Returns a multiplied by b

Returns a divided by b

Returns the sum of a and b

Returns the absolute value of the argument

The value minus one as a System.Int64

Returns the smallest 64-bit signed integer

Returns the largest 64-bit signed integer

Returns the successor of the argument

Returns the predeccessor of the argument

The value one as a System.Int64

The value zero as a System.Int64

Basic operations on 64-bit integers. The type int64 is identical to <c>System.Int64</c>.

Build a lazy (delayed) value from the given computation

Check if a lazy (delayed) value has already been computed

Build a lazy (delayed) value from the given pre-computed value.

Build a lazy (delayed) value from the given computation

See Lazy.Force.

ASCII LexBuffers The type "lexbuf" is opaque, but has an internal position information field that can be updated by setting "lexbuf.EndPos", for example if you wish to update the other fields in that position data before or during lexing. You will need to do this if you wish to maintain accurate line-count information. If you do this and wish to maintain strict cross-compiling compatibility with OCamlLex and other tools you may need code to conditionally use lexbuf_set_curr_p when compiling F# code.

same as lexeme_end_p

Return absolute positions into the entire stream of characters

Return the positions stored in the lexbuf for the matched string

Return a character from the matched string, innterpreting the bytes using an ASCII encoding

Return the bytes for the matched string

Return the matched string interpreting the bytes using the given Unicode text encoding

Return the matched string

Fuel a lexer from function that fills an array of bytes up to the given length, returning the number of bytes filled.

Fuel a lexer from an array of bytes

Fuel a lexer from a string, converted to ascii using <c>System.Text.Encoding.ASCII.GetBytes</c>

Fuel a lexer using the given BinaryReader.

Fuel a lexer using the given TextReader or StreamReader. The characters read are decoded to bytes using the given encoding (e.g. System.Text.Encoding.ASCII) and the bytes presented to the lexer. The encoding used to decode the characters is associated with the expectations of the lexer (e.g. a lexer may be constructed to accept only ASCII or pseudo-UTF8 bytes) and will typically be different to the encoding used to decode the file.

Fuel a lexer using the given in_channel. The bytes are read using Pervasives.input. If the in_channel is a textual channel the bytes are presented to the lexer by decoding the characters using System.Text.Encoding.ASCII.

Remove all input, though don't discard the except the current lexeme

Lexing: ML-like lexing support This file maintains rough compatibility for lexbuffers used by some ML laxer generators. The lexbuf carries an associated pair of positions. Beware that only the "cnum" (absolute character number) field is automatically updated as each lexeme is matched. Upon each successful match the prior end position is transferred to be the start position and a new start position is allocated with an updated pos_cnum field.

Return the tail of the list. Raises <c>System.ArgumentException</c> if <c>list</c> is empty

Return the first element of the list. Raises <c>System.ArgumentException</c> if <c>list</c> is empty

"rev_append l1 l2" evaluates to "append (rev l1) l2"

"rev_map2 f l1 l2" evaluates to "map2 f (rev l1) (rev l2)"

"rev_map f l1" evaluates to "map f (rev l1)"

Return true if the list is not empty.

See <c>mem</c>, but uses the physical equality operator (==) for equality tests.

See <c>remove_assoc</c>, but uses the physical equality operator (==) for equality tests.

See <c>mem_assoc</c>, but uses the physical equality operator (==) for equality tests.

See <c>try_assoc</c>, but uses the physical equality operator (==) for equality tests.

See <c>assoc</c>, but uses the physical equality operator (==) for equality tests

Remove pair for key from the association list (if it's there).

Does the key have pair in the association list?

Lookup key's data in association list, uses (=) equality, returning "Some data" or "None".

Lookup key's data in association list, uses (=) equality. Raise <c>System.IndexOutOfRangeException</c> exception if key not found, in which case you should typically use <c>try_assoc</c> instead.

Is an element in the list. Elements are compared using generic equality.

Like reduceBack, but return both the intermediary and final results

Like reduce, but return both the intermediary and final results

Compatibility operations on lists.

A provider for creating and using maps based on a particular comparison function. The 'Tag type parameter is used to track information about the comparison function.

A functor to build a collection of operations for creating and using maps based on the given comparison function. This returns a record that contains the functions you use to create and manipulate maps of this kind. The returned value is much like an ML module. Language restrictions related to polymorphism may mean you have to create a new instantiation of for each toplevel key/value type pair. To use this function you need to define a new named class that implements IComparer and pass an instance of that class as the first argument. For example: type MyComparer = new() = { } interface IComparer<string> with member self.Compare(x,y) = ... let MyStringMapProvider : Map.Provider < string,int > = Map.MakeTagged(new MyComparer())

Negation of Obj.eq (i.e. reference/physical inequality)

See Microsoft.FSharp.Core.LanguagePrimitives.PhysicalEquality

See Microsoft.FSharp.Core.Operators.box

See Microsoft.FSharp.Core.Operators.unbox

You can initialize error recovery by raising the Parse_error exception.

Parsing: parser support for parsers produced by fsyacc. Parsers generated by fsyacc provide location information within parser actions. However that information is not available globally, but rather is accessed via the functions available on the following local variable which is available in all parser actions: parseState : 'a Microsoft.FSharp.Text.Parsing.IParseState However, this is not compatible with the parser specifications used with ocamlyacc and similar tools, which make a single parser state available globally. If you wish to use a global parser state (e.g. so your code will cross-compile with OCaml) then you can use the functions in this file. You will need to either generate the parser with '--ml-compatibility' option or add the code Parsing.set_parse_state parseState; at the start of each action of your grammar. The functions below simply report the results of corresponding calls to the latest object specified by a call to set_parse_state. Note that there could be unprotected multi-threaded concurrent access for the parser information, so you should not in general use these functions if there may be more than one parser active, and should instead use the functions directly available from the parseState object.

An pseudo-abstraction over binary and textual output channels. OCaml-compatible channels conflate binary and text IO, and for this reasons their use from F# is somewhat deprecated The direct use of System.IO StreamWriter, TextWriter and BinaryWriter objects is preferred, e.g. see System.IO.File.CreateText). Well-written OCaml code that simply opens either a channel in text or binary mode and then does text or binary I/O using the OCaml functions will work, though care must be taken with regard to end-of-line characters (see output_char below). This library pretends that an out_channel is just a System.IO.TextWriter. Channels created using open_out_bin maintain a private System.IO.BinaryWriter, which will be used whenever do I/O using this channel.

A pseudo-abstraction over binary and textual input channels. OCaml-compatible channels conflate binary and text IO, and for this reasons their use from F# is somewhat deprecated (direct use of System.IO StreamReader, TextReader and BinaryReader objects is preferred, e.g. see System.IO.File.OpenText). Well-written OCaml-compatible code that simply opens either a channel in text or binary mode and then does text or binary I/O using the OCaml-compatible functions below will work, though care must be taken with regard to end-of-line characters (see input_char below). This library pretends that an in_channel is just a System.IO.TextReader. Channel values created using open_in_bin maintain a private System.IO.BinaryReader, which will be used whenever you do I/O using this channel. InChannel.of_BinaryReader and InChannel.of_StreamReader allow you to build input channels out of the corresponding .NET abstractions.

This type is present primarily for compatibility with other versions of ML. When not cross-compiling we recommend using the .NET I/O libraries

Throw an <c>KeyNotFoundException</c> exception

Throw an ArgumentException

Read a line from the console, without the end-of-line character.

Read an integer from the console.

Read a floating point number from the console.

Print a character to the stderr stream

Flush all pending output on the channel to the physical output device.

Set the binary mode. If the binary mode is changed from "true" to "false" then a StreamWriter is created to write the binary stream. The StreamWriter uses the default text encoding System.Text.Encoding.Default.

Set the current position in the output channel, measured from the start of the channel.

Return the current position in the output channel, measured from the start of the channel. Not valid on all channels.

Serialize the given value to the output channel.

Write the given Unicode string to the output channel. See output_char for the treatment of '\n' characters within the string.

Write the given Unicode character to the output channel. If the output channel is a binary stream and the UTF-16 value of the Unicode character is greater than 255 then ArgumentException is thrown. No CRLF translation is done on output. That is, if the output character is '\n' (LF) characters they will not be written as '\r\n' (CRLF) characters, regardless of whether the underlying operating system or output stream uses CRLF as the default line-feed character.

Write the given byte to the output channel. No CRLF translation is performed.

Write the given integer to the output channel in binary format. Only valid on binary channels.

Write the given range of bytes to the output channel.

Return the length of the output channel. Raise an exception if not an app

Close the given output channel

Open the given file to write in the mode according to the specified flags

Open the given file to write in binary-mode

Open the given file to write in text-mode using the System.Text.Encoding.Default encoding See output_char for a description of CR-LF translation done on output.

Set the binary mode to true or false. If the binary mode is changed from "true" to "false" then a StreamReader is created to read the binary stream. The StreamReader uses the default text encoding System.Text.Encoding.Default

Reads bytes from the channel. Blocks if the bytes are not available. For text channels this only accepts UTF-16 bytes with an encoding less than 256. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.

Reads bytes from the channel. Blocks if the bytes are not available. See 'input' for treatment of text channels. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.

Report the current position in the input channel

Input a single serialized value from a binary stream. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.

Input a single line. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.

Input a single character. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.

Input a single byte. For text channels this only accepts characters with a UTF16 encoding that fits in a byte, e.g. ASCII. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.

Input a binary integer from a binary channel. Compatible with output_binary_int.

Attempt to input characters from a channel. Does not block if inpout is not available. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached. No CRLF translation is done on input, even in text mode. That is, if an input file has '\r\n' (CRLF) line terminators both characters will be seen in the input.

Attempt to input the given number of bytes from the channel, writing them into the buffer at the given start position. Does not block if the bytes are not available. The use of this function with a channel performing byte-to-character translation (e.g. one created with open_in, open_in_utf8 or open_in_encoded, or one or built from a StreamReader or TextReader) is not recommended. Instead, open the channel using open_in_bin or InChannel.of_BinaryReader. If used with a StreamReader channel, i.e. one created using open_in, open_in_utf8 or open_in_encoded, or one or built from a StreamReader, this function reads bytes directly from the underlying BaseStream. This may not be appropriate if any other input techniques are being used on the channel. If used with a TextReader channel (e.g. stdin), this function reads characters from the stream and then fills some of the byte array with the decoding of these into bytes, where the decoding is performed using the System.Text.Encoding.Default encoding Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.

Return the length of the input channel

Close the channel

Open the given file in the mode specified by the given flags

Open the given file to read in binary-mode

Open the given file to read. In the absence of an explicit encoding (e.g. using Open_encoding) open_in uses the default text encoding (System.Text.Encoding.Default). If you want to read a file regardless of encoding then you should use binary modes. Note that .NET's "new StreamReader" function defaults to use a utf8 encoding, and also attempts to determine an automatic encoding by looking for "byteorder-marks" at the head of a text file. This function does not do this. No CR-LF translation is done on input.

This value is present primarily for compatibility with other versions of ML

This value is present primarily for compatibility with other versions of ML The smallest value that when added to 1.0 gives a different value to 1.0

This value is present primarily for compatibility with other versions of ML The lowest non-denormalized positive IEEE64 float

This value is present primarily for compatibility with other versions of ML The highest representable positive value in the 'float' type

This value is present primarily for compatibility with other versions of ML. In F# the overloaded operators may be used.

This value is present primarily for compatibility with other versions of ML

The exception thrown by <c>invalid_arg</c> and misues of F# library functions

Negation on integers of the 'int' type

The highest representable value in the 'int' type

The lowest representable value in the 'int' type

n+1 (no overflow checking)

n-1 (no overflow checking)

1D Array element set-accessor ('setter')

1D Array element get-accessor ('getter')

Negation of the '==' operator, see also Obj.eq

Reference/physical equality. True if boxed versions of the inputs are reference-equal, OR if both are value types and the implementation of Object.Equals for the type of the first argument returns true on the boxed versions of the inputs. In normal use on reference types or non-mutable value types this function has the following properties: - returns 'true' for two F# values where mutation of data in mutable fields of one affects mutation of data in the other - will return 'true' if (=) returns true - hashq will return equal hashes if (==) returns 'true' The use on mutable value types is not recommended.

The exception thrown by 'assert' failures. A future release of F# may map this exception to a corresponding .NET exception.

Non-exhaustive match failures will raise Match failures A future release of F# may map this exception to a corresponding .NET exception.

The type of simple immutable lists

The type of None/Some options

The type of pointers to mutable reference cells

Concatenate two lists.

Concatenate two strings. The overlaoded operator '+' may also be used.

Exit the current hardware isolated process, if security settings permit, otherwise raise an exception. Calls System.Environment.Exit.

Increment a mutable reference cell containing an integer

Decrement a mutable reference cell containing an integer

Throw an exception

Throw a 'Failure' exception

Create a mutable reference cell

Assign to a mutable reference cell

Dereference a mutable reference cell

Absolute value of the given integer

The "hash" function is a structural hash function. It is designed to return equal hash values for items that are equal according to the polymorphic equality function Pervasives.(=) (i.e. the standard "=" operator).

Minimum based on structural comparison

Maximum based on structural comparison

Structural comparison

Structural greater-than-or-equal

Structural greater-than

Structural equality

Structural inequality

Structural less-than-or-equal comparison

Structural less-than comparison

Pervasives: Additional OCaml-compatible bindings

Compatibility module to display data about exceptions.

Simple operations on signed bytes

A collection of operations for creating and using sets based on a particular comparison function. The 'Tag' type parameter is used to track information about the comparison function.

A functor to build a collection of operations for creating and using sets based on the given comparison function. This returns a record that contains the functions you use to create and manipulate maps of this kind. The returned value is much like an ML module. To use this function you need to define a new named class that implements IComparer and pass an instance of that class as the first argument. For example: type MyComparer() = interface IComparer<string> with member self.Compare(x,y) = ... let MyStringSetProvider = Set.MakeTagged(new MyComparer())

Build a collection of operations for creating and using maps based on a single consistent comparison function. This returns a record that contains the functions you use to create and manipulate maps all of which use this comparison function. The returned value is much like an ML module. Use MakeTagged if you want additional type safety that guarantees that two sets based on different comparison functions can never be combined in inconsistent ways.

Immutable sets implemented via binary trees

Return a string with all characters converted to uppercase.

Return the index of the first occurrence of the given character starting from the given index proceeding backwards.

Return the index of the first occurrence of the given character from the end of the string proceeding backwards

Return true if the string contains the given character prior to the given index

Return the first index of the given character in the range from the given start position to the end of the string. Raise <c>KeyNotFoundException</c> if the string does not contain the given character.

Return the first index of the given character in the string. Raise <c>KeyNotFoundException</c> if the string does not contain the given character.

Return true is the given string contains the given character in the range from the given start index to the end of the string.

Return true is the given string contains the given character in the range specified by the given start index and the given length

Return true is the given string contains the given character

Return s string of length 1 containing the given character

Return a string of the given length containing repetitions of the given character

Return a new string with all characters converted to lowercase

Return a substring of length 'length' starting index 'start'.

Returns the character at the specified position in the string

Compare the given strings using ordinal comparison

Removes all occurrences of a set of characters specified in a list from the beginning and end of this instance.

Split the string using the given list of separator characters. Trimming is also performed at both ends of the string and any empty strings that result from the split are discarded.

Return a string with the first character converted to lowercase.

Return a string with the first character converted to uppercase.

Compatibility module for string processing. Richer string operations are available via the member functions on strings and other functionality in the <c>System.String</c> type and the <c>System.Text.RegularExpressions</c> namespace.

Time consumed by the main thread. (for approximate timings). Generally returns only the processor time used by the main thread of the application.

The number of bits in the "int" type.

Path of the current executable, using <c>System.IO.Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory,System.AppDomain.CurrentDomain.FriendlyName)</c>

Run the command and return it's exit code. Warning: 'command' currently attempts to execute the string using the 'cmd.exe' shell processor. If it is not present on the system then the operation will fail. Use System.Diagnostics.Process directly to run commands in a portable way, which involves specifying the program to run and the arguments independently.

Returns the current working directory for the process using <c>System.IO.Directory.GetCurrentDirectory</c>

Sets the current working directory for the process using <c>System.IO.Directory.SetCurrentDirectory</c>

Rename a file on disk using System.IO.File.Move

Deletes a file using <c>System.IO.File.Delete</c>.

Call System.Environment.GetEnvironmentVariable. Raise <c>KeyNotFoundException</c> if the variable is not defined.

Returns true if a file currently exists, using System.IO.File.Exists(s).

The array of command line options. Gives the command line arguments as returned by <c>System.Environment.GetCommandLineArgs</c>.

Sys: Basic system operations (for ML compatibility) This module is only included to make it possible to cross-compile code with other ML compilers. It may be deprecated and/or removed in a future release. You may wish to use .NET functions directly instead.

UInt32: ML-like operations on 32-bit System.UInt32 numbers.

UInt64: basic operations on 64-bit System.UInt64 numbers.