FnSharp.Bcl.Core

Array

This module contains functions pertaining to arrays. This module requires qualified access.
contains<'a> : 'a → 'a[] → bool
Test if any element in the array matches the supplied value.
groupBy2<'t> : ('t → 't[] → GroupingAction) → 't[] → 't[][]
Group the elements in an array by a supplied function which returns the desired grouping action.
groupBy<'a> : ('a → GroupingAction) → 'a[] → 'a[][]
Group the elements in an array by a supplied function which returns the desired grouping action.
nth<'t> : int → 't[] → 't
Return the nth element of an array.
nthFromEnd<'t> : int → 't[] → 't
Return the nth element from the end of an array.
nthFromEndOrDefault<'t> : int → 't[] → 't
Return the nth element from the end of an array, if it exists, or the generic default.
nthFromEndOrDefaultTo<'t> : int → 't → 't[] → 't
Return the nth element from the end of an array, if it exists, or the supplied default value.
nthFromEndOrNone<'t> : int → 't[] → option<'t>
Return the nth element from the end of an array as an option, if it exists, or none.
nthOrDefault<'t> : int → 't[] → 't
Return the nth element of an array, if it exists, or the generic default.
nthOrDefaultTo<'t> : int → 't → 't[] → 't
Return the nth element of an array, if it exists, or the supplied default value.
nthOrNone<'t> : int → 't[] → option<'t>
Return the nth element of an array as an option, if it exists, or none.
skip<'t> : int → 't[] → 't[]
Skip n elements of an array, and return the rest.
skipLast<'t> : int → 't[] → 't[]
Skip n elements at the end of an array, and return the rest.
take<'t> : int → 't[] → 't[]
Take n elements from the beginning of an array, skip the rest.
takeLast<'t> : int → 't[] → 't[]
Take the last n elements from the end of an array, skip the rest.

Async

This module contains Async extensions and functionality.
start : CancellationToken → Async<unit> → unit
Start the asynchronous computation in the thread pool. Do not await its result.

Atom

This module contains functions pertaining to mutable atom cells.
(!) : Atom<'a> → 'a
Return the currently referenced type.
atom<'a> : 'a → Atom<'a>
Create a new mutable atom cell.
switch<'a> : Atom<'a> → ('a → 'a) → unit
Switch references atomically.
|AtomCell|<'T> : Atom<'T> → 'T
An active pattern which when matched returns the atom cell contents.

Atom<'T>

Mutable atom cell.
new : 'T → _
this.Switch : ('T → 'T) → unit
Switch references atomically.
this.Value : 'T
Return the currently referenced type.

BackingField

This module contains functions pertaining to backing fields. This module requires qualified access.
create<'T> : cell<'T>
Creates a backing field for a property.
createWrite<'T> : int → cell<'T>
Creates a backing field for a property, which can only be n amount of times.
createWriteOnce<'T> : cell<'T>
Creates a backing field for a property, which can only be written to once.
defaultTo<'a> : 'a → cell<'a> → cell<'a>
Default to a supplied value when the backing field has not been set.
get<'a> : cell<'a> → 'a
Return the backing field value.
lock<'a> : cell<'a> → unit
Lock the backing field so that it can not be written.
set<'a> : 'a → cell<'a> → unit
Alter the backing field value.

cell<'T>

Represents the backing field of a property.

Disposable

This module contains functions pertaining to disposing of resources. This module requires qualified access.
Empty : IDisposable
Create a new empty disposable instance.
get_Empty : IDisposable
init : (unit → unit) → IDisposable
Initialize a new disposable instance, which when disposed calls a function.
ofDisposables<'a> : seq<'a> → IDisposable
Create a new disposable instance, which wraps multiple disposable instances.

DisposablePervasives

This module contains functions pertaining to disposing of resources. The functions are pervasive and the module doesn't need to be opened explicitly.
dispose<'a> : 'a → unit
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
disposeAll<'a> : seq<'a> → unit
Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources on multiple disposable instances.

GroupingPervasives

This module contains types pertaining to grouping on various collection types. The types are pervasive and the module doesn't need to be opened explicitly.

ContinueGroupItemAction

type ContinueGroupItemAction =
    | WithItem     
    | WithoutItem     
            

GroupingAction

type GroupingAction =
    | YieldGroup of YieldGroupItemAction     
    | ContinueGroup of ContinueGroupItemAction    
            

YieldGroupItemAction

type YieldGroupItemAction =
    | GroupItem    
    | AppendItem    
    | DiscardItem    
    | SeperateItem    
            

LazyFuture

This module contains functions pertaining to lazy futures. This module requires qualified access.
create<'a> : bool → (unit → 'a) → Lazy<'a>
Creates a lazy future from a supplied function.
ofAsync<'a> : bool → Async<'a> → Lazy<'a>
Creates a lazy future from an asynchronous computation.

List

This module contains functions pertaining to lists. This module requires qualified access.
groupBy2<'t> : ('t → 't[] → GroupingAction) → list<'t> → list<list<'t>>
Group the items in a list by a supplied function which returns the desired grouping action.
groupBy<'a> : ('a → GroupingAction) → list<'a> → list<list<'a>>
Group the items in a list by a supplied function which returns the desired grouping action.

Memoization

This module contains functions pertaining to memoization.
create<'a,'b> : ('a → 'b) → 'a → 'b
Memoize a function.

Option

This module contains functions pertaining to the option type. This module requires qualified access.
defaultTo<'a> : 'a → option<'a> → 'a
Default to a supplied value when the option is none.
defaultToF<'a> : (unit → 'a) → option<'a> → 'a
Default to a value returned by a function when the option is none.
mapOrDefault<'a,'b> : ('a → 'b) → option<'a> → 'b
Map the option value, or default to the generic default when the option is none.
mapOrDefaultTo<'a,'b> : ('a → 'b) → 'b → option<'a> → 'b
Map the option value, or default to a supplied value when the option is none.
mapOrDefaultToF<'a,'b> : ('a → 'b) → (unit → 'b) → option<'a> → 'b
Map the option value, or default to a value returned by a function when the option is none
ofBool2<'a> : bool × 'a → option<'a>
Map a boolean value to an option with a supplied value.
ofBool<'a> : 'a → bool → option<'a>
Map a boolean value to an option with a supplied value.
ofBoolF2<'a> : (unit → 'a) → ('a → unit) → bool → option<'a>
Map a boolean value to an option with a supplied value returned by a function.
ofBoolF<'a> : (unit → 'a) → bool → option<'a>
Map a boolean value to an option with a supplied value returned by a function.
ofBoolInv2<'a> : bool × 'a → option<'a>
Map an inverted boolean value to an option with a supplied value.
ofBoolInv<'a> : 'a → bool → option<'a>
Map an inverted boolean value to an option with a supplied value.
ofBoolInvF2<'a> : (unit → 'a) → ('a → unit) → bool → option<'a>
Map an inverted boolean value to an option with a supplied value returned by a function.
ofBoolInvF<'a> : (unit → 'a) → bool → option<'a>
Map an inverted boolean value to an option with a supplied value returned by a function.
ofObject<'a> : 'a → option<'a>
Create an option from a class instance, null is mapped to None.

ParsePervasives

This module contains functions pertaining to parsing text. The functions are pervasive and the module doesn't need to be opened explicitly.
Boolean.tryParse.Static : string → option<bool>
DateTime.tryParse.Static : string → option<DateTime>
Decimal.tryParse.Static : string → option<decimal>
Double.tryParse.Static : string → option<double>
Int32.tryParse.Static : string → option<int>
Int64.tryParse.Static : string → option<int64>
Single.tryParse.Static : string → option<Single>
String.tryParse.Static<'a,'b,'c,'d,'t> : PrintfFormat<'a,'b,'c,'d,'t> → string → option<'t>
UInt32.tryParse.Static : string → option<uint32>
UInt64.tryParse.Static : string → option<uint64>
|Bool|_| : string → option<bool>
An active pattern which matches the string representations of System.Boolean.
|Date|_| : string → option<DateTime>
An active pattern which matches the string representations of System.DateTime.
|Decimal|_| : string → option<decimal>
An active pattern which matches the string representations of System.Decimal.
|Double|_| : string → option<double>
An active pattern which matches the string representations of System.Double.
|Float|_| : string → option<double>
An active pattern which matches the string representations of System.Double.
|Int64|_| : string → option<int64>
An active pattern which matches the string representations of System.Int64.
|Int|_| : string → option<int>
An active pattern which matches the string representations of System.Int32.
|Pattern|_|<'a,'b,'c,'d,'e> : PrintfFormat<'a,'b,'c,'d,'e> → string → option<'e>
An active pattern which matches a formatted string by means of a pattern.
|Single|_| : string → option<Single>
An active pattern which matches the string representations of System.Single.
|UInt64|_| : string → option<uint64>
An active pattern which matches the string representations of System.UInt64.
|UInt|_| : string → option<uint32>
An active pattern which matches the string representations of System.UInt32.

Pervasives

This module is not intended for direct use!

Prelude

curry<'a,'b,'c> : ('a × 'b → 'c) → 'a → 'b → 'c
flip<'a,'b,'c> : ('a → 'b → 'c) → 'b → 'a → 'c
swap<'a,'b> : 'a × 'b → 'b × 'a
uncurry<'a,'b,'c> : ('a → 'b → 'c) → 'a × 'b → 'c

Seq

This module contains functions pertaining to sequences. This module requires qualified access.
groupBy2<'t> : ('t → 't[] → GroupingAction) → seq<'t> → seq<seq<'t>>
Group the items in a list by a supplied function which returns the desired grouping action.
groupBy<'a> : ('a → GroupingAction) → seq<'a> → seq<seq<'a>>
Group the items in a list by a supplied function which returns the desired grouping action.
nthOrDefault<'t> : int → seq<'t> → 't
Return the nth item of a sequence, if it exists, or the generic default.
nthOrDefaultTo<'t> : int → 't → seq<'t> → 't
Return the nth item of a sequence, if it exists, or the supplied default value.
nthOrNone<'t> : int → seq<'t> → option<'t>
Return the nth item of a sequence as an option, if it exists, or none.

String

This module contains functions pertaining to strings. This module requires qualified access.
defaultTo : (string → bool) → string → string → string
Default to a supplied value when the supplied function returns true.
defaultToEmpty : string → string
Default to empty when the string is null.
defaultToNull : string → string → string
Default to a supplied value when the string is null.
fromCharArray : char[] → string
Create a string from an array of characters.
groupBy : (char → GroupingAction) → string → string[]
Group the characters in an string by a supplied function which returns the desired grouping action.
groupBy2 : (char → string → GroupingAction) → string → string[]
Group the characters in an string by a supplied function which returns the desired grouping action.
join : string → seq<string> → string
Concatenates all items in a string sequence, using the specified seperator between each item.
map<'a> : (string → 'a) → string → 'a
Map a string using the supplied mapping function.
mapChar : (char → char) → string → string
Map a strings characters using the supplied mapping function.
quote : string → string
Wrap the string in quotation marks.
skip : int → string → string
Skip n characters of a string, and return the rest.
skipLast : int → string → string
Skip n characters at the end of a string, and return the rest.
splitOnChar : list<char> → string → string[]
Returns a string array that contains the substrings in this instance that are delimited by the seperator characters.
splitOnString : list<string> → string → string[]
Returns a string array that contains the substrings in this instance that are delimited by the seperator strings.
take : int → string → string
Take n characters from the beginning of a string, skip the rest.
takeLast : int → string → string
Take the last n characters from the end of a string, skip the rest.
toCamelCase : string → string
Convert the string to camelcase.
toLower : string → string
Convert the string to lowercase.
toPascalCase : string → string
Convert the string to pascalcase.
toUpper : string → string
Convert the string to uppercase.
trimEnd : string → string
Removes all trailing occurrences of whitespace characters.
trimEnd2 : char[] → string → string
Removes all trailing occurrences of a supplied array of characters.
trimStart : string → string
Removes all leading occurrences of whitespace characters.
trimStart2 : char[] → string → string
Removes all leading occurrences of a supplied array of characters.

TracePervasives

This module contains functions pertaining to debug tracing. The functions are pervasive and the module doesn't need to be opened explicitly.
trace : string → unit
Writes a message to the debug trace.
tracef<'a> : PrintfFormat<'a,unit,string,unit> → 'a
Writes a formated message to the debug trace.
tracefn<'a> : PrintfFormat<'a,unit,string,unit> → 'a
Writes a formatted message to the debug trace followed by a line terminator.
tracen : string → unit
Writes a message to the debug trace followed by a line terminator.

Var

A Universal type in which any other type can be embedded and retrieved.
bind<'a> : ('a → (unit → unit) × (unit → unit)) × ((unit → unit) × (unit → unit) → option<'a>)
Bind a getter and setter function for embedded type access.

Last edited Mar 16, 2012 at 1:16 PM by huwman, version 7

Comments

No comments yet.