fsharppowerpack Wiki Rss Feed

New Comment on "FsYacc"

thewidi — Thu, 02 May 2013 06:39:35 GMT

Good day very nice site!! Guy .. Excellent .. Superb .. <a href="http://3s3n.com/">judi online</a> I will bookmark your website and take the feeds additionally? I'm satisfied to search out numerous useful information right here within the submit, we need work out more strategies on this regard, thanks for sharing. . . . . .

New Comment on "FsYacc"

thewidi — Thu, 02 May 2013 06:39:04 GMT

Good day very nice site!! Guy .. Excellent .. Superb .. "judi online":http://3s3n.com I will bookmark your website and take the feeds additionally? I'm satisfied to search out numerous useful information right here within the submit, we need work out more strategies on this regard, thanks for sharing. . . . . .

Updated Wiki: Home

dsyme — Sun, 17 Feb 2013 17:34:51 GMT

A collection of extra libraries and tools for the F# programming language. Also the staging point for the open source code drop(s) of the F# compiler and core library under the OSS approved Apache 2.0 license. The F# open source code is managed by the F# Software Foundation and incorporated into the fsharp repository on GitHub.

To get, learn, install or use F#, go to fsharp.org (for F# generally) or MSDN (for the Visual F# tools from Microsoft)

Get Using Nuget

Install-Package FsPowerPack.Community
Install-Package FsPowerPack.Core.Community
Install-Package FsPowerPack.Linq.Community
Install-Package FsPowerPack.Metadata.Community
Install-Package FsPowerPack.Parallel.Seq.Community

About This Library

The F# Power Pack is stable and useful, but will not evolve significantly from this point.
You may have to recompile the source code to use it, e.g. for .NET Portable components
Some of the components are being duplicated into FSharpx. FSharpx is an actively evolving collection of F# utilities developed by the F# community. You can read about an early version of FSharpx in this article.
Some of the math components of the F# Power Pack have recently been incorporated into the F# support in the Math.NET Numerics open source library.
Note: instead of using this library in binary form, you may want to copy out the relevant parts of the source code into your application or use alternatives. This can reduce the dependencies of your application or component. For example, if all you want is a simple quotation evaluator, than this F# snippet may be what you want.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)
F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library and you should ignore the ones defined in the power pack)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

FsLex and FsYacc
FsLex and FsYaxx are lexer and parser generation tools, along with MSBuild tasks to incorporate them in the build process.

See the Parsed Language Starter Template and the documentation for FsLex and FsYacc.

F# Documentation generator
FsHtmlDoc.exe can be used to generate HTML documentation from the XMLDoc comments in F# source files

F# 2.0 LINQ and Quotations to Expression Tree Bridge
Note: This assembly requires .NET 3.5
FSharp.PowerPack.Linq.dll connects F# 2.0 with some LINQ features introduced in .NET 3.5. In F# 3.0 some of this functionality has been moved to the core F# language and FSharp.Core.dll.

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

F# CodeDOM Implementation
FSharp.Compiler.CodeDom.dll contains implementations of System.CodeDom.Compiler.CodeDomProvider for F#. This allows F# to be used with CodeDom consumers, and most importantly to author ASP.NET pages code-behind classes in F#. Not all ASP.NET features work with this CodeDom, and you don't get strongly typed access to page elements, Some sample ASP.NET applications are in the test suite in the source tree.

F# Parallel LINQ Integration
Note: This assembly requires .NET 4.0
Note: This assembly is not installed into the GAC when you install the PowerPack MSI
FSharp.PowerPack.Parallel.dll provides F#-style API for parallel operations on sequences that are part in .NET 4.0 as System.Linq.ParallelEnumerable class. The API is akin to F# operations on sequences:

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Tue, 18 Dec 2012 03:26:57 GMT

Get Using Nuget

About This Library

The F# Power Pack is stable and useful, but will not evolve significantly from this point.
You may have to recompile the source code to use it, e.g. for .NET Portable components
Some of the components are being duplicated into FSharpx. FSharpx is an actively evolving collection of F# utilities developed by the F# community. You can read about an early version of FSharpx in this article.
Some of the math components of the F# Power Pack have recently been incorporated into the F# support in the Math.NET Numerics open source library.
Note: instead of using this library in binary form, you may want to copy out the relevant parts of the source code into your application. This can reduce the dependencies of your application or component.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)
F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library and you should ignore the ones defined in the power pack)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Mon, 17 Dec 2012 23:07:58 GMT

This is a collection of libraries and tools for use with the F# programming language. This is also the staging point for the open source code drop(s) of the F# compiler and core library under the OSS approved Apache 2.0 license. The F# open source code is managed by the F# Software Foundation and incorporated into the fsharp repository there.

If you're looking to get, learn, install or use F#, go to fsharp.org (for F# generally) or MSDN (for the Visual F# tools from Microsoft)

About This Library

The F# Power Pack is stable and useful, but will not evolve significantly from this point.
You may have to recompile the source code to use it on certain platforms, e.g. for .NET Portable components
Some of the components are being duplicated into FSharpx. FSharpx is an actively evolving collection of F# utilities developed by the F# community. You can read about an early version of FSharpx in this article.
Some of the math components of the F# Power Pack have recently been incorporated into the F# support in the Math.NET Numerics open source library.

Using This Library

Note: instead of using this library in binary form, you may want to copy out the relevant parts of the source code into your application. This can reduce the dependencies of your application or component.

Note: To use the libraries with Visual Studio 2010 and F# 2.0 and .NET 2.0-4.0, install the matching MSI or build the project binaries yourself from source code (the May2010 branch)

Note: To use the libraries with Visual Studio 2012 and F# 3.0 and .NET 4.0-4.5, install the matching MSI or build the project binaries yourself from source code (the Dec2012 branch)

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)
F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library and you should ignore the ones defined in the power pack)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Mon, 17 Dec 2012 17:37:56 GMT

This is a collection of libraries and tools for use with the F# programming language.

If you're looking to get, learn, install or use F#, go to fsharp.org (for F# generally) or MSDN (for the Visual F# tools from Microsoft)

About This Library

The F# Power Pack is stable and useful, but will not evolve significantly from this point.
Some of the components are being duplicated into FSharpx. FSharpx is an actively evolving collection of F# utilities developed by the F# community. You can read about an early version of FSharpx in this article.
Some of the math components of the F# Power Pack have recently been incorporated into the F# support in the Math.NET Numerics open source library.
This is also the staging point for the open source code drop(s) of the F# compiler and core library under the OSS approved Apache 2.0 license. The F# open source code is managed by the F# Software Foundation and incorporated into the fsharp repository there.

Using This Library

Note: To use the libraries with Visual Studio 2010 and F# 2.0, we now recommend you build the project binaries yourself from source code.

Note: To use the libraries with Visual Studio 2012 and F# 3.0, you must build them yourself from the "head" branch, or use the community NuGet package. To use FsLex and FsYacc with F# 3.0, you will need to edit your project file by hand to include the correct targets file.

Note: To use the libraries with .NET 2.0, .NET 3.5, then install the old binary release of compile from source from the May2010 directory.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)
F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library and you should ignore the ones defined in the power pack)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Mon, 10 Dec 2012 20:36:59 GMT

The F# Power Pack is stable and useful, but will not evolve significantly from this point.
Some of the components are being duplicated into FSharpx. FSharpx is an actively evolving collection of F# utilities developed by the F# community. You can read about an early version of FSharpx in this article.
Some of the math components of the F# Power Pack have recently been incorporated into the F# support in the Math.NET Numerics open source library.
This is also the staging point for the open source code drop(s) of the F# compiler and core library under the OSS approved Apache 2.0 license. The F# open source code is managed by the F# Software Foundation and incorporated into the fsharp repository there.

Using This Library

Note: To use the libraries with .NET 2.0, .NET 3.5, then install the old binary release of compile from source from the May2010 directory.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)
F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library and you should ignore the ones defined in the power pack)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Mon, 10 Dec 2012 20:36:07 GMT

This is a collection of libraries and tools for use with the F# programming language.

If you're looking to get, learn, install or use F#, go to fsharp.org (for F# generally) or fsharp.net (for the Visual F# tools from Microsoft)

About This Library

The F# Power Pack is stable and useful, but will not evolve significantly from this point.
Some of the components are being duplicated into FSharpx. FSharpx is an actively evolving collection of F# utilities developed by the F# community. You can read about an early version of FSharpx in this article.
Some of the math components of the F# Power Pack have recently been incorporated into the F# support in the Math.NET Numerics open source library.
This is also the staging point for the open source code drop(s) of the F# compiler and core library under the OSS approved Apache 2.0 license. The F# open source code is managed by the F# Software Foundation and incorporated into the fsharp repository there.

Using This Library

Note: To use the libraries with .NET 2.0, .NET 3.5, then install the old binary release of compile from source from the May2010 directory.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)
F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library and you should ignore the ones defined in the power pack)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Mon, 10 Dec 2012 20:35:51 GMT

This is a collection of libraries and tools for use with the F# programming language.

If you're looking to get, learn, install or use F#, go to fsharp.org (for F# generally) or fsharp.net (for the Visual F# tools from Microsoft)

About This Library

The F# Power Pack is stable and useful, but will not evolve significantly from this point.
Some of the components are being duplicated into FSharpx. FSharpx is an actively evolving collection of F# utilities developed by the F# community. You can read about an early version of FSharpx in this article.
Some of the math components of the F# Power Pack have recently been incorporated into the F# support in the Math.NET Numerics open source library.
This is also the staging point for the open source code drop(s) of the F# compiler and core library under the OSS approved Apache 2.0 license. The F# open source code is managed by the F# Software Foundation and incorporated into the fsharp repository there.

Using This Library

Note: To use the libraries with .NET 2.0, .NET 3.5, then install the old binary release of compile from source from the May2010 directory.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)
F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library and you should ignore the ones defined in the power pack)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Mon, 10 Dec 2012 20:35:38 GMT

This is a collection of libraries and tools for use with the F# programming language.

If you're looking to get, learn, install or use F#, go to fsharp.org (for F# generally) or fsharp.net (for the Visual F# tools from Microsoft)

About This Library

The F# Power Pack is stable and useful, but will not evolve significantly from this point.
Some of the components are being duplicated into FSharpx. FSharpx is an actively evolving collection of F# utilities developed by the F# community. You can read about an early version of FSharpx in this article.
Some of the math components of the F# Power Pack have recently been incorporated into the F# support in the Math.NET Numerics open source library.
This is also the staging point for the open source code drop(s) of the F# compiler and core library under the OSS approved Apache 2.0 license. The F# open source code is managed by the F# Software Foundation and incorporated into the fsharp repository there.

Using This Library

Note: To use the libraries with .NET 2.0, .NET 3.5, then install the old binary release of compile from source from the May2010 directory.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)
F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library and you should ignore the ones defined in the power pack)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Mon, 10 Dec 2012 20:35:16 GMT

This is a collection of libraries and tools for use with the F# programming language.

If you're looking to get, learn, install or use F#, go to fsharp.org (for F# generally) or fsharp.net (for the Visual F# tools from Microsoft)

About This Library

The F# Power Pack is stable and useful, but will not evolve significantly from this point.
Some of the components are being duplicated into FSharpx. FSharpx is an actively evolving collection of F# utilities developed by the F# community. You can read about an early version of FSharpx in this article.
Some of the math components of the F# Power Pack have recently been incorporated into the F# support in the Math.NET Numerics open source library.
This is also the staging point for the open source code drop(s) of the F# compiler and core library under the OSS approved Apache 2.0 license. The F# open source code is managed by the F# Software Foundation and incorporated into the fsharp repository there.

Using This Library

Note: To use the libraries with .NET 2.0, .NET 3.5, then install the old binary release of compile from source from the May2010 directory.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)
F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library and you should ignore the ones defined in the power pack)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Wed, 10 Oct 2012 16:59:06 GMT

This is a collection of libraries and tools for use with the F# programming language. It is also the staging point for the open source code drop(s) of the F# compiler and core library under the OSS approved Apache 2.0 license.

If you're looking to get, learn, install or use F#, go to www.fsharp.net.
An actively maintained collection of F# utilities is FSharpx., you can read more about that in this article.
This site does not include binary builds of the F# compiler.
The F# open source code is managed byhe F# community on GitHub and incorporated into the fsharp repository there.

Note: To use the libraries with .NET 2.0, .NET 3.5, then install the old binary release of compile from source from the May2010 directory.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)
F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library and you should ignore the ones defined in the power pack)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Tue, 25 Sep 2012 03:21:57 GMT

If you're looking to get, learn, install or use F#, go to www.fsharp.net.
A more actively maintained collection of F# utilities is FSharpx., you can read more about that in this article.
This site does not include binary builds of the F# compiler. The F# open source code drops are picked up by the F# community on GitHub and incorporated into the fsharp repository there.

Note: To use the libraries with .NET 2.0, .NET 3.5, then install the old binary release of compile from source from the May2010 directory.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)
F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library and you should ignore the ones defined in the power pack)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Tue, 25 Sep 2012 03:15:34 GMT

This is a small collection of libraries and tools for use with the F# programming language. It also acts as a staging point for the open source code drop(s) of the F# compiler and core library under the OSS approved Apache 2.0 license.

If you're looking to get, learn, install or use F#, go to www.fsharp.net.

This site does not include binary builds of the F# compiler. The F# open source code drops are picked up by the F# community on GitHub and incorporated into the fsharp repository there.

If you want to use the libraries with Visual Studio 2012 and F# 3.0, you must build them yourself from the "head" branch, or use the community NuGet package. To use FsLex and FsYacc with F# 3.0, you will need to edit your project file by hand to include the correct targets file. If you want to use the libraries with F# 2.0, then install the old binary release of compile from source from the May2010 directory.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)

let v  = vector [1.0;1.0;1.0] + vector [2.0;2.0;2.0] // (3.0; 3.0; 3.0)
let c = complex 0.0 1.0 * complex 0.0 1.0 // -1r+0i
let r = (1N/2N) * (1N/3N) // 1/6

F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Tue, 25 Sep 2012 03:04:18 GMT

If you're looking to get, learn, install or use F#, go to www.fsharp.net.

This site does not include binary builds of the F# compiler. The F# open source code drops are picked up by the F# community on GitHub and incorporated into the fsharp repository there.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)

let v  = vector [1.0;1.0;1.0] + vector [2.0;2.0;2.0] // (3.0; 3.0; 3.0)
let c = complex 0.0 1.0 * complex 0.0 1.0 // -1r+0i
let r = (1N/2N) * (1N/3N) // 1/6

F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Mon, 23 Jul 2012 15:15:33 GMT

If you're looking to get, learn, install or use F#, go to www.fsharp.net.

This site does not include binary builds of the F# compiler. The F# open source code drops are picked up by the F# community on GitHub and incorporated into the fsharp repository there.

FSharp.PowerPack.dll
This assembly provides assorted utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a "ResizeArray" functional operations for the standard .NET System.Collections.Generic.List<_> and more
Some Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)

let v  = vector [1.0;1.0;1.0] + vector [2.0;2.0;2.0] // (3.0; 3.0; 3.0)
let c = complex 0.0 1.0 * complex 0.0 1.0 // -1r+0i
let r = (1N/2N) * (1N/3N) // 1/6

F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Mon, 23 Jul 2012 14:35:12 GMT

If you're looking to get, learn, install or use F#, go to www.fsharp.net.

This site does not include binary builds of the F# compiler. The F# open source code drops are picked up by the F# community on GitHub and incorporated into the fsharp repository there.

FSharp.PowerPack.dll
This assembly provides assorted useful utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a functional interface to standard .NET System.Collections.Generic.List<_> and more
Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)

let v  = vector [1.0;1.0;1.0] + vector [2.0;2.0;2.0] // (3.0; 3.0; 3.0)
let c = complex 0.0 1.0 * complex 0.0 1.0 // -1r+0i
let r = (1N/2N) * (1N/3N) // 1/6

F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Mon, 23 Jul 2012 14:34:52 GMT

If you're looking to get, learn, install or use F#, go to www.fsharp.net.

This site does not include binary builds of the F# compiler. The F# open source code drops are picked up by the F# community on GitHub and incorporated into the fsharp repository there.

F# Extras Bits and Pieces

FSharp.PowerPack.dll
This assembly provides assorted useful utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a functional interface to standard .NET System.Collections.Generic.List<_> and more
Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)

let v  = vector [1.0;1.0;1.0] + vector [2.0;2.0;2.0] // (3.0; 3.0; 3.0)
let c = complex 0.0 1.0 * complex 0.0 1.0 // -1r+0i
let r = (1N/2N) * (1N/3N) // 1/6

F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Mon, 23 Jul 2012 14:01:49 GMT

F# Extras (aka F# PowerPack) is a small collection of libraries and tools for use with the F# programming language. It also acts as a staging point for the open source code drop(s) of the F# compiler and core library under the OSS approved Apache 2.0 license.

If you're looking to get, learn, install or use F#, go to www.fsharp.net.

This site does not include binary builds of the F# compiler. The F# open source code drops are picked up by the F# community on GitHub and incorporated into the fsharp repository there.

F# Extras Bits and Pieces

FSharp.PowerPack.dll
This assembly provides assorted useful utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a functional interface to standard .NET System.Collections.Generic.List<_> and more
Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)

let v  = vector [1.0;1.0;1.0] + vector [2.0;2.0;2.0] // (3.0; 3.0; 3.0)
let c = complex 0.0 1.0 * complex 0.0 1.0 // -1r+0i
let r = (1N/2N) * (1N/3N) // 1/6

F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#

Updated Wiki: Home

dsyme — Mon, 23 Jul 2012 14:01:14 GMT

If you're looking to get, learn, install or use F#, go to www.fsharp.net.

This site does not include binary builds of the F# compiler. The F# open source code drops are picked up by the F# community on GitHub and incorporated into the fsharp repository there.

F# Extras Bits and Pieces

FSharp.PowerPack.dll
This assembly provides assorted useful utilities:

Additional immutable datastructures, including HashMultiMap, tagged immutable sets and maps, extension methods giving a functional interface to standard .NET System.Collections.Generic.List<_> and more
Math data types and operations over them, including Matrix, Vector, Complex and BigRational (note: also consider using Math.NET Numerics as your open source math library)

let v  = vector [1.0;1.0;1.0] + vector [2.0;2.0;2.0] // (3.0; 3.0; 3.0)
let c = complex 0.0 1.0 * complex 0.0 1.0 // -1r+0i
let r = (1N/2N) * (1N/3N) // 1/6

F# 2.0 definitions for SI units of measure, for use with F# units of measure language constructs. (In F# 3.0 these are defined in the core FSharp.Core.dll library)
Functions and types for F# Async programming, including asynchronous I/O extensions and several helper classes

Provides converters from quotations to .NET expression trees:

let adderExpr = <@ fun i -> i + 1 @>.ToLinqExpression()
let adder = <@ fun i -> i + 1 @>.Compile()

Introduces a query operator that allows F# programs to execute queries via LINQ mechanisms:

let db = new NORTHWND(connString)
let sameCountry =
   query <@ seq { for e in db.Employees do  
                   for c in db.Customers do 
                    if e.Country = c.Country then 
                        yield (e,c) } @>

let nums = [|1..500000|]
let finalDigitOfPrimes = 
        nums 
        |> PSeq.filter isPrime
        |> PSeq.groupBy (fun i -> i % 10)
        |> PSeq.map (fun (k, vs) -> (k, Seq.length vs))
        |> PSeq.toArray

F# Metadata Reader
FSharp.PowerPack.Metadata.dll allows to introspect F#-authored assemblies and analyze F#-specific metadata:

// Reflect over list<_> union type
let [l] = 
    FSharpAssembly.FSharpLibrary.Entities 
        |> Seq.filter (fun entity -> entity.CompiledName.Contains "FSharpList") 
        |> Seq.toList
// Get list<_> union cases
let [nil;cons] = l.UnionCases |> Seq.toList

F# Compatibility Helpers
FSharp.PowerPack.Compatibility.dll provides various helper functions for compatibility with OCaml and previous releases of F#