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.

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 = 
        |> 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] = 
        |> 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#

Last edited Feb 17, 2013 at 4:34 PM by dsyme, version 80