[Home] Module Microsoft.FSharp.Compatibility.OCaml.Pervasives


Pervasives: Additional OCaml-compatible bindings

Modules (as contributed by assembly 'FSharp.Compatibility')

ModuleDescription
Microsoft.FSharp.Compatibility.OCaml.Pervasives.InChannel
Microsoft.FSharp.Compatibility.OCaml.Pervasives.OutChannel
Microsoft.FSharp.Compatibility.OCaml.Pervasives.Pervasives

Type Definitions

TypeDescription
type big_int Note: an abbreviation for bigint
type format Note: an abbreviation for Format<'a,'b,'c,'c>
type format4 Note: an abbreviation for Format<'a,'b,'c,'d>
type fpclass
type in_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. Note: an abbreviation for TextReader
type num Note: an abbreviation for bignum
type open_flag This type is present primarily for compatibility with other versions of ML. When not cross-compiling we recommend using the .NET I/O libraries
type out_channel 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. Note: an abbreviation for TextWriter

Exceptions

ExceptionDescription
exception Assert_failure The exception thrown by 'assert' failures. A future release of F# may map this exception to a corresponding .NET exception. Note: an abbreviation for = AssertionFailure
exception Division_by_zero
exception End_of_file
exception Exit Non-exhaustive match failures will raise Match failures A future release of F# may map this exception to a corresponding .NET exception.
exception Invalid_argument The exception thrown by [[invalid_arg]] and misues of F# library functions A future release of F# may map this exception to a corresponding .NET exception. Note: an abbreviation for = InvalidArgument
exception Match_failure Note: an abbreviation for = MatchFailure
exception Not_found
exception Out_of_memory
exception Stack_overflow

Values

ValueDescription
[<OCamlCompatibilityAttribute
  ("Using the physical inequality operator '!=' is not recommended except in cross-compiled code. Consider using generic structual inequality 'x <> y' or 'LanguagePrimitives.PhysicalInequality x y'")>]
val ( != ) : 'a -> 'a -> bool
Negation of the '==' operator, see also Obj.eq
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'x * y' instead of 'x *. y'")>]
val ( *. ) : float -> float -> float
This value is present primarily for compatibility with other versions of ML
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'x + y' instead of 'x +. y'")>]
val ( +. ) : float -> float -> float
This value is present primarily for compatibility with other versions of ML. In F# the overloaded operators may be used.
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'x - y' instead of 'x -. y'")>]
val ( -. ) : float -> float -> float
This value is present primarily for compatibility with other versions of ML. In F# the overloaded operators may be used.
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'x / y' instead of 'x /. y'")>]
val ( /. ) : float -> float -> float
This value is present primarily for compatibility with other versions of ML. In F# the overloaded operators may be used.
[<OCamlCompatibilityAttribute
  ("Using the physical equality operator '==' is not recommended except in cross-compiled code. Consider using generic structural equality 'x = y' or 'LanguagePrimitives.PhysicalEquality x y'")>]
val ( == ) : 'a -> 'a -> bool
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.
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator '+x' instead of '+. x'")>]
val ( ~+. ) : float -> float
This value is present primarily for compatibility with other versions of ML. In F# the overloaded operators may be used.
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator '-x' instead of '-. x'")>]
val ( ~-. ) : float -> float
This value is present primarily for compatibility with other versions of ML. In F# the overloaded operators may be used.
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded F# library function 'abs' instead")>]
val abs_float : float -> float
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'x >>> y' instead of 'x asr y'. The precedence of these operators differs, so you may need to add parentheses")>]
val asr : int -> int -> int
[<OCamlCompatibilityAttribute ()>]
val bool_of_string : string -> bool
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'char' instead")>]
val char_of_int : int -> char
[<OCamlCompatibilityAttribute ()>]
val classify_float : float -> fpclass
[<OCamlCompatibilityAttribute ("Consider using 'channel.Close()' instead")>]
val close_in : in_channel -> unit
Close the channel
[<OCamlCompatibilityAttribute
  ("Consider using 'channel.Close()' instead, or create the channel via a 'use' binding to ensure automatic cleanup")>]
val close_out : out_channel -> unit
Close the given output channel
[<OCamlCompatibilityAttribute ()>]
val epsilon_float : float
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
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded conversion function 'float' instead")>]
val float_of_int : int -> float
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded conversion function 'float' instead")>]
val float_of_string : string -> float
val float_to_string : float -> string
[<OCamlCompatibilityAttribute ("Consider using 'channel.Flush()' instead")>]
val flush : out_channel -> unit
Flush all pending output on the channel to the physical output device.
[<OCamlCompatibilityAttribute
  ("Consider using 'channel.BaseStream.Length' instead")>]
val in_channel_length : in_channel -> int
Return the length of the input channel
val infinity : float
[<OCamlCompatibilityAttribute
  ("Consider using 'channel.Read(buffer,index,count)' instead")>]
val input : in_channel -> byte [] -> int -> int -> int
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.
[<OCamlCompatibilityAttribute
  ("Consider using 'channel.ReadInt32()' on a BinaryReader instead")>]
val input_binary_int : in_channel -> int
Input a binary integer from a binary channel. Compatible with output_binary_int.
[<OCamlCompatibilityAttribute
  ("Consider using the 'Read()' method on a 'BinaryReader' instead, which returns -1 if no byte is available")>]
val input_byte : in_channel -> int
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.
[<OCamlCompatibilityAttribute
  ("Consider using the 'channel.Read()' method instead, which returns -1 if no character is available")>]
val input_char : in_channel -> char
Input a single character. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.
[<OCamlCompatibilityAttribute
  ("Consider using 'channel.Read(buffer,index,count)' instead")>]
val input_chars : in_channel -> char [] -> int -> int -> 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.
[<OCamlCompatibilityAttribute
  ("Consider using the 'channel.ReadLine()' method instead")>]
val input_line : in_channel -> string
Input a single line. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.
[<OCamlCompatibilityAttribute
  ("Consider deserializing using an object of type 'System.Runtime.Serialization.Formatters.Binary.BinaryFormatter' method instead")>]
val input_value : in_channel -> 'a
Input a single serialized value from a binary stream. Raise End_of_file (= System.IO.EndOfStreamException) if end of file reached.
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator '-x' instead of 'int_neg x'")>]
val int_neg : int -> int
Negation on integers of the 'int' type
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'int' instead")>]
val int_of_char : char -> int
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'int' instead")>]
val int_of_float : float -> int
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'int' instead")>]
val int_of_string : string -> int
val int_to_string : int -> string
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'x &&& y' instead of 'x land y'. The precedence of these operators differs, so you may need to add parentheses")>]
val land : int -> int -> int
[<OCamlCompatibilityAttribute ()>]
val ldexp : float -> int -> float
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator '~~~x' instead of 'lnot x'")>]
val lnot : int -> int
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'x ||| y' instead of 'x lor y'. The precedence of these operators differs, so you may need to add parentheses")>]
val lor : int -> int -> int
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'x <<< y' instead of 'x lsl y'. The precedence of these operators differs, so you may need to add parentheses")>]
val lsl : int -> int -> int
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'x >>> y' on an unsigned type instead of 'x lsr y'. The precedence of these operators differs, so you may need to add parentheses")>]
val lsr : int -> int -> int
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'x ^^^ y' instead of 'x lxor y'. The precedence of these operators differs, so you may need to add parentheses")>]
val lxor : int -> int -> int
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Double.MaxValue' instead")>]
val max_float : float
This value is present primarily for compatibility with other versions of ML The highest representable positive value in the 'float' type
[<OCamlCompatibilityAttribute ("Consider using 'System.Int32.MaxValue' instead")>]
val max_int : int
The highest representable value in the 'int' type
[<OCamlCompatibilityAttribute ()>]
val min_float : float
This value is present primarily for compatibility with other versions of ML The lowest non-denormalized positive IEEE64 float
[<OCamlCompatibilityAttribute ("Consider using 'System.Int32.MinValue' instead")>]
val min_int : int
The lowest representable value in the 'int' type
[<OCamlCompatibilityAttribute
  ("Consider using the overloaded operator 'x % y' instead of 'x mod y'. The precedence of these operators differs, so you may need to add parentheses")>]
val mod : int -> int -> int
[<OCamlCompatibilityAttribute ("Consider using the '%' operator instead")>]
val mod_float : float -> float -> float
This value is present primarily for compatibility with other versions of ML
[<OCamlCompatibilityAttribute ()>]
val modf : float -> float * float
This value is present primarily for compatibility with other versions of ML
val nan : float
This value is present primarily for compatibility with other versions of ML
[<OCamlCompatibilityAttribute
  ("Consider using '-System.Double.Infinity' instead")>]
val neg_infinity : float
This value is present primarily for compatibility with other versions of ML
[<OCamlCompatibilityAttribute
  ("Consider using 'System.IO.File.OpenText(path)' instead")>]
val open_in : string -> in_channel
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.
[<OCamlCompatibilityAttribute
  ("Consider using 'new System.IO.BinaryReader(System.IO.File.OpenRead(path))' and changing your type to be a BinaryReader instead")>]
val open_in_bin : string -> in_channel
Open the given file to read in binary-mode
[<OCamlCompatibilityAttribute
  ("For advanced I/O consider using the System.IO namespace instead")>]
val open_in_gen : open_flag list -> int -> string -> in_channel
Open the given file in the mode specified by the given flags
[<OCamlCompatibilityAttribute
  ("Consider using 'System.IO.File.CreateText(path)' instead")>]
val open_out : string -> out_channel
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.
[<OCamlCompatibilityAttribute
  ("Consider using 'new System.IO.BinaryWriter(System.IO.File.OpenWrite(path))' and changing your type to be a BinaryWriter instead")>]
val open_out_bin : string -> out_channel
Open the given file to write in binary-mode
[<OCamlCompatibilityAttribute
  ("For advanced I/O consider using the System.IO namespace")>]
val open_out_gen : open_flag list -> int -> string -> out_channel
Open the given file to write in the mode according to the specified flags
[<OCamlCompatibilityAttribute
  ("Consider using 'channel.BaseStream.Length' instead")>]
val out_channel_length : out_channel -> int
Return the length of the output channel. Raise an exception if not an app
[<OCamlCompatibilityAttribute
  ("Consider using 'channel.Write(buffer,index,count)' instead")>]
val output : out_channel -> byte [] -> int -> int -> unit
Write the given range of bytes to the output channel.
[<OCamlCompatibilityAttribute ("Consider using 'channel.Write(int)' instead")>]
val output_binary_int : out_channel -> int -> unit
Write the given integer to the output channel in binary format. Only valid on binary channels.
[<OCamlCompatibilityAttribute ("Consider using 'channel.Write(byte)' instead")>]
val output_byte : out_channel -> int -> unit
Write the given byte to the output channel. No CRLF translation is performed.
[<OCamlCompatibilityAttribute
  ("Consider using 'channel.Write(bytes,0,bytes.Length)' instead")>]
val output_bytearray : out_channel -> byte [] -> unit
Write all the given bytes to the output channel. No CRLF translation is performed.
[<OCamlCompatibilityAttribute ("Consider using 'channel.Write(char)' instead")>]
val output_char : out_channel -> char -> unit
Write the given Unicode character to the output channel. 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.
[<OCamlCompatibilityAttribute ("Consider using 'channel.Write(string)' instead")>]
val output_string : out_channel -> string -> unit
Write the given Unicode string to the output channel. See output_char for the treatment of '\n' characters within the string.
[<OCamlCompatibilityAttribute
  ("Consider serializing using an object of type 'System.Runtime.Serialization.Formatters.Binary.BinaryFormatter' instead")>]
val output_value : out_channel -> 'a -> unit
Serialize the given value to the output channel.
[<OCamlCompatibilityAttribute
  ("Consider using 'channel.BaseStream.Position' property instead")>]
val pos_in : in_channel -> int
Report the current position in the input channel
[<OCamlCompatibilityAttribute
  ("Consider using 'channel.BaseStream.Position' on a TextWriter or '.Position' on a Stream instead")>]
val pos_out : out_channel -> int
Return the current position in the output channel, measured from the start of the channel. Not valid on all channels.
[<OCamlCompatibilityAttribute ()>]
val pred : int -> int
n-1 (no overflow checking)
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.Error.Write(char)' instead")>]
val prerr_char : char -> unit
Print a character to the stderr stream
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.Error.WriteLine(string)' instead")>]
val prerr_endline : string -> unit
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.Error.Write(double)' instead")>]
val prerr_float : float -> unit
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.Error.Write(int)' instead")>]
val prerr_int : int -> unit
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.Error.WriteLine()' instead")>]
val prerr_newline : unit -> unit
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.Error.Write(string)' instead")>]
val prerr_string : string -> unit
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.Write(char)' instead")>]
val print_char : char -> unit
val print_endline : string -> unit
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.Write(double)' instead")>]
val print_float : float -> unit
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.Write(int)' instead")>]
val print_int : int -> unit
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.WriteLine()' instead")>]
val print_newline : unit -> unit
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.Write(string)' instead")>]
val print_string : string -> unit
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.ReadLine() |> float' instead")>]
val read_float : unit -> float
Read a floating point number from the console.
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.ReadLine() |> int' instead")>]
val read_int : unit -> int
Read an integer from the console.
[<OCamlCompatibilityAttribute
  ("Consider using 'System.Console.ReadLine()' instead")>]
val read_line : unit -> string
Read a line from the console, without the end-of-line character.
[<OCamlCompatibilityAttribute ()>]
val really_input : in_channel -> byte [] -> int -> int -> unit
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.
[<OCamlCompatibilityAttribute
  ("Consider using 'channel.BaseStream.Seek' method instead, or using a 'System.IO.BinaryReader' and related types for binary I/O")>]
val seek_in : in_channel -> int -> unit
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.
[<OCamlCompatibilityAttribute
  ("Consider using 'channel.BaseStream.Seek' on a TextReader or 'channel.Seek' on a Stream instead")>]
val seek_out : out_channel -> int -> unit
Set the current position in the output channel, measured from the start of the channel.
[<OCamlCompatibilityAttribute
  ("Consider using 'System.IO.BinaryReader' and related types for binary I/O")>]
val set_binary_mode_in : in_channel -> bool -> unit
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
[<OCamlCompatibilityAttribute
  ("For advanced I/O consider using the System.IO namespace")>]
val set_binary_mode_out : out_channel -> bool -> unit
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.
val string_of_bool : bool -> string
val string_of_float : float -> string
val string_of_int : int -> string
[<OCamlCompatibilityAttribute ()>]
val succ : int -> int
n+1 (no overflow checking)

Deprecated/Unsafe Type Definitions

TypeDescription
type channel_format

Note: This type is deprecated. Consider using the type 'Microsoft.FSharp.Text.Printf.TextWriterFormat' instead

type string_format

Note: This type is deprecated. Consider using the type 'Microsoft.FSharp.Text.Printf.StringFormat' instead

Deprecated Values

ValueDescription
[<Obsolete ("Consider using the corresponding InChannel.* member instead")>]
val binary_reader_to_in_channel : #BinaryReader -> in_channel

Note: Consider using the corresponding InChannel.* member instead

[<Obsolete ("Consider using the corresponding OutChannel.* member instead")>]
val binary_writer_to_out_channel : #BinaryWriter -> out_channel

Note: Consider using the corresponding OutChannel.* member instead

[<Obsolete
  ("Consider using the overloaded conversion function 'int' or the method 'System.Convert.ToInt32' instead")>]
val byte_to_int : byte -> int

Note: Consider using the overloaded conversion function 'int' or the method 'System.Convert.ToInt32' instead

[<Obsolete
  ("Consider using the overloaded conversion function 'float32' instead")>]
val float32_of_int : int -> float32

Note: Consider using the overloaded conversion function 'float32' instead

[<Obsolete ("Consider using the function 'Float32.of_string' instead")>]
val float32_of_string : string -> float32

Note: Consider using the function 'Float32.of_string' instead

[<Obsolete
  ("Consider using 'Float32.to_string' or 'System.Single.ToString' instead")>]
val float32_to_string : float32 -> string

Note: Consider using 'Float32.to_string' or 'System.Single.ToString' instead

[<Obsolete ("Consider using the corresponding InChannel.* member instead")>]
val in_channel_to_binary_reader : in_channel -> BinaryReader

Note: Consider using the corresponding InChannel.* member instead

[<Obsolete ("Consider using the corresponding InChannel.* member instead")>]
val in_channel_to_stream : in_channel -> Stream

Note: Consider using the corresponding InChannel.* member instead

[<Obsolete ("Consider using the corresponding InChannel.* member instead")>]
val in_channel_to_stream_reader : in_channel -> StreamReader

Note: Consider using the corresponding InChannel.* member instead

[<Obsolete ("Consider using the corresponding InChannel.* member instead")>]
val in_channel_to_text_reader : in_channel -> TextReader

Note: Consider using the corresponding InChannel.* member instead

[<Obsolete
  ("Consider using the overloaded conversion function 'int' or the method 'System.Convert.ToInt64' instead")>]
val int64_to_int : int64 -> int

Note: Consider using the overloaded conversion function 'int' or the method 'System.Convert.ToInt64' instead

[<Obsolete ("Consider using the overloaded conversion function 'int' instead")>]
val int_of_float32 : float32 -> int

Note: Consider using the overloaded conversion function 'int' instead

[<Obsolete
  ("Consider using the overloaded conversion function 'byte' or the method 'System.Convert.ToByte' instead")>]
val int_to_byte : int -> byte

Note: Consider using the overloaded conversion function 'byte' or the method 'System.Convert.ToByte' instead

[<Obsolete ("Consider using 'Char.chr' or 'System.Convert.ToChar' instead")>]
val int_to_char : int -> char

Note: Consider using 'Char.chr' or 'System.Convert.ToChar' instead

[<Obsolete
  ("Consider using the overloaded conversion function 'int64' or the method 'System.Convert.ToInt64' instead")>]
val int_to_int64 : int -> int64

Note: Consider using the overloaded conversion function 'int64' or the method 'System.Convert.ToInt64' instead

[<Obsolete
  ("Consider using 'new System.IO.StreamReader(path,encoding)' instead")>]
val open_in_encoded : #Encoding -> string -> in_channel

Note: Consider using 'new System.IO.StreamReader(path,encoding)' instead

Open the given file to read in text-mode using the given encoding
[<Obsolete
  ("This value is deprecated. Consider using 'System.IO.File.OpenText(path)' instead")>]
val open_in_utf8 : string -> in_channel

Note: This value is deprecated. Consider using 'System.IO.File.OpenText(path)' instead

Open the given file to read in text-mode using the UTF8 encoding
[<Obsolete ("Consider using the 'System.IO.StreamWriter' type instead")>]
val open_out_encoded : #Encoding -> string -> out_channel

Note: Consider using the 'System.IO.StreamWriter' type instead

Open the given file to write in text-mode using the given encoding
[<Obsolete ("Consider using the System.IO.File.OpenWrite function instead")>]
val open_out_utf8 : string -> out_channel

Note: Consider using the System.IO.File.OpenWrite function instead

Open the given file to write in text-mode using the UTF8 encoding
[<Obsolete ("Consider using the the corresponding OutChannel.* member instead")>]
val out_channel_to_binary_writer : out_channel -> BinaryWriter

Note: Consider using the the corresponding OutChannel.* member instead

[<Obsolete ("Consider using the corresponding OutChannel.* member instead")>]
val out_channel_to_stream : out_channel -> Stream

Note: Consider using the corresponding OutChannel.* member instead

[<Obsolete ("Consider using the the corresponding OutChannel.* member instead")>]
val out_channel_to_stream_writer : out_channel -> StreamWriter

Note: Consider using the the corresponding OutChannel.* member instead

[<Obsolete ("Consider using the the corresponding OutChannel.* member instead")>]
val out_channel_to_text_writer : out_channel -> TextWriter

Note: Consider using the the corresponding OutChannel.* member instead

[<Obsolete ("Consider using the corresponding InChannel.* member instead")>]
val stream_reader_to_in_channel : #StreamReader -> in_channel

Note: Consider using the corresponding InChannel.* member instead

[<Obsolete ("Consider using the corresponding InChannel.* member instead")>]
val stream_to_in_channel : #Encoding -> #Stream -> in_channel

Note: Consider using the corresponding InChannel.* member instead

[<Obsolete ("Consider using the corresponding OutChannel.* member instead")>]
val stream_to_out_channel : #Encoding -> #Stream -> out_channel

Note: Consider using the corresponding OutChannel.* member instead

[<Obsolete ("Consider using the corresponding OutChannel.* member instead")>]
val stream_writer_to_out_channel : #StreamWriter -> out_channel

Note: Consider using the corresponding OutChannel.* member instead

[<Obsolete ("Consider using the function 'Float32.to_string' instead")>]
val string_of_float32 : float32 -> string

Note: Consider using the function 'Float32.to_string' instead

[<Obsolete ("Consider using 'Float.of_string' or 'System.Double.Parse' instead")>]
val string_to_float : string -> float

Note: Consider using 'Float.of_string' or 'System.Double.Parse' instead

[<Obsolete
  ("Consider using 'Float32.of_string' or 'System.Single.Parse' instead")>]
val string_to_float32 : string -> float32

Note: Consider using 'Float32.of_string' or 'System.Single.Parse' instead

[<Obsolete ("Consider using the corresponding InChannel.* member instead")>]
val text_reader_to_in_channel : #TextReader -> in_channel

Note: Consider using the corresponding InChannel.* member instead

[<Obsolete ("Consider using the corresponding OutChannel.* member instead")>]
val text_writer_to_out_channel : #TextWriter -> out_channel

Note: Consider using the corresponding OutChannel.* member instead

[<Obsolete ("For F# code unsafe_really_input is identical to really_input");
  OCamlCompatibilityAttribute ()>]
val unsafe_really_input : in_channel -> byte [] -> int -> int -> unit

Note: For F# code unsafe_really_input is identical to really_input

See Also

Microsoft.FSharp.Compatibility.OCaml


Documentation for assembly FSharp.Compatibility, version 1.9.4.19, generated using F# version 1.9.4.19