diff --git a/src/fsharp/FSharp.Core/Linq.fsi b/src/fsharp/FSharp.Core/Linq.fsi index a46ebe44de9..cc62fe99b58 100644 --- a/src/fsharp/FSharp.Core/Linq.fsi +++ b/src/fsharp/FSharp.Core/Linq.fsi @@ -8,6 +8,13 @@ open Microsoft.FSharp.Core open Microsoft.FSharp.Collections open Microsoft.FSharp.Quotations +/// +/// Contains functionality to convert F# quotations to LINQ expression trees. +/// +/// +/// +/// Library functionality associated with converting F# quotations to .NET LINQ expression trees. +/// module LeafExpressionConverter = /// When used in a quotation, this function indicates a specific conversion /// should be performed when converting the quotation to a LINQ expression. diff --git a/src/fsharp/FSharp.Core/MutableTuple.fs b/src/fsharp/FSharp.Core/MutableTuple.fs index 89c84dca36a..79e7d5c73ed 100644 --- a/src/fsharp/FSharp.Core/MutableTuple.fs +++ b/src/fsharp/FSharp.Core/MutableTuple.fs @@ -22,14 +22,16 @@ open Microsoft.FSharp.Core // This terminology mistake also runs all the way through Query.fs. // ---------------------------------------------------------------------------- -/// This type shouldn't be used directly from user code. +/// This type shouldn't be used directly from user code. +/// type AnonymousObject<'T1> = val private item1 : 'T1 member x.Item1 = x.item1 new (Item1) = { item1 = Item1 } -/// This type shouldn't be used directly from user code. +/// This type shouldn't be used directly from user code. +/// type AnonymousObject<'T1, 'T2> = val private item1 : 'T1 member x.Item1 = x.item1 @@ -39,7 +41,8 @@ type AnonymousObject<'T1, 'T2> = new (Item1, Item2) = { item1 = Item1; item2 = Item2 } -/// This type shouldn't be used directly from user code. +/// This type shouldn't be used directly from user code. +/// type AnonymousObject<'T1, 'T2, 'T3> = val private item1 : 'T1 member x.Item1 = x.item1 @@ -53,7 +56,8 @@ type AnonymousObject<'T1, 'T2, 'T3> = new (Item1, Item2, Item3) = { item1 = Item1; item2 = Item2; item3 = Item3 } -/// This type shouldn't be used directly from user code. +/// This type shouldn't be used directly from user code. +/// type AnonymousObject<'T1, 'T2, 'T3, 'T4> = val private item1 : 'T1 member x.Item1 = x.item1 @@ -71,7 +75,8 @@ type AnonymousObject<'T1, 'T2, 'T3, 'T4> = -/// This type shouldn't be used directly from user code. +/// This type shouldn't be used directly from user code. +/// type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5> = val private item1 : 'T1 member x.Item1 = x.item1 @@ -91,7 +96,8 @@ type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5> = new (Item1, Item2, Item3, Item4, Item5) = { item1 = Item1; item2 = Item2; item3 = Item3; item4 = Item4 ; item5 = Item5 } -/// This type shouldn't be used directly from user code. +/// This type shouldn't be used directly from user code. +/// type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6> = val private item1 : 'T1 member x.Item1 = x.item1 @@ -114,7 +120,8 @@ type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6> = new (Item1, Item2, Item3, Item4, Item5, Item6) = { item1 = Item1; item2 = Item2; item3 = Item3; item4 = Item4 ; item5 = Item5 ; item6 = Item6 } -/// This type shouldn't be used directly from user code. +/// This type shouldn't be used directly from user code. +/// type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> = val private item1 : 'T1 member x.Item1 = x.item1 @@ -139,7 +146,8 @@ type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7> = new (Item1, Item2, Item3, Item4, Item5, Item6, Item7) = { item1 = Item1; item2 = Item2; item3 = Item3; item4 = Item4 ; item5 = Item5 ; item6 = Item6 ; item7 = Item7 } -/// This type shouldn't be used directly from user code. +/// This type shouldn't be used directly from user code. +/// type AnonymousObject<'T1, 'T2, 'T3, 'T4, 'T5, 'T6, 'T7, 'T8> = val private item1 : 'T1 member x.Item1 = x.item1 diff --git a/src/fsharp/FSharp.Core/Query.fsi b/src/fsharp/FSharp.Core/Query.fsi index bda2b9f2ca4..7017fe693e8 100644 --- a/src/fsharp/FSharp.Core/Query.fsi +++ b/src/fsharp/FSharp.Core/Query.fsi @@ -11,19 +11,28 @@ namespace Microsoft.FSharp.Linq open System.Collections.Generic [] + /// /// A partial input or result in an F# query. This type is used to support the F# query syntax. + /// + /// + /// + /// Library functionality for F# query syntax and interoperability with .NET LINQ Expressions. See + /// also F# Query Expressions in the F# Language Guide. + /// type QuerySource<'T, 'Q> = /// /// A method used to support the F# query syntax. /// new : seq<'T> -> QuerySource<'T,'Q> + /// /// A property used to support the F# query syntax. /// member Source : seq<'T> [] - /// The type used to support the F# query syntax. Use 'query { ... }' to use the query syntax. + /// The type used to support the F# query syntax. Use 'query { ... }' to use the query syntax. See + /// also F# Query Expressions in the F# Language Guide. type QueryBuilder = /// Create an instance of this builder. Use 'query { ... }' to use the query syntax. new : unit -> QueryBuilder @@ -350,6 +359,13 @@ namespace Microsoft.FSharp.Linq.QueryRunExtensions open Microsoft.FSharp.Core + /// + /// A module used to support the F# query syntax. + /// + /// + /// + /// Contains modules used to support the F# query syntax. + /// module LowPriority = type Microsoft.FSharp.Linq.QueryBuilder with /// @@ -358,6 +374,9 @@ namespace Microsoft.FSharp.Linq.QueryRunExtensions [] member Run : Microsoft.FSharp.Quotations.Expr<'T> -> 'T + /// + /// A module used to support the F# query syntax. + /// module HighPriority = type Microsoft.FSharp.Linq.QueryBuilder with /// diff --git a/src/fsharp/FSharp.Core/array.fsi b/src/fsharp/FSharp.Core/array.fsi index aded2dcf256..f47baa49e2b 100644 --- a/src/fsharp/FSharp.Core/array.fsi +++ b/src/fsharp/FSharp.Core/array.fsi @@ -7,7 +7,7 @@ namespace Microsoft.FSharp.Collections open Microsoft.FSharp.Collections open System.Collections.Generic - /// Basic operations on arrays. + /// Contains operations for working with arrays. /// /// /// See also F# Language Guide - Arrays. @@ -1033,10 +1033,10 @@ namespace Microsoft.FSharp.Collections [] val sub: array:'T[] -> startIndex:int -> count:int -> 'T[] - /// Sorts the elements of an array, returning a new array. Elements are compared using Operators.compare. + /// Sorts the elements of an array, returning a new array. Elements are compared using . /// /// This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. - /// For a stable sort, consider using Seq.sort. + /// For a stable sort, consider using . /// /// The input array. /// @@ -1047,10 +1047,10 @@ namespace Microsoft.FSharp.Collections val sort: array:'T[] -> 'T[] when 'T : comparison /// Sorts the elements of an array, using the given projection for the keys and returning a new array. - /// Elements are compared using Operators.compare. + /// Elements are compared using . /// /// This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. - /// For a stable sort, consider using Seq.sort. + /// For a stable sort, consider using . /// /// The function to transform array elements into the type that is compared. /// The input array. @@ -1064,7 +1064,7 @@ namespace Microsoft.FSharp.Collections /// Sorts the elements of an array, using the given comparison function as the order, returning a new array. /// /// This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. - /// For a stable sort, consider using Seq.sort. + /// For a stable sort, consider using . /// /// The function to compare pairs of array elements. /// The input array. @@ -1076,10 +1076,10 @@ namespace Microsoft.FSharp.Collections val sortWith: comparer:('T -> 'T -> int) -> array:'T[] -> 'T[] /// Sorts the elements of an array by mutating the array in-place, using the given projection for the keys. - /// Elements are compared using Operators.compare. + /// Elements are compared using . /// /// This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. - /// For a stable sort, consider using Seq.sort. + /// For a stable sort, consider using . /// /// The function to transform array elements into the type that is compared. /// The input array. @@ -1100,7 +1100,7 @@ namespace Microsoft.FSharp.Collections val sortInPlaceWith: comparer:('T -> 'T -> int) -> array:'T[] -> unit /// Sorts the elements of an array by mutating the array in-place, using the given comparison function. - /// Elements are compared using Operators.compare. + /// Elements are compared using . /// /// The input array. /// @@ -1121,10 +1121,10 @@ namespace Microsoft.FSharp.Collections [] val splitAt: index:int -> array:'T[] -> ('T[] * 'T[]) - /// Sorts the elements of an array, in descending order, returning a new array. Elements are compared using Operators.compare. + /// Sorts the elements of an array, in descending order, returning a new array. Elements are compared using . /// /// This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. - /// For a stable sort, consider using Seq.sort. + /// For a stable sort, consider using . /// /// The input array. /// @@ -1133,10 +1133,10 @@ namespace Microsoft.FSharp.Collections val inline sortDescending: array:'T[] -> 'T[] when 'T : comparison /// Sorts the elements of an array, in descending order, using the given projection for the keys and returning a new array. - /// Elements are compared using Operators.compare. + /// Elements are compared using . /// /// This is not a stable sort, i.e. the original order of equal elements is not necessarily preserved. - /// For a stable sort, consider using Seq.sort. + /// For a stable sort, consider using . /// /// The function to transform array elements into the type that is compared. /// The input array. @@ -1403,13 +1403,13 @@ namespace Microsoft.FSharp.Collections /// the array comprised of the results "x" for each element where /// the function returns Some(x). /// - /// Performs the operation in parallel using System.Threading.Parallel.For. + /// Performs the operation in parallel using . /// The order in which the given function is applied to elements of the input array is not specified. /// /// The function to generate options from the elements. /// The input array. /// - /// 'U[] + /// The array of results. /// /// Thrown when the input array is null. [] @@ -1417,7 +1417,7 @@ namespace Microsoft.FSharp.Collections /// For each element of the array, apply the given function. Concatenate all the results and return the combined array. /// - /// Performs the operation in parallel using System.Threading.Parallel.For. + /// Performs the operation in parallel using . /// The order in which the given function is applied to elements of the input array is not specified. /// /// @@ -1432,13 +1432,13 @@ namespace Microsoft.FSharp.Collections /// Build a new array whose elements are the results of applying the given function /// to each of the elements of the array. /// - /// Performs the operation in parallel using System.Threading.Parallel.For. + /// Performs the operation in parallel using . /// The order in which the given function is applied to elements of the input array is not specified. /// /// /// The input array. /// - /// 'U[] + /// The array of results. /// /// Thrown when the input array is null. [] @@ -1448,13 +1448,13 @@ namespace Microsoft.FSharp.Collections /// to each of the elements of the array. The integer index passed to the /// function indicates the index of element being transformed. /// - /// Performs the operation in parallel using System.Threading.Parallel.For. + /// Performs the operation in parallel using . /// The order in which the given function is applied to elements of the input array is not specified. /// /// /// The input array. /// - /// 'U[] + /// The array of results. /// /// Thrown when the input array is null. [] @@ -1462,7 +1462,7 @@ namespace Microsoft.FSharp.Collections /// Apply the given function to each element of the array. /// - /// Performs the operation in parallel using System.Threading.Parallel.For. + /// Performs the operation in parallel using . /// The order in which the given function is applied to elements of the input array is not specified. /// /// @@ -1475,7 +1475,7 @@ namespace Microsoft.FSharp.Collections /// Apply the given function to each element of the array. The integer passed to the /// function indicates the index of element. /// - /// Performs the operation in parallel using System.Threading.Parallel.For. + /// Performs the operation in parallel using . /// The order in which the given function is applied to elements of the input array is not specified. /// /// @@ -1487,13 +1487,13 @@ namespace Microsoft.FSharp.Collections /// Create an array given the dimension and a generator function to compute the elements. /// - /// Performs the operation in parallel using System.Threading.Parallel.For. + /// Performs the operation in parallel using . /// The order in which the given function is applied to indices is not specified. /// /// /// /// - /// 'T[] + /// The array of results. [] val init : count:int -> initializer:(int -> 'T) -> 'T[] @@ -1501,13 +1501,13 @@ namespace Microsoft.FSharp.Collections /// elements for which the given predicate returns "true" and "false" /// respectively /// - /// Performs the operation in parallel using System.Threading.Parallel.For. + /// Performs the operation in parallel using . /// The order in which the given function is applied to indices is not specified. /// /// The function to test the input elements. /// The input array. /// - /// 'T[] * 'T[] + /// The two arrays of results. /// /// Thrown when the input array is null. [] diff --git a/src/fsharp/FSharp.Core/array2.fsi b/src/fsharp/FSharp.Core/array2.fsi index 23d4e36b9e2..372bc131419 100644 --- a/src/fsharp/FSharp.Core/array2.fsi +++ b/src/fsharp/FSharp.Core/array2.fsi @@ -8,7 +8,7 @@ namespace Microsoft.FSharp.Collections [] [] - /// Basic operations on 2-dimensional arrays. + /// Contains operations for working with 2-dimensional arrays. /// /// /// See also F# Language Guide - Arrays. diff --git a/src/fsharp/FSharp.Core/array3.fsi b/src/fsharp/FSharp.Core/array3.fsi index cba604b2266..60be384d0d8 100644 --- a/src/fsharp/FSharp.Core/array3.fsi +++ b/src/fsharp/FSharp.Core/array3.fsi @@ -9,7 +9,7 @@ namespace Microsoft.FSharp.Collections [] [] - /// Basic operations on rank 3 arrays. + /// Contains operations for working with rank 3 arrays. /// /// /// See also F# Language Guide - Arrays. @@ -137,7 +137,7 @@ namespace Microsoft.FSharp.Collections [] [] - /// Basic operations on rank 4 arrays. + /// Contains operations for working with rank 4 arrays. module Array4D = /// Creates an array whose elements are all initially the given value diff --git a/src/fsharp/FSharp.Core/async.fsi b/src/fsharp/FSharp.Core/async.fsi index b19d63cbfdc..5fea2c1a81d 100644 --- a/src/fsharp/FSharp.Core/async.fsi +++ b/src/fsharp/FSharp.Core/async.fsi @@ -21,6 +21,16 @@ namespace Microsoft.FSharp.Control /// /// See also F# Language Guide - Async Workflows. /// + /// + /// + /// Library functionality for asynchronous programming, events and agents. See also + /// Asynchronous Programming, + /// Events and + /// Lazy Expressions in the + /// F# Language Guide. + /// + /// + /// Async Programming [] type Async<'T> @@ -30,6 +40,8 @@ namespace Microsoft.FSharp.Control /// /// See also F# Language Guide - Async Workflows. /// + /// + /// Async Programming [] [] @@ -54,6 +66,8 @@ namespace Microsoft.FSharp.Control /// If one is not supplied, the default cancellation token is used. /// /// The result of the computation. + /// + /// Starting Async Computations static member RunSynchronously : computation:Async<'T> * ?timeout : int * ?cancellationToken:CancellationToken-> 'T /// Starts the asynchronous computation in the thread pool. Do not await its result. @@ -63,6 +77,8 @@ namespace Microsoft.FSharp.Control /// The computation to run asynchronously. /// The cancellation token to be associated with the computation. /// If one is not supplied, the default cancellation token is used. + /// + /// Starting Async Computations static member Start : computation:Async * ?cancellationToken:CancellationToken -> unit /// Executes a computation in the thread pool. @@ -71,10 +87,13 @@ namespace Microsoft.FSharp.Control /// /// A that will be completed /// in the corresponding state once the computation terminates (produces the result, throws exception or gets canceled) - /// + /// + /// Starting Async Computations static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions * ?cancellationToken:CancellationToken -> Task<'T> /// Creates an asynchronous computation which starts the given computation as a + /// + /// Starting Async Computations static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions -> Async> /// Creates an asynchronous computation that executes computation. @@ -85,6 +104,8 @@ namespace Microsoft.FSharp.Control /// The input computation that returns the type T. /// /// A computation that returns a choice of type T or exception. + /// + /// Cancellation and Exceptions static member Catch : computation:Async<'T> -> Async> /// Creates an asynchronous computation that executes computation. @@ -96,6 +117,8 @@ namespace Microsoft.FSharp.Control /// /// An asynchronous computation that runs the compensation if the input computation /// is cancelled. + /// + /// Cancellation and Exceptions static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T> /// Generates a scoped, cooperative cancellation handler for use within an asynchronous workflow. @@ -113,6 +136,8 @@ namespace Microsoft.FSharp.Control /// /// An asynchronous computation that triggers the interruption if it is cancelled /// before being disposed. + /// + /// Cancellation and Exceptions static member OnCancel : interruption: (unit -> unit) -> Async /// Creates an asynchronous computation that returns the CancellationToken governing the execution @@ -123,17 +148,23 @@ namespace Microsoft.FSharp.Control /// /// An asynchronous computation capable of retrieving the CancellationToken from a computation /// expression. + /// + /// Cancellation and Exceptions static member CancellationToken : Async /// Raises the cancellation condition for the most recent set of asynchronous computations started /// without any specific CancellationToken. Replaces the global CancellationTokenSource with a new /// global token source for any asynchronous computations created after this point without any /// specific CancellationToken. + /// + /// Cancellation and Exceptions static member CancelDefaultToken : unit -> unit /// Gets the default cancellation token for executing asynchronous computations. /// /// The default CancellationToken. + /// + /// Cancellation and Exceptions static member DefaultCancellationToken : CancellationToken //---------- Parallelism @@ -162,6 +193,8 @@ namespace Microsoft.FSharp.Control /// then the default value of -1 corresponding to . /// /// A new computation that waits for the input computation to finish. + /// + /// Cancellation and Exceptions static member StartChild : computation:Async<'T> * ?millisecondsTimeout : int -> Async> /// Creates an asynchronous computation that executes all the given asynchronous computations, @@ -179,6 +212,8 @@ namespace Microsoft.FSharp.Control /// A sequence of distinct computations to be parallelized. /// /// A computation that returns an array of values from the sequence of input computations. + /// + /// Composing Async Computations static member Parallel : computations:seq> -> Async<'T[]> /// Creates an asynchronous computation that executes all the given asynchronous computations, @@ -196,6 +231,8 @@ namespace Microsoft.FSharp.Control /// A sequence of distinct computations to be parallelized. /// /// A computation that returns an array of values from the sequence of input computations. + /// + /// Composing Async Computations static member Parallel : computations:seq> * ?maxDegreeOfParallelism : int -> Async<'T[]> /// Creates an asynchronous computation that executes all the given asynchronous computations sequentially. @@ -212,6 +249,8 @@ namespace Microsoft.FSharp.Control /// A sequence of distinct computations to be run in sequence. /// /// A computation that returns an array of values from the sequence of input computations. + /// + /// Composing Async Computations static member Sequential : computations:seq> -> Async<'T[]> /// Creates an asynchronous computation that executes all given asynchronous computations in parallel, @@ -229,6 +268,8 @@ namespace Microsoft.FSharp.Control /// A sequence of computations to be parallelized. /// /// A computation that returns the first succeeding computation. + /// + /// Composing Async Computations static member Choice : computations:seq> -> Async<'T option> //---------- Thread Control @@ -237,12 +278,16 @@ namespace Microsoft.FSharp.Control /// its continuation in that thread. /// /// A computation that will execute on a new thread. + /// + /// Threads and Contexts static member SwitchToNewThread : unit -> Async /// Creates an asynchronous computation that queues a work item that runs /// its continuation. /// /// A computation that generates a new work item in the thread pool. + /// + /// Threads and Contexts static member SwitchToThreadPool : unit -> Async /// Creates an asynchronous computation that runs @@ -252,6 +297,8 @@ namespace Microsoft.FSharp.Control /// The synchronization context to accept the posted computation. /// /// An asynchronous computation that uses the syncContext context to execute. + /// + /// Threads and Contexts static member SwitchToContext : syncContext:System.Threading.SynchronizationContext -> Async /// Creates an asynchronous computation that captures the current @@ -262,6 +309,8 @@ namespace Microsoft.FSharp.Control /// continuations. /// /// An asynchronous computation that provides the callback with the current continuations. + /// + /// Composing Async Computations static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T> /// Creates an asynchronous computation that waits for a single invocation of a CLI @@ -280,6 +329,8 @@ namespace Microsoft.FSharp.Control /// cancellation is issued. /// /// An asynchronous computation that waits for the event to be invoked. + /// + /// Awaiting Results static member AwaitEvent: event:IEvent<'Del,'T> * ?cancelAction : (unit -> unit) -> Async<'T> when 'Del : delegate<'T,unit> and 'Del :> System.Delegate /// Creates an asynchronous computation that will wait on the given WaitHandle. @@ -291,6 +342,8 @@ namespace Microsoft.FSharp.Control /// then the default value of -1 corresponding to . /// /// An asynchronous computation that waits on the given WaitHandle. + /// + /// Awaiting Results static member AwaitWaitHandle: waitHandle: WaitHandle * ?millisecondsTimeout:int -> Async /// Creates an asynchronous computation that will wait on the IAsyncResult. @@ -302,14 +355,24 @@ namespace Microsoft.FSharp.Control /// then the default value of -1 corresponding to . /// /// An asynchronous computation that waits on the given IAsyncResult. + /// + /// Awaiting Results static member AwaitIAsyncResult: iar: System.IAsyncResult * ?millisecondsTimeout:int -> Async - /// Return an asynchronous computation that will wait for the given task to complete and return - /// its result. + /// Return an asynchronous computation that will wait for the given task to complete and return + /// its result. + /// + /// The task to await. + /// + /// Awaiting Results static member AwaitTask: task: Task<'T> -> Async<'T> - /// Return an asynchronous computation that will wait for the given task to complete and return - /// its result. + /// Return an asynchronous computation that will wait for the given task to complete and return + /// its result. + /// + /// The task to await. + /// + /// Awaiting Results static member AwaitTask: task: Task -> Async /// @@ -324,6 +387,8 @@ namespace Microsoft.FSharp.Control /// /// Thrown when the due time is negative /// and not infinite. + /// + /// Awaiting Results static member Sleep: millisecondsDueTime:int -> Async /// @@ -337,6 +402,8 @@ namespace Microsoft.FSharp.Control /// An asynchronous computation that will sleep for the given time. /// /// Thrown when the due time is negative. + /// + /// Awaiting Results static member Sleep: dueTime:TimeSpan -> Async /// @@ -357,6 +424,8 @@ namespace Microsoft.FSharp.Control /// An optional function to be executed when a cancellation is requested. /// /// An asynchronous computation wrapping the given Begin/End functions. + /// + /// Legacy .NET Async Interoperability static member FromBeginEnd : beginAction:(System.AsyncCallback * obj -> System.IAsyncResult) * endAction:(System.IAsyncResult -> 'T) * ?cancelAction : (unit -> unit) -> Async<'T> /// @@ -378,6 +447,8 @@ namespace Microsoft.FSharp.Control /// An optional function to be executed when a cancellation is requested. /// /// An asynchronous computation wrapping the given Begin/End functions. + /// + /// Legacy .NET Async Interoperability static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * System.AsyncCallback * obj -> System.IAsyncResult) * endAction:(System.IAsyncResult -> 'T) * ?cancelAction : (unit -> unit) -> Async<'T> /// @@ -398,6 +469,8 @@ namespace Microsoft.FSharp.Control /// An optional function to be executed when a cancellation is requested. /// /// An asynchronous computation wrapping the given Begin/End functions. + /// + /// Legacy .NET Async Interoperability static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * System.AsyncCallback * obj -> System.IAsyncResult) * endAction:(System.IAsyncResult -> 'T) * ?cancelAction : (unit -> unit) -> Async<'T> /// Creates an asynchronous computation in terms of a Begin/End pair of actions in @@ -418,6 +491,8 @@ namespace Microsoft.FSharp.Control /// An optional function to be executed when a cancellation is requested. /// /// An asynchronous computation wrapping the given Begin/End functions. + /// + /// Legacy .NET Async Interoperability static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * System.AsyncCallback * obj -> System.IAsyncResult) * endAction:(System.IAsyncResult -> 'T) * ?cancelAction : (unit -> unit) -> Async<'T> /// Creates three functions that can be used to implement the .NET 1.0 Asynchronous @@ -427,6 +502,8 @@ namespace Microsoft.FSharp.Control /// .NET Asynchronous Programming Model. /// /// A tuple of the begin, end, and cancel members. + /// + /// Legacy .NET Async Interoperability static member AsBeginEnd : computation:('Arg -> Async<'T>) -> // The 'Begin' member ('Arg * System.AsyncCallback * obj -> System.IAsyncResult) * @@ -441,6 +518,8 @@ namespace Microsoft.FSharp.Control /// The input computation. /// /// A computation that is equivalent to the input computation, but disregards the result. + /// + /// Composing Async Computations static member Ignore : computation: Async<'T> -> Async /// Runs an asynchronous computation, starting immediately on the current operating system @@ -455,6 +534,8 @@ namespace Microsoft.FSharp.Control /// The function called on cancellation. /// The CancellationToken to associate with the computation. /// The default is used if this parameter is not provided. + /// + /// Starting Async Computations static member StartWithContinuations: computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * @@ -473,6 +554,8 @@ namespace Microsoft.FSharp.Control /// The asynchronous computation to execute. /// The CancellationToken to associate with the computation. /// The default is used if this parameter is not provided. + /// + /// Starting Async Computations static member StartImmediate: computation:Async * ?cancellationToken:CancellationToken-> unit @@ -491,15 +574,21 @@ namespace Microsoft.FSharp.Control /// /// A that will be completed /// in the corresponding state once the computation terminates (produces the result, throws exception or gets canceled) + /// + /// Starting Async Computations static member StartImmediateAsTask: computation:Async<'T> * ?cancellationToken:CancellationToken-> Task<'T> /// The F# compiler emits references to this type to implement F# async expressions. + /// + /// Async Internals type AsyncReturn /// The F# compiler emits references to this type to implement F# async expressions. [] + /// + /// Async Internals type AsyncActivation<'T> = /// The F# compiler emits calls to this function to implement F# async expressions. @@ -534,6 +623,8 @@ namespace Microsoft.FSharp.Control [] /// Entry points for generated code + /// + /// Async Internals module AsyncPrimitives = /// The F# compiler emits calls to this function to implement F# async expressions. @@ -554,7 +645,7 @@ namespace Microsoft.FSharp.Control /// The F# compiler emits calls to this function to implement constructs for F# async expressions. /// /// The async activation. - /// The result of the first part of the computation. + /// The result of the first part of the computation. /// A function returning the second part of the computation. /// /// A value indicating asynchronous execution. @@ -563,6 +654,7 @@ namespace Microsoft.FSharp.Control /// The F# compiler emits calls to this function to implement the let! construct for F# async expressions. /// /// The async activation. + /// The first part of the computation. /// A function returning the second part of the computation. /// /// An async activation suitable for running part1 of the asynchronous execution. @@ -605,6 +697,8 @@ namespace Microsoft.FSharp.Control [] [] /// The type of the async operator, used to build workflows for asynchronous computations. + /// + /// Async Programming type AsyncBuilder = /// Creates an asynchronous computation that enumerates the sequence seq /// on demand and runs body for each element. @@ -764,6 +858,8 @@ namespace Microsoft.FSharp.Control [] /// A module of extension members providing asynchronous operations for some basic CLI types related to concurrency and I/O. + /// + /// Async Programming module CommonExtensions = type System.IO.Stream with @@ -822,6 +918,8 @@ namespace Microsoft.FSharp.Control member Subscribe: callback:('T -> unit) -> System.IDisposable /// A module of extension members providing asynchronous operations for some basic Web operations. + /// + /// Async Programming [] module WebExtensions = diff --git a/src/fsharp/FSharp.Core/collections.fsi b/src/fsharp/FSharp.Core/collections.fsi index 2acb1410697..ce063e711a3 100644 --- a/src/fsharp/FSharp.Core/collections.fsi +++ b/src/fsharp/FSharp.Core/collections.fsi @@ -20,7 +20,7 @@ namespace Microsoft.FSharp.Collections /// Get an implementation of comparison semantics using non-structural comparison. /// - /// An object implementing using . + /// An object implementing using . val inline NonStructural< ^T > : IComparer< ^T > when ^T : (static member ( < ) : ^T * ^T -> bool) and ^T : (static member ( > ) : ^T * ^T -> bool) /// Get an implementation of comparison semantics using the given function. diff --git a/src/fsharp/FSharp.Core/event.fsi b/src/fsharp/FSharp.Core/event.fsi index dfc76ab434d..855a259121b 100644 --- a/src/fsharp/FSharp.Core/event.fsi +++ b/src/fsharp/FSharp.Core/event.fsi @@ -9,6 +9,8 @@ namespace Microsoft.FSharp.Control open Microsoft.FSharp.Collections /// Event implementations for an arbitrary type of delegate. + /// + /// Events and Observables [] type DelegateEvent<'Delegate when 'Delegate :> System.Delegate> = /// Creates an event object suitable for implementing an arbitrary type of delegate. @@ -21,6 +23,8 @@ namespace Microsoft.FSharp.Control member Publish : IDelegateEvent<'Delegate> /// Event implementations for a delegate types following the standard .NET Framework convention of a first 'sender' argument. + /// + /// Events and Observables [] type Event<'Delegate,'Args when 'Delegate : delegate<'Args,unit> and 'Delegate :> System.Delegate > = /// Creates an event object suitable for delegate types following the standard .NET Framework convention of a first 'sender' argument. @@ -36,6 +40,8 @@ namespace Microsoft.FSharp.Control /// Event implementations for the IEvent<_> type. + /// + /// Events and Observables [] type Event<'T> = /// Creates an observable object. diff --git a/src/fsharp/FSharp.Core/eventmodule.fsi b/src/fsharp/FSharp.Core/eventmodule.fsi index 54a0c4057c8..b4ea1078fe4 100644 --- a/src/fsharp/FSharp.Core/eventmodule.fsi +++ b/src/fsharp/FSharp.Core/eventmodule.fsi @@ -7,6 +7,9 @@ namespace Microsoft.FSharp.Control [] [] + /// Contains operations for working with values of type . + /// + /// Events and Observables module Event = /// Fires the output event when either of the input events fire. diff --git a/src/fsharp/FSharp.Core/fslib-extra-pervasives.fsi b/src/fsharp/FSharp.Core/fslib-extra-pervasives.fsi index c1ef9149ae5..c7ae3fc6cf1 100644 --- a/src/fsharp/FSharp.Core/fslib-extra-pervasives.fsi +++ b/src/fsharp/FSharp.Core/fslib-extra-pervasives.fsi @@ -4,7 +4,9 @@ namespace Microsoft.FSharp.Core [] -/// A set of extra operators and functions. This module is opened by default when compiling all F# code. +/// A set of extra operators and functions. This module is automatically opened in all F# code. +/// +/// Basic Operators module ExtraTopLevelOperators = open System @@ -14,6 +16,7 @@ module ExtraTopLevelOperators = open Microsoft.FSharp.Text /// Print to stdout using the given format. + /// /// The formatter. /// /// The formatted result. @@ -173,6 +176,11 @@ namespace Microsoft.FSharp.Core.CompilerServices /// Represents the product of two measure expressions when returned as a generic argument of a provided type. + /// + /// + /// Library functionality for supporting type providers and code generated by the F# compiler. See + /// also F# Type Providers in the F# Language Guide. + /// type MeasureProduct<'Measure1, 'Measure2> /// Represents the inverse of a measure expressions when returned as a generic argument of a provided type. diff --git a/src/fsharp/FSharp.Core/list.fsi b/src/fsharp/FSharp.Core/list.fsi index 28acfb823c1..c4c560fb858 100644 --- a/src/fsharp/FSharp.Core/list.fsi +++ b/src/fsharp/FSharp.Core/list.fsi @@ -7,7 +7,11 @@ namespace Microsoft.FSharp.Collections open Microsoft.FSharp.Core open Microsoft.FSharp.Collections - /// Basic operations for values of type . + /// Contains operations for working with values of type . + /// + /// Operations for collections such as lists, arrays, sets, maps and sequences. See also + /// F# Collection Types in the F# Language Guide. + /// [] [] module List = @@ -806,7 +810,7 @@ namespace Microsoft.FSharp.Collections [] val sortWith: comparer:('T -> 'T -> int) -> list:'T list -> 'T list - /// Sorts the given list using keys given by the given projection. Keys are compared using Operators.compare. + /// Sorts the given list using keys given by the given projection. Keys are compared using . /// /// This is a stable sort, i.e. the original order of equal elements is preserved. /// The function to transform the list elements into the type to be compared. @@ -816,7 +820,7 @@ namespace Microsoft.FSharp.Collections [] val sortBy: projection:('T -> 'Key) -> list:'T list -> 'T list when 'Key : comparison - /// Sorts the given list using Operators.compare. + /// Sorts the given list using . /// /// This is a stable sort, i.e. the original order of equal elements is preserved. /// The input list. @@ -837,7 +841,7 @@ namespace Microsoft.FSharp.Collections [] val splitAt: index:int -> list:'T list -> ('T list * 'T list) - /// Sorts the given list in descending order using keys given by the given projection. Keys are compared using Operators.compare. + /// Sorts the given list in descending order using keys given by the given projection. Keys are compared using . /// /// This is a stable sort, i.e. the original order of equal elements is preserved. /// The function to transform the list elements into the type to be compared. @@ -847,7 +851,7 @@ namespace Microsoft.FSharp.Collections [] val inline sortByDescending: projection:('T -> 'Key) -> list:'T list -> 'T list when 'Key : comparison - /// Sorts the given list in descending order using Operators.compare. + /// Sorts the given list in descending order using . /// /// This is a stable sort, i.e. the original order of equal elements is preserved. /// The input list. diff --git a/src/fsharp/FSharp.Core/mailbox.fsi b/src/fsharp/FSharp.Core/mailbox.fsi index 65e31a192c6..3f36a6f9def 100644 --- a/src/fsharp/FSharp.Core/mailbox.fsi +++ b/src/fsharp/FSharp.Core/mailbox.fsi @@ -9,6 +9,8 @@ namespace Microsoft.FSharp.Control [] /// A handle to a capability to reply to a PostAndReply message. + /// + /// Agents type AsyncReplyChannel<'Reply> = /// Sends a reply to a PostAndReply message. /// The value to send. @@ -22,6 +24,8 @@ namespace Microsoft.FSharp.Control /// /// The agent may wait for messages using the Receive or TryReceive methods or /// scan through all available messages using the Scan or TryScan method. + /// + /// Agents [] type MailboxProcessor<'Msg> = diff --git a/src/fsharp/FSharp.Core/map.fsi b/src/fsharp/FSharp.Core/map.fsi index ebbe7762c0e..2f0360bf4cb 100644 --- a/src/fsharp/FSharp.Core/map.fsi +++ b/src/fsharp/FSharp.Core/map.fsi @@ -93,10 +93,9 @@ namespace Microsoft.FSharp.Collections interface IReadOnlyDictionary<'Key,'Value> override Equals : obj -> bool - /// Basic operations on values of type . + /// Contains operations for working with values of type . [] [] - /// Basic operations on values of type . module Map = /// Returns a new map with the binding added to the given map. diff --git a/src/fsharp/FSharp.Core/math/z.fsi b/src/fsharp/FSharp.Core/math/z.fsi index dcdb96ef604..463d57f3db0 100644 --- a/src/fsharp/FSharp.Core/math/z.fsi +++ b/src/fsharp/FSharp.Core/math/z.fsi @@ -12,11 +12,15 @@ namespace Microsoft.FSharp.Math namespace Microsoft.FSharp.Core - /// An abbreviation for + /// An abbreviation for . + /// + /// Basic Types type bigint = System.Numerics.BigInteger [] - /// Provides a default implementations of F# numeric literal syntax for literals of the form 'dddI' + /// Provides a default implementations of F# numeric literal syntax for literals of the form 'dddI' + /// + /// Language Primitives module NumericLiterals = /// Provides a default implementations of F# numeric literal syntax for literals of the form 'dddI' diff --git a/src/fsharp/FSharp.Core/nativeptr.fsi b/src/fsharp/FSharp.Core/nativeptr.fsi index 6fbdc484d05..a90abcdbfba 100644 --- a/src/fsharp/FSharp.Core/nativeptr.fsi +++ b/src/fsharp/FSharp.Core/nativeptr.fsi @@ -9,6 +9,12 @@ namespace Microsoft.FSharp.NativeInterop [] /// Contains operations on native pointers. Use of these operators may /// result in the generation of unverifiable code. + /// + /// + /// Library functionality for native interopability. See + /// also F# External Functions in + /// the F# Language Guide. + /// module NativePtr = [] diff --git a/src/fsharp/FSharp.Core/observable.fsi b/src/fsharp/FSharp.Core/observable.fsi index 479d306cdd4..5a8ee380b76 100644 --- a/src/fsharp/FSharp.Core/observable.fsi +++ b/src/fsharp/FSharp.Core/observable.fsi @@ -7,7 +7,9 @@ namespace Microsoft.FSharp.Control [] [] - /// Basic operations on first class event and other observable objects. + /// Contains operations for working with first class event and other observable objects. + /// + /// Events and Observables module Observable = /// Returns an observable for the merged observations from the sources. diff --git a/src/fsharp/FSharp.Core/option.fsi b/src/fsharp/FSharp.Core/option.fsi index 8854204201f..cff21e535b6 100644 --- a/src/fsharp/FSharp.Core/option.fsi +++ b/src/fsharp/FSharp.Core/option.fsi @@ -8,7 +8,9 @@ open Microsoft.FSharp.Collections [] -/// Basic operations on options. +/// Contains operations for working with options. +/// +/// Options module Option = /// Returns true if the option is not None. /// The input option. @@ -248,7 +250,9 @@ module Option = [] val toObj: value: 'T option -> 'T when 'T : null -/// Basic operations on value options. +/// Contains operations for working with value options. +/// +/// Options module ValueOption = /// Returns true if the value option is not ValueNone. /// diff --git a/src/fsharp/FSharp.Core/prim-types-prelude.fsi b/src/fsharp/FSharp.Core/prim-types-prelude.fsi index dcaf513abf3..3ab796ca91b 100644 --- a/src/fsharp/FSharp.Core/prim-types-prelude.fsi +++ b/src/fsharp/FSharp.Core/prim-types-prelude.fsi @@ -10,81 +10,133 @@ namespace Microsoft.FSharp.Core open System /// An abbreviation for the CLI type . + /// + /// Basic Types type obj = System.Object /// An abbreviation for the CLI type . + /// + /// Basic Types type exn = System.Exception /// An abbreviation for the CLI type . + /// + /// Basic Types type nativeint = System.IntPtr /// An abbreviation for the CLI type . + /// + /// Basic Types type unativeint = System.UIntPtr /// An abbreviation for the CLI type . + /// + /// Basic Types type string = System.String /// An abbreviation for the CLI type . + /// + /// Basic Types type float32 = System.Single /// An abbreviation for the CLI type . + /// + /// Basic Types type float = System.Double /// An abbreviation for the CLI type . Identical to . + /// + /// Basic Types type single = System.Single /// An abbreviation for the CLI type . Identical to . + /// + /// Basic Types type double = System.Double /// An abbreviation for the CLI type . + /// + /// Basic Types type sbyte = System.SByte /// An abbreviation for the CLI type . + /// + /// Basic Types type byte = System.Byte /// An abbreviation for the CLI type . + /// + /// Basic Types type int8 = System.SByte /// An abbreviation for the CLI type . + /// + /// Basic Types type uint8 = System.Byte /// An abbreviation for the CLI type . + /// + /// Basic Types type int16 = System.Int16 /// An abbreviation for the CLI type . + /// + /// Basic Types type uint16 = System.UInt16 /// An abbreviation for the CLI type . + /// + /// Basic Types type int32 = System.Int32 /// An abbreviation for the CLI type . + /// + /// Basic Types type uint32 = System.UInt32 /// An abbreviation for the CLI type . + /// + /// Basic Types type int64 = System.Int64 /// An abbreviation for the CLI type . + /// + /// Basic Types type uint64 = System.UInt64 /// An abbreviation for the CLI type . + /// + /// Basic Types type char = System.Char /// An abbreviation for the CLI type . + /// + /// Basic Types type bool = System.Boolean /// An abbreviation for the CLI type . + /// + /// Basic Types type decimal = System.Decimal /// An abbreviation for the CLI type . + /// + /// Basic Types type int = int32 /// An abbreviation for the CLI type . + /// + /// Basic Types type uint = uint32 /// Single dimensional, zero-based arrays, written int[], string[] etc. + /// /// Use the values in the Array module to manipulate values /// of this type, or the notation arr.[x] to get/set array /// values. + /// + /// Basic Types + /// type 'T ``[]`` = (# "!0[]" #) /// Two dimensional arrays, typically zero-based. @@ -94,6 +146,9 @@ namespace Microsoft.FSharp.Core /// values. /// /// Non-zero-based arrays can also be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,]`` = (# "!0[0 ... , 0 ... ]" #) /// Three dimensional arrays, typically zero-based. Non-zero-based arrays @@ -102,6 +157,9 @@ namespace Microsoft.FSharp.Core /// Use the values in the Array3D module /// to manipulate values of this type, or the notation arr.[x1,x2,x3] to get and set array /// values. + /// + /// Basic Types + /// type 'T ``[,,]`` = (# "!0[0 ...,0 ...,0 ...]" #) /// Four dimensional arrays, typically zero-based. Non-zero-based arrays @@ -110,140 +168,227 @@ namespace Microsoft.FSharp.Core /// Use the values in the Array4D module /// to manipulate values of this type, or the notation arr.[x1,x2,x3,x4] to get and set array /// values. + /// + /// Basic Types + /// type 'T ``[,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...]" #) /// Five dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Six dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Seven dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Eight dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Nine dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Ten dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Eleven dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Twelve dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Thirteen dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Fourteen dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Fifteen dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Sixteen dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Seventeen dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Eighteen dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Nineteen dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Twenty dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Twenty-one dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Twenty-two dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Twenty-three dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Twenty-four dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Twenty-five dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Twenty-six dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Twenty-seven dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Twenty-eight dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Twenty-nine dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Thirty dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Thirty-one dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) /// Thirty-two dimensional arrays, typically zero-based. Non-zero-based arrays /// can be created using methods on the System.Array type. + /// + /// Basic Types + /// type 'T ``[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]`` = (# "!0[0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...,0 ...]" #) @@ -252,6 +397,8 @@ namespace Microsoft.FSharp.Core /// Use the values in the module to manipulate values /// of this type, or the notation arr.[x] to get/set array /// values. + /// + /// Basic Types type 'T array = 'T[] /// Represents an unmanaged pointer in F# code. @@ -261,6 +408,8 @@ namespace Microsoft.FSharp.Core /// unverifiable code being generated. Conversions to and from the /// type may be required. Values of this type can be generated /// by the functions in the NativeInterop.NativePtr module. + /// + /// ByRef and Pointer Types type nativeptr<'T when 'T : unmanaged> = (# "native int" #) /// Represents an untyped unmanaged pointer in F# code. @@ -270,8 +419,12 @@ namespace Microsoft.FSharp.Core /// unverifiable code being generated. Conversions to and from the /// type may be required. Values of this type can be generated /// by the functions in the NativeInterop.NativePtr module. + /// + /// ByRef and Pointer Types type voidptr = (# "void*" #) /// This type is for internal use by the F# code generator. + /// + /// ByRef and Pointer Types type ilsigptr<'T> = (# "!0*" #) diff --git a/src/fsharp/FSharp.Core/prim-types.fsi b/src/fsharp/FSharp.Core/prim-types.fsi index 3370b699150..398fbd0a0f3 100644 --- a/src/fsharp/FSharp.Core/prim-types.fsi +++ b/src/fsharp/FSharp.Core/prim-types.fsi @@ -8,16 +8,27 @@ namespace Microsoft.FSharp.Core open System + /// + /// Basic definitions of operators, options, functions, results, choices, attributes and plain text formatting. + /// + /// /// The type 'unit', which has only one value "()". This value is special and /// always uses the representation 'null'. + /// + /// Basic Types + /// type Unit = interface IComparable /// The type 'unit', which has only one value "()". This value is special and /// always uses the representation 'null'. + /// + /// Basic Types and unit = Unit /// Indicates the relationship between a compiled entity in a CLI binary and an element in F# source code. + /// + /// Attributes type SourceConstructFlags = /// Indicates that the compiled entity has no relationship to an element in F# source code. | None = 0 @@ -57,6 +68,8 @@ namespace Microsoft.FSharp.Core [] /// Indicates one or more adjustments to the compiled representation of an F# type or member. + /// + /// Attributes type CompilationRepresentationFlags = /// No special compilation representation. @@ -79,6 +92,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to class definition makes it sealed, which means it may not /// be extended or implemented. + /// + /// Attributes [] type SealedAttribute = inherit Attribute @@ -98,6 +113,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to class definition makes it abstract, which means it need not /// implement all its methods. Instances of abstract classes may not be constructed directly. + /// + /// Attributes [] [] type AbstractClassAttribute = @@ -110,6 +127,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to the let-binding for the definition of a top-level /// value makes the quotation expression that implements the value available /// for use at runtime. + /// + /// Attributes [] [] type ReflectedDefinitionAttribute = @@ -141,7 +160,10 @@ namespace Microsoft.FSharp.Core /// as C<(int -> int)> will not support equality because the type (int -> int) is an F# function type /// and does not support equality. /// - /// This attribute will be ignored if it is used on the generic parameters of functions or methods. + /// This attribute will be ignored if it is used on the generic parameters of functions or methods. + /// + /// + /// Attributes [] [] type EqualityConditionalOnAttribute = @@ -161,7 +183,10 @@ namespace Microsoft.FSharp.Core /// as C<(int -> int)> will not support comparison because the type (int -> int) is an F# function type /// and does not support comparison. /// - /// This attribute will be ignored if it is used on the generic parameters of functions or methods. + /// This attribute will be ignored if it is used on the generic parameters of functions or methods. + /// + /// + /// Attributes [] [] type ComparisonConditionalOnAttribute = @@ -172,6 +197,8 @@ namespace Microsoft.FSharp.Core new : unit -> ComparisonConditionalOnAttribute /// Adding this attribute to a type causes it to be represented using a CLI struct. + /// + /// Attributes [] [] type StructAttribute = @@ -183,6 +210,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a type causes it to be interpreted as a unit of measure. /// This may only be used under very limited conditions. + /// + /// Attributes [] [] type MeasureAttribute = @@ -194,6 +223,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a type causes it to be interpreted as a refined type, currently limited to measure-parameterized types. /// This may only be used under very limited conditions. + /// + /// Attributes [] [] type MeasureAnnotatedAbbreviationAttribute = @@ -204,6 +235,8 @@ namespace Microsoft.FSharp.Core new : unit -> MeasureAnnotatedAbbreviationAttribute /// Adding this attribute to a type causes it to be represented using a CLI interface. + /// + /// Attributes [] [] type InterfaceAttribute = @@ -214,6 +247,8 @@ namespace Microsoft.FSharp.Core new : unit -> InterfaceAttribute /// Adding this attribute to a type causes it to be represented using a CLI class. + /// + /// Attributes [] [] type ClassAttribute = @@ -226,6 +261,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a type lets the 'null' literal be used for the type /// within F# code. This attribute may only be added to F#-defined class or /// interface types. + /// + /// Attributes [] [] type AllowNullLiteralAttribute = @@ -243,6 +280,8 @@ namespace Microsoft.FSharp.Core member Value: bool /// Adding this attribute to a value causes it to be compiled as a CLI constant literal. + /// + /// Attributes [] [] type LiteralAttribute = @@ -255,6 +294,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a property with event type causes it to be compiled with as a CLI /// metadata event, through a syntactic translation to a pair of 'add_EventName' and /// 'remove_EventName' methods. + /// + /// Attributes [] [] type CLIEventAttribute = @@ -266,6 +307,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a record type causes it to be compiled to a CLI representation /// with a default constructor with property getters and setters. + /// + /// Attributes [] [] type CLIMutableAttribute = @@ -278,6 +321,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a discriminated union with value false /// turns off the generation of standard helper member tester, constructor /// and accessor members for the generated CLI class for that type. + /// + /// Attributes [] [] type DefaultAugmentationAttribute = @@ -296,6 +341,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to an F# mutable binding causes the "volatile" /// prefix to be used for all accesses to the field. + /// + /// Attributes [] [] type VolatileFieldAttribute = @@ -308,6 +355,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a function indicates it is the entrypoint for an application. /// If this attribute is not specified for an EXE then the initialization implicit in the /// module bindings in the last file in the compilation sequence are used as the entrypoint. + /// + /// Attributes [] [] type EntryPointAttribute = @@ -320,6 +369,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a record or union type disables the automatic generation /// of overrides for 'System.Object.Equals(obj)', 'System.Object.GetHashCode()' /// and 'System.IComparable' for the type. The type will by default use reference equality. + /// + /// Attributes [] [] type ReferenceEqualityAttribute = @@ -332,6 +383,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a record, union or struct type confirms the automatic /// generation of overrides for 'System.Object.Equals(obj)' and /// 'System.Object.GetHashCode()' for the type. + /// + /// Attributes [] [] type StructuralEqualityAttribute = @@ -343,6 +396,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a record, union, exception, or struct type confirms the /// automatic generation of implementations for 'System.IComparable' for the type. + /// + /// Attributes [] [] type StructuralComparisonAttribute = @@ -354,8 +409,10 @@ namespace Microsoft.FSharp.Core [] [] - /// Indicates that a member on a computation builder type is a custom query operator, - /// and indicates the name of that operator. + /// Indicates that a member on a computation builder type is a custom query operator, + /// and indicates the name of that operator. + /// + /// Attributes type CustomOperationAttribute = inherit Attribute @@ -391,6 +448,8 @@ namespace Microsoft.FSharp.Core [] /// Indicates that, when a custom operator is used in a computation expression, /// a parameter is automatically parameterized by the variable space of the computation expression + /// + /// Attributes type ProjectionParameterAttribute = /// Creates an instance of the attribute @@ -403,6 +462,8 @@ namespace Microsoft.FSharp.Core /// F# type system, this helps ensure that the F# generic equality function is not instantiated directly /// at this type. The attribute and checking does not constrain the use of comparison with base or child /// types of this type. + /// + /// Attributes [] [] type NoEqualityAttribute = @@ -413,6 +474,8 @@ namespace Microsoft.FSharp.Core new : unit -> NoEqualityAttribute /// Adding this attribute to a type indicates it is a type with a user-defined implementation of equality. + /// + /// Attributes [] [] type CustomEqualityAttribute = @@ -423,6 +486,8 @@ namespace Microsoft.FSharp.Core new : unit -> CustomEqualityAttribute /// Adding this attribute to a type indicates it is a type with a user-defined implementation of comparison. + /// + /// Attributes [] [] type CustomComparisonAttribute = @@ -436,7 +501,10 @@ namespace Microsoft.FSharp.Core /// This means that the type does not satisfy the F# 'comparison' constraint. Within the bounds of the /// F# type system, this helps ensure that the F# generic comparison function is not instantiated directly /// at this type. The attribute and checking does not constrain the use of comparison with base or child - /// types of this type. + /// types of this type. + /// + /// + /// Attributes [] [] type NoComparisonAttribute = @@ -448,7 +516,10 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a field declaration means that the field is /// not initialized. During type checking a constraint is asserted that the field type supports 'null'. - /// If the 'check' value is false then the constraint is not asserted. + /// If the 'check' value is false then the constraint is not asserted. + /// + /// + /// Attributes [] [] type DefaultValueAttribute = @@ -469,6 +540,8 @@ namespace Microsoft.FSharp.Core new : check: bool -> DefaultValueAttribute /// This attribute is added automatically for all optional arguments. + /// + /// Attributes [] [] type OptionalArgumentAttribute = @@ -480,6 +553,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a type, value or member requires that /// uses of the construct must explicitly instantiate any generic type parameters. + /// + /// Attributes [] [] type RequiresExplicitTypeArgumentsAttribute = @@ -491,6 +566,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a non-function value with generic parameters indicates that /// uses of the construct can give rise to generic code through type inference. + /// + /// Attributes [] [] type GeneralizableValueAttribute = @@ -502,6 +579,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a value or function definition in an F# module changes the name used /// for the value in compiled CLI code. + /// + /// Attributes [] [] type CompiledNameAttribute = @@ -519,6 +598,8 @@ namespace Microsoft.FSharp.Core /// Adding this attribute to a type with value 'false' disables the behaviour where F# makes the /// type Serializable by default. + /// + /// Attributes [] [] type AutoSerializableAttribute = @@ -537,6 +618,8 @@ namespace Microsoft.FSharp.Core /// This attribute is added to generated assemblies to indicate the /// version of the data schema used to encode additional F# /// specific information in the resource attached to compiled F# libraries. + /// + /// Attributes [] [] type FSharpInterfaceDataVersionAttribute = @@ -567,6 +650,8 @@ namespace Microsoft.FSharp.Core /// This attribute is used by the functions in the /// FSharp.Reflection namespace to reverse-map compiled constructs to /// their original forms. It is not intended for use from user code. + /// + /// Attributes [] [] type CompilationMappingAttribute = @@ -619,7 +704,10 @@ namespace Microsoft.FSharp.Core /// /// This attribute is used by the functions in the /// FSharp.Reflection namespace to reverse-map compiled constructs to - /// their original forms. It is not intended for use from user code. + /// their original forms. It is not intended for use from user code. + /// + /// + /// Attributes [] [] type CompilationSourceNameAttribute = @@ -637,7 +725,10 @@ namespace Microsoft.FSharp.Core /// This attribute is used to adjust the runtime representation for a type. /// For example, it may be used to note that the null representation - /// may be used for a type. This affects how some constructs are compiled. + /// may be used for a type. This affects how some constructs are compiled. + /// + /// + /// Attributes [] [] type CompilationRepresentationAttribute = @@ -661,6 +752,8 @@ namespace Microsoft.FSharp.Core /// This attribute is used to tag values that are part of an experimental library /// feature. + /// + /// Attributes [] [] type ExperimentalAttribute = @@ -677,7 +770,10 @@ namespace Microsoft.FSharp.Core member Message: string /// This attribute is generated automatically by the F# compiler to tag functions and members - /// that accept a partial application of some of their arguments and return a residual function + /// that accept a partial application of some of their arguments and return a residual function. + /// + /// + /// Attributes [] [] type CompilationArgumentCountsAttribute = @@ -697,6 +793,8 @@ namespace Microsoft.FSharp.Core /// '%A' printf formatting patterns and other two-dimensional text-based display layouts. /// In this version of F# valid values are of the form PreText {PropertyName1} PostText {PropertyName2} ... {PropertyNameX} PostText. /// The property names indicate properties to evaluate and to display instead of the object itself. + /// + /// Attributes [] [] type StructuredFormatDisplayAttribute = @@ -715,6 +813,8 @@ namespace Microsoft.FSharp.Core member Value: string /// Indicates that a message should be emitted when F# source code uses this construct. + /// + /// Attributes [] [] type CompilerMessageAttribute = @@ -740,6 +840,8 @@ namespace Microsoft.FSharp.Core /// of unverifiable code. These values are inevitably marked 'inline' to ensure that /// the unverifiable constructs are not present in the actual code for the F# library, /// but are rather copied to the source code of the caller. + /// + /// Attributes [] [] type UnverifiableAttribute = @@ -754,6 +856,8 @@ namespace Microsoft.FSharp.Core /// causes the method body emitted for the inlined function to raise an exception if /// dynamically invoked, rather than including the unverifiable code in the generated /// assembly. + /// + /// Attributes [] [] type NoDynamicInvocationAttribute = @@ -767,6 +871,8 @@ namespace Microsoft.FSharp.Core /// This attribute is used to indicate that references to the elements of a module, record or union /// type require explicit qualified access. + /// + /// Attributes [] [] type RequireQualifiedAccessAttribute = @@ -785,7 +891,10 @@ namespace Microsoft.FSharp.Core /// where the given path is automatically opened. /// /// When applied to a type or module within an assembly, then the attribute must not be given any arguments, and - /// the type or module is implicitly opened when its enclosing namespace or module is opened. + /// the type or module is implicitly opened when its enclosing namespace or module is opened. + /// + /// + /// Attributes [] [] type AutoOpenAttribute = @@ -812,13 +921,18 @@ namespace Microsoft.FSharp.Core /// of measure is erased in compiled code and when values of this type /// are analyzed using reflection. The type is representationally equivalent to /// . + /// + /// Basic Types with Units of Measure type float<[] 'Measure> = float [] /// The type of floating point numbers, annotated with a unit of measure. The unit /// of measure is erased in compiled code and when values of this type /// are analyzed using reflection. The type is representationally equivalent to - /// . + /// . + /// + /// + /// Basic Types with Units of Measure type float32<[] 'Measure> = float32 [] @@ -826,6 +940,8 @@ namespace Microsoft.FSharp.Core /// of measure is erased in compiled code and when values of this type /// are analyzed using reflection. The type is representationally equivalent to /// . + /// + /// Basic Types with Units of Measure type decimal<[] 'Measure> = decimal [] @@ -833,6 +949,8 @@ namespace Microsoft.FSharp.Core /// of measure is erased in compiled code and when values of this type /// are analyzed using reflection. The type is representationally equivalent to /// . + /// + /// Basic Types with Units of Measure type int<[] 'Measure> = int [] @@ -840,6 +958,8 @@ namespace Microsoft.FSharp.Core /// of measure is erased in compiled code and when values of this type /// are analyzed using reflection. The type is representationally equivalent to /// . + /// + /// Basic Types with Units of Measure type sbyte<[] 'Measure> = sbyte [] @@ -847,6 +967,8 @@ namespace Microsoft.FSharp.Core /// of measure is erased in compiled code and when values of this type /// are analyzed using reflection. The type is representationally equivalent to /// . + /// + /// Basic Types with Units of Measure type int16<[] 'Measure> = int16 [] @@ -854,6 +976,8 @@ namespace Microsoft.FSharp.Core /// of measure is erased in compiled code and when values of this type /// are analyzed using reflection. The type is representationally equivalent to /// . + /// + /// Basic Types with Units of Measure type int64<[] 'Measure> = int64 /// Represents a managed pointer in F# code. @@ -862,17 +986,20 @@ namespace Microsoft.FSharp.Core #else [] #endif + /// ByRef and Pointer Types type byref<'T, 'Kind> = (# "!0&" #) /// Represents a managed pointer in F# code. For F# 4.5+ this is considered equivalent to byref<'T, ByRefKinds.InOut> + /// ByRef and Pointer Types type byref<'T> = (# "!0&" #) - /// Represents the types of byrefs in F# 4.5+ + /// Represents the types of byrefs in F# 4.5+ #if BUILDING_WITH_LKG || BUILD_FROM_SOURCE [] #else [] #endif + /// ByRef and Pointer Types module ByRefKinds = /// Represents a byref that can be written @@ -900,12 +1027,16 @@ namespace Microsoft.FSharp.Core type InOut /// Represents a in-argument or readonly managed pointer in F# code. This type should only be used with F# 4.5+. + /// ByRef and Pointer Types type inref<'T> = byref<'T, ByRefKinds.In> /// Represents a out-argument managed pointer in F# code. This type should only be used with F# 4.5+. + /// ByRef and Pointer Types type outref<'T> = byref<'T, ByRefKinds.Out> /// Language primitives associated with the F# language + /// + /// Language Primitives module LanguagePrimitives = /// Compare two values for equality using partial equivalence relation semantics ([nan] <> [nan]) @@ -1566,7 +1697,7 @@ namespace Microsoft.FSharp.Core /// Helper types for active patterns with 2 choices. - //[] + /// Choices and Results [] [] type Choice<'T1,'T2> = @@ -1578,6 +1709,7 @@ namespace Microsoft.FSharp.Core | Choice2Of2 of 'T2 /// Helper types for active patterns with 3 choices. + /// Choices and Results [] [] type Choice<'T1,'T2,'T3> = @@ -1592,6 +1724,7 @@ namespace Microsoft.FSharp.Core | Choice3Of3 of 'T3 /// Helper types for active patterns with 4 choices. + /// Choices and Results [] [] type Choice<'T1,'T2,'T3,'T4> = @@ -1609,6 +1742,7 @@ namespace Microsoft.FSharp.Core | Choice4Of4 of 'T4 /// Helper types for active patterns with 5 choices. + /// Choices and Results [] [] type Choice<'T1,'T2,'T3,'T4,'T5> = @@ -1629,6 +1763,7 @@ namespace Microsoft.FSharp.Core | Choice5Of5 of 'T5 /// Helper types for active patterns with 6 choices. + /// Choices and Results [] [] type Choice<'T1,'T2,'T3,'T4,'T5,'T6> = @@ -1652,6 +1787,7 @@ namespace Microsoft.FSharp.Core | Choice6Of6 of 'T6 /// Helper types for active patterns with 7 choices. + /// Choices and Results [] [] type Choice<'T1,'T2,'T3,'T4,'T5,'T6,'T7> = @@ -1678,11 +1814,13 @@ namespace Microsoft.FSharp.Core | Choice7Of7 of 'T7 /// Non-exhaustive match failures will raise the MatchFailureException exception + /// Language Primitives [] exception MatchFailureException of string * int * int /// The CLI type used to represent F# first-class type function values. This type is for use /// by compiled F# code. + /// Language Primitives [] type FSharpTypeFunc = @@ -1696,6 +1834,7 @@ namespace Microsoft.FSharp.Core /// The CLI type used to represent F# function values. This type is not /// typically used directly, though may be used from other CLI languages. + /// Language Primitives [] type FSharpFunc<'T,'U> = @@ -1788,6 +1927,7 @@ namespace Microsoft.FSharp.Core [] /// Helper functions for converting F# first class function values to and from CLI representations /// of functions using delegates. + /// Language Primitives type FuncConvert = /// Convert the given Action delegate object to an F# function value @@ -1918,6 +2058,7 @@ namespace Microsoft.FSharp.Core /// An implementation module used to hold some private implementations of function /// value invocation. + /// Language Primitives module OptimizedClosures = /// The CLI type used to represent F# function values that accept @@ -2044,6 +2185,9 @@ namespace Microsoft.FSharp.Core /// The type of mutable references. Use the functions [!] and [:=] to get and /// set values of this type. + /// + /// Basic Types + /// [] [] type Ref<'T> = @@ -2055,6 +2199,7 @@ namespace Microsoft.FSharp.Core /// The type of mutable references. Use the functions [!] and [:=] to get and /// set values of this type. + /// Basic Types and 'T ref = Ref<'T> /// The type of optional values. When used from other CLI languages the @@ -2067,6 +2212,9 @@ namespace Microsoft.FSharp.Core /// None values will appear as the value null to other CLI languages. /// Instance methods on this type will appear as static methods to other CLI languages /// due to the use of null as a value representation. + /// + /// Options + /// [] [] [] @@ -2084,6 +2232,7 @@ namespace Microsoft.FSharp.Core | Some : Value:'T -> 'T option /// Create an option value that is a 'None' value. + /// static member None : 'T option /// Create an option value that is a 'Some' value. @@ -2091,6 +2240,7 @@ namespace Microsoft.FSharp.Core /// The input value /// /// An option representing the value. + /// static member Some : value:'T -> 'T option /// Implicitly converts a value into an optional that is a 'Some' value. @@ -2098,6 +2248,7 @@ namespace Microsoft.FSharp.Core /// The input value /// /// An option representing the value. + /// static member op_Implicit : value:'T -> 'T option [] @@ -2120,6 +2271,8 @@ namespace Microsoft.FSharp.Core /// 'None' values will appear as the value null to other CLI languages. /// Instance methods on this type will appear as static methods to other CLI languages /// due to the use of null as a value representation. + /// + /// Options and 'T option = Option<'T> /// The type of optional values, represented as structs. @@ -2127,6 +2280,9 @@ namespace Microsoft.FSharp.Core /// Use the constructors ValueSome and ValueNone to create values of this type. /// Use the values in the ValueOption module to manipulate values of this type, /// or pattern match against the values directly. + /// + /// Options + /// [] [] [] @@ -2145,6 +2301,7 @@ namespace Microsoft.FSharp.Core member Value : 'T /// Create a value option value that is a 'ValueNone' value. + /// static member None : 'T voption /// Create a value option value that is a 'Some' value. @@ -2152,6 +2309,7 @@ namespace Microsoft.FSharp.Core /// The input value /// /// A value option representing the value. + /// static member Some : value:'T -> 'T voption /// Return 'true' if the value option is a 'ValueSome' value. @@ -2165,6 +2323,7 @@ namespace Microsoft.FSharp.Core /// The input value /// /// A voption representing the value. + /// static member op_Implicit: value: 'T -> 'T voption /// The type of optional values, represented as structs. @@ -2172,9 +2331,13 @@ namespace Microsoft.FSharp.Core /// Use the constructors ValueSome and ValueNone to create values of this type. /// Use the values in the ValueOption module to manipulate values of this type, /// or pattern match against the values directly. + /// + /// Options and 'T voption = ValueOption<'T> /// Helper type for error handling without exceptions. + /// + /// Choices and Results [] [] [] @@ -2197,7 +2360,10 @@ namespace Microsoft.FSharp.Collections /// /// Use the constructors [] and :: (infix) to create values of this type, or /// the notation [1;2;3]. Use the values in the List module to manipulate - /// values of this type, or pattern match against the values directly. + /// values of this type, or pattern match against the values directly. + /// + /// + /// [] [] [] @@ -2289,6 +2455,8 @@ namespace Microsoft.FSharp.Core open Microsoft.FSharp.Collections /// Basic F# Operators. This module is automatically opened in all F# code. + /// + /// Basic Operators [] module Operators = @@ -3278,6 +3446,8 @@ namespace Microsoft.FSharp.Core [] [] + /// Contains extension methods to allow the use of F# indexer notation with arrays. + /// This module is automatically opened in all F# code. module ArrayExtensions = type ``[,,,]``<'T> with /// Get the index for the element offset elements away from the end of the collection. @@ -4471,6 +4641,8 @@ namespace Microsoft.FSharp.Control open Microsoft.FSharp.Core /// Extensions related to Lazy values. + /// + /// Lazy Computation [] module LazyExtensions = @@ -4503,6 +4675,8 @@ namespace Microsoft.FSharp.Control /// Use the values in the Lazy module to manipulate /// values of this type, and the notation lazy expr to create values /// of type . + /// + /// Lazy Computation type Lazy<'T> = System.Lazy<'T> and [] @@ -4518,6 +4692,8 @@ namespace Microsoft.FSharp.Control /// F# gives special status to member properties compatible with type IDelegateEvent and /// tagged with the CLIEventAttribute. In this case the F# compiler generates appropriate /// CLI metadata to make the member appear to other CLI languages as a CLI event. + /// + /// Events and Observables type IDelegateEvent<'Delegate when 'Delegate :> System.Delegate > = /// Connect a handler delegate object to the event. A handler can @@ -4533,6 +4709,8 @@ namespace Microsoft.FSharp.Control abstract RemoveHandler: handler:'Delegate -> unit /// First class event values for CLI events conforming to CLI Framework standards. + /// + /// Events and Observables [] type IEvent<'Delegate,'Args when 'Delegate : delegate<'Args,unit> and 'Delegate :> System.Delegate > = inherit IDelegateEvent<'Delegate> @@ -4542,9 +4720,13 @@ namespace Microsoft.FSharp.Control /// /// The object that fired the event. /// The event arguments. + /// + /// Events and Observables [] type Handler<'T> = delegate of sender:obj * args:'T -> unit /// First-class listening points (i.e. objects that permit you to register a callback /// activated when the event is triggered). + /// + /// Events and Observables type IEvent<'T> = IEvent, 'T> diff --git a/src/fsharp/FSharp.Core/printf.fsi b/src/fsharp/FSharp.Core/printf.fsi index 37e98e99d27..be6bc3f5017 100644 --- a/src/fsharp/FSharp.Core/printf.fsi +++ b/src/fsharp/FSharp.Core/printf.fsi @@ -10,10 +10,13 @@ open System.IO open System.Text /// Type of a formatting expression. +/// /// Function type generated by printf. /// Type argument passed to %a formatters /// Value generated by the overall printf action (e.g. sprint generates a string) /// Value generated after post processing (e.g. failwithf generates a string internally then raises an exception) +/// +/// Language Primitives type PrintfFormat<'Printer,'State,'Residue,'Result> = /// Construct a format string @@ -26,11 +29,14 @@ type PrintfFormat<'Printer,'State,'Residue,'Result> = member Value : string /// Type of a formatting expression. +/// /// Function type generated by printf. /// Type argument passed to %a formatters /// Value generated by the overall printf action (e.g. sprint generates a string) /// Value generated after post processing (e.g. failwithf generates a string internally then raises an exception) /// Tuple of values generated by scan or match. +/// +/// Language Primitives type PrintfFormat<'Printer,'State,'Residue,'Result,'Tuple> = inherit PrintfFormat<'Printer,'State,'Residue,'Result> @@ -47,6 +53,8 @@ type PrintfFormat<'Printer,'State,'Residue,'Result,'Tuple> = /// Type argument passed to %a formatters /// Value generated by the overall printf action (e.g. sprint generates a string) /// Value generated after post processing (e.g. failwithf generates a string internally then raises an exception) +/// +/// Language Primitives type Format<'Printer,'State,'Residue,'Result> = PrintfFormat<'Printer,'State,'Residue,'Result> /// Type of a formatting expression. @@ -55,12 +63,16 @@ type Format<'Printer,'State,'Residue,'Result> = PrintfFormat<'Printer,'State,'Re /// Value generated by the overall printf action (e.g. sprint generates a string) /// Value generated after post processing (e.g. failwithf generates a string internally then raises an exception) /// Tuple of values generated by scan or match. +/// +/// Language Primitives type Format<'Printer,'State,'Residue,'Result,'Tuple> = PrintfFormat<'Printer,'State,'Residue,'Result,'Tuple> /// Extensible printf-style formatting for numbers and other datatypes /// /// Format specifications are strings with "%" markers indicating format /// placeholders. Format placeholders consist of %[flags][width][.precision][type]. +/// +/// Strings and Text [] module Printf = diff --git a/src/fsharp/FSharp.Core/quotations.fsi b/src/fsharp/FSharp.Core/quotations.fsi index bdeab19a85b..37679515a58 100644 --- a/src/fsharp/FSharp.Core/quotations.fsi +++ b/src/fsharp/FSharp.Core/quotations.fsi @@ -10,6 +10,11 @@ open System open System.Reflection /// Information at the binding site of a variable +/// +/// +/// Library functionality for F# quotations. +/// See also F# Code Quotations in the F# Language Guide. +/// [] [] type Var = @@ -23,6 +28,7 @@ type Var = member IsMutable: bool /// Creates a new variable with the given name, type and mutability + /// /// The declared name of the variable. /// The type associated with the variable. /// Indicates if the variable represents a mutable storage location. Default is false. @@ -567,7 +573,7 @@ module Patterns = /// /// The input expression to match against. /// - /// Expr option + /// When successful, the pattern binds the sub-expression of the input AddressOf expression [] val (|AddressOf|_|) : input:Expr -> Expr option @@ -575,7 +581,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr * Expr) option + /// When successful, the pattern binds the target and value expressions of the input expression [] val (|AddressSet|_|) : input:Expr -> (Expr * Expr) option @@ -583,7 +589,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr * Expr) option + /// When successful, the pattern binds the function and argument of the input expression [] val (|Application|_|) : input:Expr -> (Expr * Expr) option @@ -591,7 +597,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr option * MethodInfo * Expr list) option + /// When successful, the pattern binds the object, method and argument sub-expressions of the input expression [] val (|Call|_|) : input:Expr -> (Expr option * MethodInfo * Expr list) option @@ -599,7 +605,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr option * MethodInfo * MethodInfo * Expr list) option + /// When successful, the pattern binds the object, method, witness-argument and argument sub-expressions of the input expression [] [] val (|CallWithWitnesses|_|) : input:Expr -> (Expr option * MethodInfo * MethodInfo * Expr list * Expr list) option @@ -608,7 +614,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr * Type) option + /// When successful, the pattern binds the source expression and target type of the input expression [] val (|Coerce|_|) : input:Expr -> (Expr * Type) option @@ -616,7 +622,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr option * FieldInfo) option + /// When successful, the pattern binds the object and field of the input expression [] val (|FieldGet|_|) : input:Expr -> (Expr option * FieldInfo) option @@ -624,7 +630,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr option * FieldInfo * Expr) option + /// When successful, the pattern binds the object, field and value of the input expression [] val (|FieldSet|_|) : input:Expr -> (Expr option * FieldInfo * Expr) option @@ -632,7 +638,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Var * Expr * Expr * Expr) option + /// When successful, the pattern binds the value, start, finish and body of the input expression [] val (|ForIntegerRangeLoop|_|) : input:Expr -> (Var * Expr * Expr * Expr) option @@ -640,7 +646,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr * Expr) option + /// When successful, the pattern binds the guard and body of the input expression [] val (|WhileLoop|_|) : input:Expr -> (Expr * Expr) option @@ -648,7 +654,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr * Expr * Expr) option + /// When successful, the pattern binds the condition, then-branch and else-branch of the input expression [] val (|IfThenElse|_|) : input:Expr -> (Expr * Expr * Expr) option @@ -656,7 +662,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Var * Expr) option + /// When successful, the pattern binds the variable and body of the input expression [] val (|Lambda|_|) : input:Expr -> (Var * Expr) option @@ -664,7 +670,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Var * Expr * Expr) option + /// When successful, the pattern binds the variable, binding expression and body of the input expression [] val (|Let|_|) : input:Expr -> (Var * Expr * Expr) option @@ -672,7 +678,7 @@ module Patterns = /// /// The input expression to match against. /// - /// ((Var * Expr) list * Expr) option + /// When successful, the pattern binds the bindings and body of the input expression [] val (|LetRecursive|_|) : input:Expr -> ((Var * Expr) list * Expr) option @@ -680,7 +686,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Type * Expr list) option + /// When successful, the pattern binds the element type and values of the input expression [] val (|NewArray|_|) : input:Expr -> (Type * Expr list) option @@ -688,7 +694,7 @@ module Patterns = /// /// The input expression to match against. /// - /// Type option + /// When successful, the pattern binds the relevant type of the input expression [] val (|DefaultValue|_|) : input:Expr -> Type option @@ -696,7 +702,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Type * Var list * Expr) option + /// When successful, the pattern binds the delegate type, argument parameters and body of the input expression [] val (|NewDelegate|_|) : input:Expr -> (Type * Var list * Expr) option @@ -704,7 +710,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (ConstructorInfo * Expr list) option + /// When successful, the pattern binds the constructor and arguments of the input expression [] val (|NewObject|_|) : input:Expr -> (ConstructorInfo * Expr list) option @@ -712,7 +718,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Type * Expr list) option + /// When successful, the pattern binds the record type and field values of the input expression [] val (|NewRecord|_|) : input:Expr -> (Type * Expr list) option @@ -720,7 +726,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (UnionCaseInfo * Expr list) option + /// When successful, the pattern binds the union case and field values of the input expression [] val (|NewUnionCase|_|) : input:Expr -> (UnionCaseInfo * Expr list) option @@ -728,7 +734,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr list) option + /// When successful, the pattern binds the element expressions of the input expression [] val (|NewTuple|_|) : input:Expr -> (Expr list) option @@ -736,7 +742,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr list) option + /// When successful, the pattern binds the element expressions of the input expression [] val (|NewStructTuple|_|) : input:Expr -> (Expr list) option @@ -744,7 +750,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr option * PropertyInfo * Expr list) option + /// When successful, the pattern binds the object, property and indexer arguments of the input expression [] val (|PropertyGet|_|) : input:Expr -> (Expr option * PropertyInfo * Expr list) option @@ -752,7 +758,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr option * PropertyInfo * Expr list * Expr) option + /// When successful, the pattern binds the object, property, indexer arguments and setter value of the input expression [] val (|PropertySet|_|) : input:Expr -> (Expr option * PropertyInfo * Expr list * Expr) option @@ -760,7 +766,7 @@ module Patterns = /// /// The input expression to match against. /// - /// Expr option + /// When successful, the pattern binds the nested quotation expression of the input expression [] [] val (|Quote|_|) : input:Expr -> Expr option @@ -769,7 +775,7 @@ module Patterns = /// /// The input expression to match against. /// - /// Expr option + /// When successful, the pattern binds the nested quotation expression of the input expression [] val (|QuoteRaw|_|) : input:Expr -> Expr option @@ -777,7 +783,7 @@ module Patterns = /// /// The input expression to match against. /// - /// Expr option + /// When successful, the pattern binds the nested quotation expression of the input expression [] val (|QuoteTyped|_|) : input:Expr -> Expr option @@ -785,7 +791,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr * Expr) option + /// When successful, the pattern binds the two sub-expressions of the input expression [] val (|Sequential|_|) : input:Expr -> (Expr * Expr) option @@ -793,7 +799,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Expr * Var * Expr * Var * Expr) option + /// When successful, the pattern binds the body, exception variable, filter expression and catch expression of the input expression [] val (|TryWith|_|) : input:Expr -> (Expr * Var * Expr * Var * Expr) option @@ -801,7 +807,7 @@ module Patterns = /// /// The input expression to match against. /// - /// The body and handler parts of the try/finally expression + /// When successful, the pattern binds the body and handler parts of the try/finally expression [] val (|TryFinally|_|) : input:Expr -> (Expr * Expr) option @@ -809,7 +815,7 @@ module Patterns = /// /// The input expression to match against. /// - /// The expression and tuple field being accessed + /// When successful, the pattern binds the expression and tuple field being accessed [] val (|TupleGet|_|) : input:Expr -> (Expr * int) option @@ -817,7 +823,7 @@ module Patterns = /// /// The input expression to match against. /// - /// The expression and type being tested + /// When successful, the pattern binds the expression and type being tested [] val (|TypeTest|_|) : input:Expr -> (Expr * Type) option @@ -825,7 +831,7 @@ module Patterns = /// /// The input expression to match against. /// - /// The expression and union case being tested + /// When successful, the pattern binds the expression and union case being tested [] val (|UnionCaseTest|_|) : input:Expr -> (Expr * UnionCaseInfo) option @@ -833,7 +839,7 @@ module Patterns = /// /// The input expression to match against. /// - /// The boxed value and its static type + /// When successful, the pattern binds the boxed value and its static type [] val (|Value|_|) : input:Expr -> (obj * Type) option @@ -841,7 +847,7 @@ module Patterns = /// /// The input expression to match against. /// - /// The boxed value, its static type and its name + /// When successful, the pattern binds the boxed value, its static type and its name [] val (|ValueWithName|_|) : input:Expr -> (obj * Type * string) option @@ -849,7 +855,7 @@ module Patterns = /// /// The input expression to match against. /// - /// The boxed value, its static type and its definition + /// When successful, the pattern binds the boxed value, its static type and its definition [] val (|WithValue|_|) : input:Expr -> (obj * Type * Expr) option @@ -857,7 +863,7 @@ module Patterns = /// /// The input expression to match against. /// - /// Var option + /// When successful, the pattern binds the variable of the input expression [] val (|Var|_|) : input:Expr -> Var option @@ -865,7 +871,7 @@ module Patterns = /// /// The input expression to match against. /// - /// (Var * Expr) option + /// When successful, the pattern binds the variable and value expression of the input expression [] val (|VarSet|_|) : input:Expr -> (Var * Expr) option @@ -877,7 +883,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// (Var list list * Expr) option + /// When successful, the pattern binds the curried variables and body of the input expression [] val (|Lambdas|_|) : input:Expr -> (Var list list * Expr) option @@ -885,7 +891,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// (Expr * Expr list list) option + /// When successful, the pattern binds the function and curried arguments of the input expression [] val (|Applications|_|) : input:Expr -> (Expr * Expr list list) option @@ -893,7 +899,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// (Expr * Expr) option + /// When successful, the pattern binds the left and right parts of the input expression [] val (|AndAlso|_|) : input:Expr -> (Expr * Expr) option @@ -901,7 +907,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// (Expr * Expr) option + /// When successful, the pattern binds the left and right parts of the input expression [] val (|OrElse|_|) : input:Expr -> (Expr * Expr) option @@ -909,7 +915,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// unit option + /// When successful, the pattern does not bind any results [] val (|Unit|_|) : input:Expr -> unit option @@ -917,7 +923,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// bool option + /// When successful, the pattern binds the constant value from the input expression [] val (|Bool|_|) : input:Expr -> bool option @@ -925,7 +931,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// string option + /// When successful, the pattern binds the constant value from the input expression [] val (|String|_|) : input:Expr -> string option @@ -933,7 +939,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// float32 option + /// When successful, the pattern binds the constant value from the input expression [] val (|Single|_|) : input:Expr -> float32 option @@ -941,7 +947,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// float option + /// When successful, the pattern binds the constant value from the input expression [] val (|Double|_|) : input:Expr -> float option @@ -949,7 +955,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// char option + /// When successful, the pattern binds the constant value from the input expression [] val (|Char|_|) : input:Expr -> char option @@ -957,7 +963,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// sbyte option + /// When successful, the pattern binds the constant value from the input expression [] val (|SByte|_|) : input:Expr -> sbyte option @@ -965,7 +971,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// byte option + /// When successful, the pattern binds the constant value from the input expression [] val (|Byte|_|) : input:Expr -> byte option @@ -973,7 +979,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// int16 option + /// When successful, the pattern binds the constant value from the input expression [] val (|Int16|_|) : input:Expr -> int16 option @@ -981,7 +987,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// uint16 option + /// When successful, the pattern binds the constant value from the input expression [] val (|UInt16|_|) : input:Expr -> uint16 option @@ -989,7 +995,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// int32 option + /// When successful, the pattern binds the constant value from the input expression [] val (|Int32|_|) : input:Expr -> int32 option @@ -997,7 +1003,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// uint32 option + /// When successful, the pattern binds the constant value from the input expression [] val (|UInt32|_|) : input:Expr -> uint32 option @@ -1005,7 +1011,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// int64 option + /// When successful, the pattern binds the constant value from the input expression [] val (|Int64|_|) : input:Expr -> int64 option @@ -1013,7 +1019,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// uint64 option + /// When successful, the pattern binds the constant value from the input expression [] val (|UInt64|_|) : input:Expr -> uint64 option @@ -1021,7 +1027,7 @@ module DerivedPatterns = /// /// The input expression to match against. /// - /// decimal option + /// When successful, the pattern binds the constant value from the input expression [] val (|Decimal|_|) : input:Expr -> decimal option diff --git a/src/fsharp/FSharp.Core/reflect.fsi b/src/fsharp/FSharp.Core/reflect.fsi index e6c2f6f9098..948e778aace 100644 --- a/src/fsharp/FSharp.Core/reflect.fsi +++ b/src/fsharp/FSharp.Core/reflect.fsi @@ -10,10 +10,12 @@ open Microsoft.FSharp.Core open Microsoft.FSharp.Primitives.Basics open Microsoft.FSharp.Collections -//--------------------------------------------------------------------- -// F# reified type inspection. - /// Represents a case of a discriminated union type +/// +/// +/// Library functionality for accessing additional information about F# types and F# values at +/// runtime, augmenting that available through System.Reflection. +/// [] type UnionCaseInfo = /// The name of the case. @@ -49,41 +51,51 @@ type FSharpValue = /// Reads a field from a record value. /// - /// Assumes the given input is a record value. If not, ArgumentException is raised. + /// Assumes the given input is a record value. If not, is raised. + /// /// The record object. /// The PropertyInfo describing the field to read. - /// Thrown when the input type is not a record type. + /// + /// Thrown when the input is not a record value. /// The field from the record. static member GetRecordField: record:obj * info:PropertyInfo -> obj /// Precompute a function for reading a particular field from a record. /// Assumes the given type is a RecordType with a field of the given name. - /// If not, ArgumentException is raised during pre-computation. + /// If not, is raised during pre-computation. /// /// Using the computed function will typically be faster than executing a corresponding call to Value.GetInfo /// because the path executed by the computed function is optimized given the knowledge that it will be /// used to read values of the given type. + /// /// The PropertyInfo of the field to read. + /// /// Thrown when the input type is not a record type. + /// /// A function to read the specified field from the record. static member PreComputeRecordFieldReader : info:PropertyInfo -> (obj -> obj) /// Creates an instance of a record type. /// /// Assumes the given input is a record type. + /// /// The type of record to make. /// The array of values to initialize the record. /// Optional binding flags for the record. + /// /// Thrown when the input type is not a record type. + /// /// The created record. static member MakeRecord: recordType:Type * values:obj [] * ?bindingFlags:BindingFlags -> obj /// Reads all the fields from a record value. /// - /// Assumes the given input is a record value. If not, ArgumentException is raised. + /// Assumes the given input is a record value. If not, is raised. /// The record object. /// Optional binding flags for the record. + /// /// Thrown when the input type is not a record type. + /// /// The array of fields from the record. static member GetRecordFields: record:obj * ?bindingFlags:BindingFlags -> obj[] @@ -92,23 +104,30 @@ type FSharpValue = /// this type. /// /// Assumes the given type is a RecordType. - /// If not, ArgumentException is raised during pre-computation. + /// If not, is raised during pre-computation. /// /// Using the computed function will typically be faster than executing a corresponding call to Value.GetInfo /// because the path executed by the computed function is optimized given the knowledge that it will be /// used to read values of the given type. + /// /// The type of record to read. /// Optional binding flags. + /// /// Thrown when the input type is not a record type. + /// /// An optimized reader for the given record type. static member PreComputeRecordReader : recordType:Type * ?bindingFlags:BindingFlags -> (obj -> obj[]) + /// Precompute a function for constructing a record value. /// /// Assumes the given type is a RecordType. - /// If not, ArgumentException is raised during pre-computation. + /// If not, is raised during pre-computation. + /// /// The type of record to construct. /// Optional binding flags. + /// /// Thrown when the input type is not a record type. + /// /// A function to construct records of the given type. static member PreComputeRecordConstructor : recordType:Type * ?bindingFlags:BindingFlags -> (obj[] -> obj) @@ -131,7 +150,7 @@ type FSharpValue = /// Identify the union case and its fields for an object /// - /// Assumes the given input is a union case value. If not, ArgumentException is raised. + /// Assumes the given input is a union case value. If not, is raised. /// /// If the type is not given, then the runtime type of the input object is used to identify the /// relevant union type. The type should always be given if the input object may be null. For example, @@ -139,16 +158,19 @@ type FSharpValue = /// The input union case. /// The union type containing the value. /// Optional binding flags. + /// /// Thrown when the input type is not a union case value. + /// /// The description of the union case and its fields. static member GetUnionFields: value:obj * unionType:Type * ?bindingFlags:BindingFlags -> UnionCaseInfo * obj [] /// Assumes the given type is a union type. - /// If not, ArgumentException is raised during pre-computation. + /// If not, is raised during pre-computation. /// /// Using the computed function is more efficient than calling GetUnionCase /// because the path executed by the computed function is optimized given the knowledge that it will be /// used to read values of the given type. + /// /// The type of union to optimize reading. /// Optional binding flags. /// @@ -166,6 +188,7 @@ type FSharpValue = /// Precompute a function for reading all the fields for a particular discriminator case of a union type /// /// Using the computed function will typically be faster than executing a corresponding call to GetFields + /// /// The description of the union case to read. /// Optional binding flags. /// @@ -190,25 +213,32 @@ type FSharpValue = /// Reads all the fields from a value built using an instance of an F# exception declaration /// - /// Assumes the given input is an F# exception value. If not, ArgumentException is raised. + /// Assumes the given input is an F# exception value. If not, is raised. + /// /// The exception instance. /// Optional binding flags. + /// /// Thrown when the input type is not an F# exception. + /// /// The fields from the given exception. static member GetExceptionFields: exn:obj * ?bindingFlags:BindingFlags -> obj[] /// Creates an instance of a tuple type /// - /// Assumes at least one element is given. If not, ArgumentException is raised. + /// Assumes at least one element is given. If not, is raised. + /// /// The array of tuple fields. /// The tuple type to create. + /// /// Thrown if no elements are given. + /// /// An instance of the tuple type with the given elements. static member MakeTuple: tupleElements:obj[] * tupleType:Type -> obj /// Reads a field from a tuple value. /// - /// Assumes the given input is a tuple value. If not, ArgumentException is raised. + /// Assumes the given input is a tuple value. If not, is raised. + /// /// The input tuple. /// The index of the field to read. /// @@ -217,18 +247,24 @@ type FSharpValue = /// Reads all fields from a tuple. /// - /// Assumes the given input is a tuple value. If not, ArgumentException is raised. + /// Assumes the given input is a tuple value. If not, is raised. + /// /// The input tuple. + /// /// Thrown when the input is not a tuple value. + /// /// An array of the fields from the given tuple. static member GetTupleFields: tuple:obj -> obj [] /// Precompute a function for reading the values of a particular tuple type /// /// Assumes the given type is a TupleType. - /// If not, ArgumentException is raised during pre-computation. + /// If not, is raised during pre-computation. + /// /// The tuple type to read. + /// /// Thrown when the given type is not a tuple type. + /// /// A function to read values of the given tuple type. static member PreComputeTupleReader : tupleType:Type -> (obj -> obj[]) @@ -243,9 +279,12 @@ type FSharpValue = /// Precompute a function for reading the values of a particular tuple type /// /// Assumes the given type is a TupleType. - /// If not, ArgumentException is raised during pre-computation. + /// If not, is raised during pre-computation. + /// /// The type of tuple to read. + /// /// Thrown when the given type is not a tuple type. + /// /// A function to read a particular tuple type. static member PreComputeTupleConstructor : tupleType:Type -> (obj[] -> obj) @@ -258,6 +297,7 @@ type FSharpValue = /// object of this type must be created and passed as the last argument /// to the ConstructorInfo. A recursive call to PreComputeTupleConstructorInfo /// can be used to determine the constructor for that the suffix type. + /// /// The input tuple type. /// /// The description of the tuple type constructor and an optional extra type @@ -278,7 +318,8 @@ type FSharpType = /// Reads all the fields from a record value, in declaration order /// - /// Assumes the given input is a record value. If not, ArgumentException is raised. + /// Assumes the given input is a record value. If not, is raised. + /// /// The input record type. /// Optional binding flags. /// @@ -287,10 +328,13 @@ type FSharpType = /// Gets the cases of a union type. /// - /// Assumes the given type is a union type. If not, ArgumentException is raised during pre-computation. + /// Assumes the given type is a union type. If not, is raised during pre-computation. + /// /// The input union type. /// Optional binding flags. + /// /// Thrown when the input type is not a union type. + /// /// An array of descriptions of the cases of the given union type. static member GetUnionCases: unionType:Type * ?bindingFlags:BindingFlags -> UnionCaseInfo[] @@ -313,10 +357,13 @@ type FSharpType = /// Reads all the fields from an F# exception declaration, in declaration order /// - /// Assumes exceptionType is an exception representation type. If not, ArgumentException is raised. + /// Assumes exceptionType is an exception representation type. If not, is raised. + /// /// The exception type to read. /// Optional binding flags. + /// /// Thrown if the given type is not an exception. + /// /// An array containing the PropertyInfo of each field in the exception. static member GetExceptionFields: exceptionType:Type * ?bindingFlags:BindingFlags -> PropertyInfo[] @@ -396,23 +443,30 @@ type FSharpType = static member GetFunctionElements : functionType:Type -> Type * Type [] +/// Defines further accessing additional information about F# types and F# values at runtime. module FSharpReflectionExtensions = type FSharpValue with /// Creates an instance of a record type. /// /// Assumes the given input is a record type. + /// /// The type of record to make. /// The array of values to initialize the record. /// Optional flags that denotes accessibility of the private representation. + /// /// Thrown when the input type is not a record type. + /// /// The created record. static member MakeRecord: recordType:Type * values:obj [] * ?allowAccessToPrivateRepresentation : bool -> obj /// Reads all the fields from a record value. /// - /// Assumes the given input is a record value. If not, ArgumentException is raised. + /// Assumes the given input is a record value. If not, is raised. + /// /// The record object. /// Optional flag that denotes accessibility of the private representation. + /// /// Thrown when the input type is not a record type. + /// /// The array of fields from the record. static member GetRecordFields: record:obj * ?allowAccessToPrivateRepresentation : bool -> obj[] @@ -421,23 +475,29 @@ module FSharpReflectionExtensions = /// this type. /// /// Assumes the given type is a RecordType. - /// If not, ArgumentException is raised during pre-computation. + /// If not, is raised during pre-computation. /// /// Using the computed function will typically be faster than executing a corresponding call to Value.GetInfo /// because the path executed by the computed function is optimized given the knowledge that it will be /// used to read values of the given type. + /// /// The type of record to read. /// Optional flag that denotes accessibility of the private representation. + /// /// Thrown when the input type is not a record type. + /// /// An optimized reader for the given record type. static member PreComputeRecordReader : recordType:Type * ?allowAccessToPrivateRepresentation : bool -> (obj -> obj[]) /// Precompute a function for constructing a record value. /// /// Assumes the given type is a RecordType. - /// If not, ArgumentException is raised during pre-computation. + /// If not, is raised during pre-computation. + /// /// The type of record to construct. /// Optional flag that denotes accessibility of the private representation. + /// /// Thrown when the input type is not a record type. + /// /// A function to construct records of the given type. static member PreComputeRecordConstructor : recordType:Type * ?allowAccessToPrivateRepresentation : bool -> (obj[] -> obj) @@ -445,6 +505,7 @@ module FSharpReflectionExtensions = /// /// The record type. /// Optional flag that denotes accessibility of the private representation. + /// /// A ConstructorInfo for the given record type. static member PreComputeRecordConstructorInfo: recordType:Type * ?allowAccessToPrivateRepresentation : bool-> ConstructorInfo @@ -453,29 +514,34 @@ module FSharpReflectionExtensions = /// The description of the union case to create. /// The array of arguments to construct the given case. /// Optional flag that denotes accessibility of the private representation. + /// /// The constructed union case. static member MakeUnion: unionCase:UnionCaseInfo * args:obj [] * ?allowAccessToPrivateRepresentation : bool-> obj /// Identify the union case and its fields for an object /// - /// Assumes the given input is a union case value. If not, ArgumentException is raised. + /// Assumes the given input is a union case value. If not, is raised. /// /// If the type is not given, then the runtime type of the input object is used to identify the /// relevant union type. The type should always be given if the input object may be null. For example, /// option values may be represented using the 'null'. + /// /// The input union case. /// The union type containing the value. /// Optional flag that denotes accessibility of the private representation. + /// /// Thrown when the input type is not a union case value. + /// /// The description of the union case and its fields. static member GetUnionFields: value:obj * unionType:Type * ?allowAccessToPrivateRepresentation : bool -> UnionCaseInfo * obj [] /// Assumes the given type is a union type. - /// If not, ArgumentException is raised during pre-computation. + /// If not, is raised during pre-computation. /// /// Using the computed function is more efficient than calling GetUnionCase /// because the path executed by the computed function is optimized given the knowledge that it will be /// used to read values of the given type. + /// /// The type of union to optimize reading. /// Optional flag that denotes accessibility of the private representation. /// @@ -486,14 +552,17 @@ module FSharpReflectionExtensions = /// /// The type of union to read. /// Optional flag that denotes accessibility of the private representation. + /// /// The description of the union case reader. static member PreComputeUnionTagMemberInfo : unionType:Type * ?allowAccessToPrivateRepresentation : bool -> MemberInfo /// Precompute a function for reading all the fields for a particular discriminator case of a union type /// /// Using the computed function will typically be faster than executing a corresponding call to GetFields + /// /// The description of the union case to read. /// Optional flag that denotes accessibility of the private representation. + /// /// A function to for reading the fields of the given union case. static member PreComputeUnionReader : unionCase:UnionCaseInfo * ?allowAccessToPrivateRepresentation : bool -> (obj -> obj[]) @@ -501,6 +570,7 @@ module FSharpReflectionExtensions = /// /// The description of the union case. /// Optional flag that denotes accessibility of the private representation. + /// /// A function for constructing values of the given union case. static member PreComputeUnionConstructor : unionCase:UnionCaseInfo * ?allowAccessToPrivateRepresentation : bool -> (obj[] -> obj) @@ -508,33 +578,42 @@ module FSharpReflectionExtensions = /// /// The description of the union case. /// Optional flag that denotes accessibility of the private representation. + /// /// The description of the constructor of the given union case. static member PreComputeUnionConstructorInfo: unionCase:UnionCaseInfo * ?allowAccessToPrivateRepresentation : bool -> MethodInfo /// Reads all the fields from a value built using an instance of an F# exception declaration /// - /// Assumes the given input is an F# exception value. If not, ArgumentException is raised. + /// Assumes the given input is an F# exception value. If not, is raised. + /// /// The exception instance. /// Optional flag that denotes accessibility of the private representation. + /// /// Thrown when the input type is not an F# exception. + /// /// The fields from the given exception. static member GetExceptionFields: exn:obj * ?allowAccessToPrivateRepresentation : bool -> obj[] type FSharpType with /// Reads all the fields from a record value, in declaration order /// - /// Assumes the given input is a record value. If not, ArgumentException is raised. + /// Assumes the given input is a record value. If not, is raised. + /// /// The input record type. /// Optional flag that denotes accessibility of the private representation. + /// /// An array of descriptions of the properties of the record type. static member GetRecordFields: recordType:Type * ?allowAccessToPrivateRepresentation : bool -> PropertyInfo[] /// Gets the cases of a union type. /// - /// Assumes the given type is a union type. If not, ArgumentException is raised during pre-computation. + /// Assumes the given type is a union type. If not, is raised during pre-computation. + /// /// The input union type. /// Optional flag that denotes accessibility of the private representation. + /// /// Thrown when the input type is not a union type. + /// /// An array of descriptions of the cases of the given union type. static member GetUnionCases: unionType:Type * ?allowAccessToPrivateRepresentation : bool -> UnionCaseInfo[] @@ -543,6 +622,7 @@ module FSharpReflectionExtensions = /// /// The type to check. /// Optional flag that denotes accessibility of the private representation. + /// /// True if the type check succeeds. static member IsRecord: typ:Type * ?allowAccessToPrivateRepresentation : bool -> bool @@ -550,22 +630,27 @@ module FSharpReflectionExtensions = /// /// The type to check. /// Optional flag that denotes accessibility of the private representation. + /// /// True if the type check succeeds. static member IsUnion: typ:Type * ?allowAccessToPrivateRepresentation : bool -> bool /// Reads all the fields from an F# exception declaration, in declaration order /// - /// Assumes exceptionType is an exception representation type. If not, ArgumentException is raised. + /// Assumes exceptionType is an exception representation type. If not, is raised. + /// /// The exception type to read. /// Optional flag that denotes accessibility of the private representation. + /// /// Thrown if the given type is not an exception. + /// /// An array containing the PropertyInfo of each field in the exception. static member GetExceptionFields: exceptionType:Type * ?allowAccessToPrivateRepresentation : bool -> PropertyInfo[] - /// Returns true if the typ is a representation of an F# exception declaration + /// Returns true if the exceptionType is a representation of an F# exception declaration /// /// The type to check. /// Optional flag that denotes accessibility of the private representation. + /// /// True if the type check is an F# exception. static member IsExceptionRepresentation: exceptionType:Type * ?allowAccessToPrivateRepresentation : bool -> bool diff --git a/src/fsharp/FSharp.Core/result.fsi b/src/fsharp/FSharp.Core/result.fsi index 2cb80c5b0f5..52e23db5d13 100644 --- a/src/fsharp/FSharp.Core/result.fsi +++ b/src/fsharp/FSharp.Core/result.fsi @@ -5,7 +5,9 @@ namespace Microsoft.FSharp.Core open Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicOperators [] - /// Basic operations for values of type . + /// Contains operations for working with values of type . + /// + /// Choices and Results module Result = /// map f inp evaluates to match inp with Error e -> Error e | Ok x -> Ok (f x). diff --git a/src/fsharp/FSharp.Core/seq.fsi b/src/fsharp/FSharp.Core/seq.fsi index f128def6635..d8f983de4b4 100644 --- a/src/fsharp/FSharp.Core/seq.fsi +++ b/src/fsharp/FSharp.Core/seq.fsi @@ -9,7 +9,7 @@ namespace Microsoft.FSharp.Collections open Microsoft.FSharp.Collections - /// Basic operations on values of type . + /// Contains operations for working with values of type . [] [] module Seq = @@ -91,7 +91,7 @@ namespace Microsoft.FSharp.Collections /// Enumeration of the result sequence is thread safe in the sense that multiple independent IEnumerator /// values may be used simultaneously from different threads (accesses to /// the internal lookaside table are thread safe). Each individual IEnumerator - /// is not typically thread safe and should not be accessed concurrently. + /// is not typically thread safe and should not be accessed concurrently. /// /// Once enumeration of the input sequence has started, /// it's enumerator will be kept live by this object until the enumeration has completed. @@ -1099,7 +1099,7 @@ namespace Microsoft.FSharp.Collections val sortWith : comparer:('T -> 'T -> int) -> source:seq<'T> -> seq<'T> /// Applies a key-generating function to each element of a sequence and yield a sequence ordered - /// by keys. The keys are compared using generic comparison as implemented by Operators.compare. + /// by keys. The keys are compared using generic comparison as implemented by . /// /// This function returns a sequence that digests the whole initial sequence as soon as /// that sequence is iterated. As a result this function should not be used with @@ -1135,7 +1135,7 @@ namespace Microsoft.FSharp.Collections val inline sortDescending : source:seq<'T> -> seq<'T> when 'T : comparison /// Applies a key-generating function to each element of a sequence and yield a sequence ordered - /// descending by keys. The keys are compared using generic comparison as implemented by Operators.compare. + /// descending by keys. The keys are compared using generic comparison as implemented by . /// /// This function returns a sequence that digests the whole initial sequence as soon as /// that sequence is iterated. As a result this function should not be used with diff --git a/src/fsharp/FSharp.Core/set.fsi b/src/fsharp/FSharp.Core/set.fsi index 12261913cf1..53f1d725abb 100644 --- a/src/fsharp/FSharp.Core/set.fsi +++ b/src/fsharp/FSharp.Core/set.fsi @@ -126,7 +126,7 @@ namespace Microsoft.FSharp.Collections [] [] - /// Basic operations on values of type . + /// Contains operations for working with values of type . module Set = /// The empty set for the type 'T. diff --git a/src/fsharp/FSharp.Core/string.fsi b/src/fsharp/FSharp.Core/string.fsi index 78c519aa1d5..cca1054f58a 100644 --- a/src/fsharp/FSharp.Core/string.fsi +++ b/src/fsharp/FSharp.Core/string.fsi @@ -10,7 +10,10 @@ namespace Microsoft.FSharp.Core /// Functional programming operators for string processing. Further string operations /// are available via the member functions on strings and other functionality in /// System.String - /// and System.Text.RegularExpressions types. + /// and System.Text.RegularExpressions types. + /// + /// + /// Strings and Text [] [] module String =