Search:

Filtering lists

Two functions showing how to filter functional lists using the specified predicate. First version uses naive recursion and the second one is tail-recursive using the accumulator parameter.

Posted: 15 years ago by Tomas Petricek

Projecting lists

Three functions showing how to implement projection for functional lists. First version uses naive recursion and the second one is tail-recursive using the accumulator parameter. The third version extends this with continuation passing.

Posted: 15 years ago by Tomas Petricek

Random walk

Create sequence of floating point values generated by random walk process. Functional solution using sequence expressions and yield! construct in a tail-call position.

Posted: 15 years ago by Tomas Petricek

Form changing color

Windows Forms tutorial showing how to create form with button and how to register an event handler. When the button is clicked, the form changes its background color.

Posted: 15 years ago by Tomas Petricek

Hello world (F#)

Classical "Hello world" example that prints a message to the console output. This version uses F# printfn function to do the printing.

Posted: 15 years ago by Tomas Petricek

Hello world (.NET)

Classical "Hello world" example that prints a message to the console output. This version uses .NET Console.WriteLine method to do the printing.

Posted: 15 years ago by Tomas Petricek

Friendly date formatting

Generates a friendly string describing a date relatively to the current date and time. The function returns strings like "2 secs ago", "yesterday" or "3 years ago".

Posted: 15 years ago by Tomas Petricek

'use' Bindings

Show's how to use F# 'use' key word to dispose a resource when it passes out of scope.

Posted: 15 years ago by Robert Pickering

Using the 'lazy' Keyword

This snippet uses the lazy keyword to create a delayed computation. It then show's using 'force' to evaluate the computation.

Posted: 15 years ago by Robert Pickering

Using the 'lazy' Keyword

Demonstrates using the 'lazy' keyword. Show's how a lazy value will only ever be evaluated once.

Posted: 15 years ago by Robert Pickering

Unfolding Sequences

Show's using the unfold function to create a sequence that terminates once some limit is passed.

Posted: 15 years ago by Robert Pickering

Recursive functions

Show's how to define a recursive function that will calculate a fibonacci number.

Posted: 15 years ago by Robert Pickering

Using Active patterns

Shows how to use an active pattern that will try to determine the format of an input value.

Posted: 15 years ago by Robert Pickering

Using Active patterns

Show's how to create a parametrized active pattern that will match based on a regular expression.

Posted: 15 years ago by Robert Pickering

Units of Measure

Show's how to define units of measure to add stronger typing to your numerical functions.

Posted: 15 years ago by Robert Pickering

Nice formatting of type names

Add extension to System.Type that returns the name of type including generic arguments in a nice readable format. It returns only short names of generic type and type arguments.

Posted: 15 years ago by Tomas Petricek

Support slicing operator

The snippet shows how to support slicing in a type. Slicing allows you to get for example a 2D sub-matrix of a matrix and is implemented by adding GetSlice member.

Posted: 15 years ago by Tomas Petricek

Random Walk

Random walk on integers starting at zero. At each step, we either add or subtract one depending on a random coin flip. The code uses Seq.unfold to generate infinite sequence.

Posted: 15 years ago by James

Load XAML

This example shows how to load a Xaml file allowing to use WPF from F#. It also shows how to access WPF objects and register event handlers.

Posted: 15 years ago by Antonio Cisternino

Currying

Currying is about fixing arguments of functions from left to right. It's useful to configurate code and embed parameters that usually serve to define the context of a function execution (i.e. a database connection object). Symbolic functions can be used to reorder arguments if needed.

Posted: 15 years ago by Antonio Cisternino

kprintf for logging

Handy *printf feature: use kprintf to prepend datetime to formatted message

Posted: 15 years ago by Vladimir Matveev

Conditional printf

Disable printf based on some condition

Posted: 15 years ago by Laurent

NUnit Sugar

Some simple functions for writing more idiomatic F# tests with NUnit.

Posted: 15 years ago by Ryan Riley

Bit manipulation methods

Bit manipulation methods

Posted: 15 years ago by Andrei Logunov

Factorial

Calculates the factorial for positive integers

Posted: 15 years ago by Stefan Knoblauch

Composing a list of functions

Composition of functions in F# is easily achieved by using the >> operator. You can also chain an arbitary amount of functions (represented as a list or sequence) together by folding the list/seq with >>. [More formally: the set of endomorphisms 'a -> 'a forms a monoid with the binary, associative operator ">>" (or "<<") and the neutral element "id".]

Posted: 15 years ago by Novox

Minimal XML DSL

This snippet provides a very small internal DSL for creating and querying XML using the underlying XLinq classes.

Posted: 15 years ago by Blake Coverett

FSX Structure

I use this basic template when writing .fsx files that I might want to compile. It adjusts the difference in command line/entrypoint handling between a script and a compiled assembly. This example shows the details for a WPF script — replace the #r's and/or remove the STAThread for a WinForms or Console script.

Posted: 15 years ago by Blake Coverett

Random Type with a few modifications

The modified Random type is built on top of System.Random type. It has a member Seed which returns a seed and NextFloat has the same overloads as NextInt (Next in System.Random). The members should further support units of measure.

Posted: 15 years ago by Oldrich Svec

Triple (3D Vector)

This class is a 3D vector representation. There is a module called Triple with operations on the triple type.

Posted: 15 years ago by Oldrich Svec

Continuation-Passing Mnemonics

Continuations provide a means whereby heap space can be traded for stack depth (heap space being generally more plentiful than stack depth). They are especially useful where tail recursion is not possible. Here are a couple of simple continuation examples that can be extended to cover more complex scenarios.

Posted: 15 years ago by Neil Carrier

Functional style Regex engine

Functional style Regex engine

Posted: 15 years ago by Nick Palladinos

Largest Palindrome Number from Product of Two Three Digit Numbers

Here is an improved version twice shorter, than original

Posted: 15 years ago by Nick Canzoneri

Distance between two 3D segments

The function segmentSegment takes 2 segments (starting and ending points) and computes the shortest distance between them. The function returns a starting and ending point of the shortest segment between the two segments. The function uses a triple type but can be easily rewritten to work with any other type (vector etc).

Posted: 15 years ago by Oldrich Svec

Association list lookup

While prototyping programs I find myself using association lists. This little snippet defines a lookup functions for association lists defined as lists of tuples.

Posted: 15 years ago by Alex Muscar

elements of 3 value tuple

Analog to the fst and snd functions of the f# lib some functions for tuples with 3 values which i use quite regularly during prototyping phases.

Posted: 15 years ago by daniel szymanski

Haskell function : iterate

Implements iterate function from Haskell's Prelude. The function generates an infinite sequence by applying a function to the initial value (first) and then to the result of previous application.

Posted: 15 years ago by Nick Palladinos

The Haskell const function

The const function is simple, but you can use it to make your code more legible. In this example we convert a unary function to a function of arity 2 (that ignores the second argument). Also by using the flip function from Haskell (which is equally easy to define) you can ignore the first argument.

Posted: 15 years ago by Alex Muscar

WinForms layout combinators

A domain specific language for creating layout using Windows Forms. The snippet implements combinators for creating controls and simple automatic arrangement of them.

Posted: 15 years ago by Tomas Petricek

A beautiful fixed-point finding function

We start with an initial value and then applying f repeatedly, until the value does not change anymore.

Posted: 15 years ago by Nick Palladinos

Creating objects with events

This snippet shows how to create objects with events in F#. It shows both simple event (to be used from F#) and a .NET compatible event with specific delegate type.

Posted: 15 years ago by Tomas Petricek

Cartesian Product of Lists

Computes the Cartesian product of a list of lists. See also corresponding example for a sequence of sequences.

Posted: 15 years ago by Neil Carrier

Cartesian Product of Sequences

Computes the Cartesian product of a sequence of sequences. See corresponding example for a list of lists.

Posted: 15 years ago by Neil Carrier

Working with paths

Concatenating paths shouldn't be done just using string concatenation, because the directory separator may differ on various platforms. This snippet shows a simple custom operator for working with paths.

Posted: 15 years ago by Tomas Petricek

Traverse quotation

Shows how to use the 'ExprShape' module to recursively traverse an entire quotation and how to write quotation transformations. As an example, the snippet replaces all numeric constants in the quotation and then runs the transformed code.

Posted: 15 years ago by Tomas Petricek

Setting the user agent of a Web request

Some Web sites deny requests that aren't sent by recognized browsers and search engine crawlers. Setting the user agent header of the request is usually sufficient for bypassing this restriction.

Posted: 15 years ago by Taha Hachana

Asynchronous sequences

An asynchronous sequence is similar to the seq type, but the elements of the sequence are generated asynchronously without blocking the caller as in Async. This snippet declares asynchronous sequence and uses it to compare two files in 1k blocks.

Posted: 15 years ago by Tomas Petricek

Getting a key from Windows registry

F# code to fetch a registry key

Posted: 15 years ago by Tuomas Hietanen

Break sequence into n-element subsequences

I'm working on parallel computations and I thought it would be useful to break work into chunks, especially when processing each element asynchronously is too expensive. The neat thing is that this function is general even though motivation for it is specific. Another neat thing is that this is true lazy sequence unlike what you'd get if you used Seq.groupBy. There are three versions for your enjoyment.

Posted: 15 years ago by Dmitri Pavlenkov

Project Euler #2

Solution to Project Euler problem 2: Find sum of even terms in fibonacci sequence which do not exceed four million. Comments about the first version: 1. It does't use memoize becouse of recursive call to unmemoized function "fibs". So it take over 20 sec to get answer. A minor change ("fibs" to "fibs' ") reduces this time to 140ms.

Posted: 15 years ago by D

Memoization and Tail Recursive Function

Hi, I expressed Memoization and Memoization Tail Recursive on the functions. I hope something useful.

Posted: 15 years ago by zecl

EnumerableStream

A lazy enumerable/stream of bytes.

Posted: 15 years ago by Ryan Riley

Dictionary extensions

Extensions to dictionaries.

Posted: 15 years ago by Ryan Riley

Fibonacci sequence

Cached fib sequence

Posted: 15 years ago by Dmitri Pavlenkov

inline pow

LanguagePrimitives help create inline functions

Posted: 15 years ago by Dmitri Pavlenkov

Regex Match Index

A function for interpreting the zero-based index property of a successful regular expression match in terms of line and column numbers.

Posted: 15 years ago by Taha Hachana

Clojure's Atoms

Clojure's Atoms are ref like structures, with the addition of (Compare And Swap) update semantics

Posted: 15 years ago by Nick Palladinos

Closest Pair of Points

Closest Pair of points problem in the planar case.

Posted: 15 years ago by Martin Szarski

F# impl of SelectMany and TakeUntil from Rx

F# implementation of SelectMany and TakeUntil (from Rx) on F# events

Posted: 15 years ago by Ankur Dhama

Functions around nullable types

Various functions around nullable types

Posted: 15 years ago by Mauricio Scheffer

Async hashing

Async memory or file hashing

Posted: 15 years ago by Mauricio Scheffer

Async SMTP

Async wrapper for SmtpClient (which is event-based)

Posted: 15 years ago by Mauricio Scheffer

Parsing string expressions, the lazy way

Sometimes you'd be surprised at what functionality you can find inside the .Net framework. Apparently the DataTable object can compute string expressions. Nice for testing your own parser implementation, and/or for lazy coders like me. Note that the DataTable is created only once and reused with each function call.

Posted: 15 years ago by Arjen Kopinga

Async TCP Server

A basic, asynchronous TCP server

Posted: 15 years ago by Ryan Riley

Tree searching using Tail recursion with continuation

Sample code which demonstrate tree searching using : Tail recursion with continuation

Posted: 15 years ago by Ankur Dhama

Calculating Age

This function interprets a time span in terms of years, months and days.

Posted: 15 years ago by Taha Hachana

Async to IObservable

Wraps an Async as an IObservable to allow easier consumption by other .NET languages. Many thanks to desco for his help: http://cs.hubfs.net/forums/thread/16545.aspx

Posted: 15 years ago by Ryan Riley

Partition a sequence until a predicate is satiated

This function is given a partition predicate and a sequence. Until the predicate returns false, a list will be filled with elements. When it is, both the list and the remainder of the sequence will be returned. Note that this example preserves the laziness of the unchecked sequence elements.

Posted: 15 years ago by Rick Minerich

Create generic IEnumerable from non-generic

Depends on Castle Dynamic Proxy 2. Returns an IEnumerable from a System.Type and a System.Collections.IEnumerable. It is a hack I wrote simply because I couldn't find anything in the framework to do this.

Posted: 15 years ago by Dan Finch

Seq.tryTake

A more tolerant and open-minded take.

Posted: 15 years ago by Dan Finch

Convert a obj list to a typed list without generics

This is used for building things with reflection at runtime. As ConstructorInfo arguments require typed collections, it is necessary when parsing to reflected records to first build up contents and then afterward convert the collected obj[] to a 'a[]. This is finally cast back to obj so it can be used as a ConstructorInfo argument.

Posted: 15 years ago by Rick Minerich

Get Stock Quote Data and Historical Stock Prices from Yahoo Finance

Get Stock Quote Data and Historical Stock Prices from Yahoo Finance.

Posted: 15 years ago by Tuomas Hietanen

Function to generate circular infinite sequence from a list

Function to generate circular infinite sequence from a list

Posted: 15 years ago by Ankur Dhama

LazyList

A LazyList implementation with tail recursive enumeration.

Posted: 15 years ago by Nick Palladinos

Easy Wrapper for thread pool work

An easy wrapper for the TPL that works nicely with (|>)

Posted: 15 years ago by Paul Greene

Take every Nth element of sequence

A function that takes every Nth element of a sequence where N is passed as an argument. The snippet shows a naive function and a function using IEnumerator directly to provide an efficient implementation.

Posted: 15 years ago by Tomas Petricek

Function to generate all possible combinations where combination "ab" != "ba"

Function to generate all possible combinations where combination "ab" is different then "ba"

Posted: 15 years ago by Ankur Dhama

Remove first ocurrence from list

Removes from list the first ocurrence only of an element that satisfies the predicate. Additional elements that also satisfy the predicate remain in the list.

Posted: 15 years ago by Alexander Rautenberg

Inline factorial samples with fix point

While reading Tomas Petricek's master thesis, came across FIX operator implementation. Decided to experiment with various implementations of factorial.

Posted: 15 years ago by Dmitri Pavlenkov

Clojure's Atoms

Clojure's Atoms are ref like structures, with the addition of (Compare And Swap) update semantics

Posted: 15 years ago by Nick Palladinos

Supercompilation using quotations

This code sample shows how to create a function that raises number to a given power using supercompilation with quotations. For any given power, the function returns quoted expression for calculating the power using explicit multiplications, which is then evaluated.

Posted: 15 years ago by Dmitry Soshnikov

Simple HTTP server with Async workflow

Simple HTTP server with Async workflow and Http Listener

Posted: 15 years ago by Ankur Dhama

Playing with async sequences

Attempt to reimplement functions AsyncRead/AsyncReadLines from 'Rx on the server ' articles (by Jeffrey van Gogh) using idea of AsyncSequence (by Tomas Petricek)

Posted: 15 years ago by Vladimir Matveev

Project Euler #182

The RSA encryption is based on the following procedure: Generate two distinct primes p and q. Compute n=pq and phi=(p-1)(q-1). Find an integer e, 1 25 people like this
Like the snippet!

Posted: 15 years ago by Natallie Baikevich

Active pattern for let binding inside patterns

The Let active pattern demonstrated by this snippet can be used to assign values to symbols in pattern matching. This is useful for writing complex pattern matching using match as we can handle multiple cases using a single clause.

Posted: 15 years ago by Tomas Petricek

URL Canonicalization

This function produces safe URLs for Web requests or URI construction. It forces the pattern: http:// + www. OR subdomain. + domain + absolute path. When used in an application that takes URLs as input, the user would be able to type "example.com" instead of "http://example.com" or "http://www.example.com". It also supports domains like google.co.uk or google.com.au.

Posted: 15 years ago by Taha Hachana

Pascal's Triangle

This code sample generates Pascal's triangle as jagged 2D list (list of lists).

Posted: 15 years ago by Dmitry Soshnikov

Anagrams

Let's use the fundamental theorem of arithmetic to determine if two words are anagrams of each other. How? The theorem states (roughly) that each number can be written as a product of prime numbers in only one unique way. For instance 42 = 7 * 2 * 3 = 3 * 7 * 2. Now what will happen if you associate a letter with a unique prime number? You can see that "team" [71*11*2*41] = "meat" [41*11*2*71]. Oh, the possibilities. Note that in the code below big integers are used since the product of many primes will overflow a 32- or even a 64-bit integer.

Posted: 15 years ago by Arjen Kopinga

Hex encode / decode

Performs conversions to and from hexadecimal values.

Posted: 15 years ago by Daniel Robinson

Quote SQL Server identifiers

Quotes SQL Server identifiers. Handles embedded quotes.

Posted: 15 years ago by Daniel Robinson

Lazily split string

Splits strings lazily, instead of splitting entire string into an array like System.String.Split. Especially useful for very large strings.

Posted: 15 years ago by Daniel Robinson

Change identifier case

Converts string to Pascal or camel case. Useful mostly for identifiers. Uses case changes to determine word boundaries.

Posted: 15 years ago by Daniel Robinson

Regular expression active pattern

Active pattern returning list of captured groups.

Posted: 15 years ago by Daniel Robinson

debugging window

The window is useful when you want to print out data to the screen.

Posted: 15 years ago by Stefan Knoblauch

Pascal's Triangle (2)

This code sample generates Pascal's triangle as jagged 2D list (list of lists). It takes 0.5 sec to generate 3000 rows (vs 16 sec for http://fssnip.net/23). Tip: try to avoid of using "list1 @ list2" construction.

Posted: 15 years ago by Shamil Sayfutdinov

Infinite sequences

Haskell-inspired infinite sequences

Posted: 15 years ago by Nick Palladinos

Merge two events in one event to move over a list

Merge two events in one event to move over a list. Can be used to implement a wizard / slider mechanism

Posted: 15 years ago by Ankur Dhama

Uri Parser

A Uri parser using the Cashel library [1]. This implementation is using ArraySegment as the underlying state, as I'm using it within a server, but it would be trivial to switch it to using a list. Also, note that I am not parsing the Uri into any specific structure, though that, too, would be trivial. For my current purposes, I just needed to validate the Uri. [1] https://github.com/panesofglass/cashel

Posted: 15 years ago by Ryan Riley

Composable WCF Web API using Async

A functional wrapper around the new WCF Web APIs (http://wcf.codeplex.com/). Composition is achieved through the use of the HttpRequestMessage -> Async signature. Pushing the app calls in the MessageHandler intercepts all requests and allows you to take control at the earliest point possible before operation selection occurs. Extending this slightly to call the innerChannel's SendAsync would allow you to create a middleware layer that would work both with this and other, normal Web API services.

Posted: 15 years ago by Ryan Riley

LinkedList extensions

LinkedList functional extension providing find and findi higher order functions that take a predicate function.

Posted: 15 years ago by Phillip Trelford

A simple Quine

A simple Quine in F#

Posted: 15 years ago by Nick Palladinos

Sorted Map

Sorted Map

Posted: 15 years ago by fholm

A little esoteric os

Petrovich is more than just a programming language, it is a complete computer operating system and program development environment named after Ivan Petrovich Pavlov. Design Principles: * Provide an operating system and computer language that can learn and improve its performance in a natural manner. * Adapt to user feedback in an intelligent manner.

Posted: 15 years ago by Natallie Baikevich

Exiting cleanly

Demonstrates how to run a function when the user presses Ctrl+C, closes the console window, or logs off.

Posted: 15 years ago by Tim Robinson

Plotting using Chart сontrol

This snippet shows how to plot data on a form using .NET 4.0 Chart control.

Posted: 15 years ago by Dmitry Soshnikov

Example of annoying enumeration syntax

Example of annoying enumeration syntax

Posted: 15 years ago by fholm

Seq.unsort

Randomizes order of specified sequence

Posted: 15 years ago by Phillip Trelford

Find verbose .NET types using Reflection

Searches all (currently loaded) types using Reflection to find the types with longest and shortest names of members. Uses average length of all type member names as a metric.

Posted: 15 years ago by Tomas Petricek

A Clojure inspired (race free) memoize function

A Clojure inspired (race free) memoize function, that uses a mutable atom cell.

Posted: 15 years ago by Nick Palladinos

Disposable computation builder

Computation builder that provides easy way of constructing IDisposable objects. It supports elegant composition of disposable objects using 'do!' which can be used for example when working with 'IObservable' type.

Posted: 15 years ago by Tomas Petricek

Parse HTTP chunked response

Code to parse HTTP chunked response, to use as a client to a Comet server who uses chunked encoding to transfer real time notification data

Posted: 15 years ago by Ankur Dhama

Miller–Rabin primality test

Miller–Rabin primality test is an algorithm which determines whether a given number is probable prime. For more information go to http://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test

Posted: 15 years ago by Cesar Mendoza

ObservableObject

The ObservableObject type implements the INotifyPropertyChanged interface used in WPF and Silverlight to notify on changes to properties that are bound to a control. Specify property names type safely using F# Quotations, i.e. <@ this.PropertyName @> when invoking the NotifyPropertyChanged method. If you are following the MVVM pattern then your View Model class can inherit from the ObservableObject type.

Posted: 15 years ago by Phillip Trelford

All combinations of list elements

For a given list, find all possible combinations of elements of the list (not just k-combinations). The result is a list of lists with each element representing one combination. Order of elements is not taken into account.

Posted: 15 years ago by Alexander Rautenberg

Cartesian product of n lists

Cartesian product of a variable number of lists. Input is a list of lists of which the cartesian product is to be constructed; output is a list that contains the elements of the product set, as lists.

Posted: 15 years ago by Alexander Rautenberg

Inspect middle of a pipeline in VS 2010 debugger

Put the code at some place and enable "Step Into Properties and Operators in Managed Code": http://msdn.microsoft.com/en-us/library/cc667388.aspx Now you should be able to step into the pipeline operator.

Posted: 15 years ago by Oldrich Svec

get the list of LAN Sql servers

get the list of ethernet sql servers

Posted: 15 years ago by nCdy

Palindromic dates

Today, 11. february 2011, is a palindromic day according to the European date format (day/month/year). This snippet collects all the palindromic dates until 31 dec. 9999. They are 366, a surprisingly low number.

Posted: 15 years ago by Francesco De Vittori

Observable.Subject

The Subject type implements both IObserver and IObservable. It is functionally equivalent to the type of the same name in the Reactive Extensions (Rx) library.

Posted: 15 years ago by Phillip Trelford

Ugly hack to call F# functions as static methods

Ugly hack to call F# functions as static methods

Posted: 15 years ago by fholm

reference to array element

Nice thing you can do in F# that you can't do in C#, pulling a reference to an array element as a local var.

Posted: 15 years ago by fholm

Read only ref

F# implementation of RO_ref from the "Effective ML" talk.

Posted: 15 years ago by fholm

Abstract Console.ReadLine as an infinite sequence

Abstracts console input as an infinite sequence of lines of text

Posted: 15 years ago by fholm

Re-creating arithmetic with DU

You never know when you might need this.

Posted: 15 years ago by Dmitri Pavlenkov

Simple Object orientation using Record types

Simple Object orientation using Record types. No complex - private public internal virtual abstract object oriented programming :)

Posted: 15 years ago by Ankur Dhama

Farey Sequence

Return a sequence that contains the numerators and denominators as tuples for Farey Sequence n.

Posted: 15 years ago by Graham Spiers

Jaro-Winkler in F#

Jaro-Winkler is a fast and effective name matching algorithm. For more info see "A Comparison of String Distance Metrics for Name-Matching Tasks" http://www.isi.edu/info-agents/workshops/ijcai03/papers/Cohen-p.pdf or the Wikipedia article http://en.wikipedia.org/wiki/Jaro%E2%80%93Winkler_distance

Posted: 15 years ago by Rick Minerich

IronJS Boxing Struct

This is the struct IronJS uses internally to do NaN-tagging of boxed values, using the technique described here http://blog.mozilla.com/rob-sayre/2010/08/02/mozillas-new-javascript-value-representation/ and here http://article.gmane.org/gmane.comp.lang.lua.general/58908

Posted: 15 years ago by fholm

Caching the function object created

Caching the function object created

Posted: 15 years ago by fholm

Struct Tuple

Two/Three/Four-element generic tuples implemented as a value types for writing more efficient F# code.

Posted: 15 years ago by fholm

Abstracting over 'M'

A higher kind of request to Don Syme... please please please,,,, we desperately need higher kinds!

Posted: 15 years ago by Nick Palladinos

Serialization of functions

Serialization and deserialization of a function value with Soap formatting. (With serious limitations; not sure how useful this is.)

Posted: 15 years ago by wmeyer

Huffman coding

Naive implementation of HuffmanCoding

Posted: 15 years ago by lamer

Scheme interpreter in F#

A small Scheme interpreter using Higher Order Abstract Syntax (HOAS) encoding for terms. The essence of the technique is to use F# (meta-level) functions to encode Scheme (object-level) functions and other binding constructs, thus avoiding the need for representing variables, bindings, explicit substitution and dealing with shadowing.

Posted: 15 years ago by Anton Tayanovskyy

Dynamic operator using Dynamic Language Runtime

The snippet shows a simple implementation of the dynamic operator (?) that uses Dynamic Language Runtime and the C# implementation of dynamic operations. The snippet shows how to invoke instance methods with single argument.

Posted: 15 years ago by Tomas Petricek

Dynamic operator using Reflection

Demonstrates how to implement the dynamic operator (?) using .NET Reflection. The implementation supports calling constructors, propreties and methods using simple overload resolution (based on parameter count). It handles instance as well as static members.

Posted: 15 years ago by Tomas Petricek

Top-Down-Operator-Precedence Parser

F# implementation of a generic Top-Down-Operator-Precedence Parser as described in this paper http://portal.acm.org/citation.cfm?id=512931 Example starts at line ~300

Posted: 15 years ago by fholm

Pascal's Triangle

Returns the pascal triangle in a 2D list . This snippet computes rows translating the 'visual' method taught at school into Lists and the usage of map2 function. It takes almost 5 seconds to compute 5000 rows.

Posted: 15 years ago by Horacio Nuñez

Extensions to the Fold function

This snippet is helpfull in the following cases: 1) After a consolidation operation using the fold function we need to know how many elements have been processed. 2) A consolidation operation needs to use the index of each of the elements processed and we don't want to use the mapi function first. 3) A combination of the above. Since the following snippet just adds a wrapper to the existing Fold function we can repeat the approach for arrays and sequences (including the plinq ones)

Posted: 15 years ago by Horacio Nuñez

String repeater

A function that efficiently creates a new string containing a given string multiple times. The function is implemented using .NET StringBuilder class.

Posted: 15 years ago by fholm

Union constructors can be used as functions

Union constructors can be used as functions

Posted: 15 years ago by fholm

Perl Style "Regex Matches?" operator

Perl Style "Regex Matches?" operator

Posted: 15 years ago by fholm

Small embedded DSL to write in F# "Who is John Galt?"

This snippet how we can use F# constructs like discrimated unions, functions and symbolic identifiers to represent proper language statements (albeit limited) using valid F# code.

Posted: 15 years ago by Horacio Nuñez

Create Disposable

This pattern is helpful when you want to do something temporarily and then restore some state. This was inspired by the System.Disposable.Disposable() class defined in System.Core.dll distributed by the Reactive Extensions for .NET (Rx) library.

Posted: 15 years ago by Cesar Mendoza

F# googelsearch

A google search automation.

Posted: 15 years ago by Chief Inspector Clouseau

A Lazy fixed-point combinator

x = f(x) encoded in F#

Posted: 15 years ago by Nick Palladinos

Enumerator computation builder

The snippet defines computation builder for working with IEnumerator. The bind operation (let!) reads next element from the enumerator, so the computation can be used for expressing things that cannot be written just using seq.

Posted: 15 years ago by Tomas Petricek

Wicked way to solve quadratic equation using list of operators

This is to demonstrate that: (1) there are many ways to solve the same problems; (2) operators can be grouped together into data structures and act as data; (3) you can have fun in F# in many ways.

Posted: 15 years ago by Dmitry Soshnikov

Primitive Pythagorean triples

Primitive Pythagorean triples generator. It uses an Algorithm found on Wolfram MathWorld and the F# PowerPack matrix library.

Posted: 15 years ago by Cesar Mendoza

Object oriented as it was supposed to be ?

The snippet shows implementing object orientation using mail box processor. In this context object orientation have this simple definition: "Objects acts on message passing". The objects created this way are thread safe too :). Not sure how much practical this would be in todays context where object oriented has gone the wrong way.

Posted: 15 years ago by Ankur Dhama

Bar chart using chart controls

The snippet shows how to use Microsoft Chart Controls (available in .NET 4.0 and for .NET 3.5) to draw a Bar chart. The sample shows population sizes in different continents.

Posted: 15 years ago by Tomas Petricek

Line chart using chart controls

The snippet shows how to use Microsoft Chart Controls (available in .NET 4.0 and for .NET 3.5) to draw a Line chart. The sample generates a 2D spline calculated using sin and cos functions.

Posted: 15 years ago by Tomas Petricek

Candlestick chart using chart controls

The snippet shows how to use Microsoft Chart Controls (available in .NET 4.0 and for .NET 3.5) to draw a Candlestick chart visualizing stock prices. The sample uses price of MSFT stocks over 20 days.

Posted: 15 years ago by Tomas Petricek

Boxplot diagram using chart controls

The snippet shows how to use Microsoft Chart Controls (available in .NET 4.0 and for .NET 3.5) to draw a BoxPlot diagram. In this sample, we provide six statistics (Maxmimum, Minimum, Upper quartile, Lower quartile, Average and Median) about observations explicitly.

Posted: 15 years ago by Tomas Petricek

Gaussian Random Sequence

Normalized Random sequence generator conforming to the user supplied mean and sigma utilizing a "seed factory" instead of the default time of day. The Gaussian sequence is based on the central limit theory, averages together the flat distribution from the random generator built into .NET. Two examples of using normalRand are given to create infinite sequences of white and brown(ian) noise.

Posted: 15 years ago by Tony Lee

Split a list

Three ways to split a list in half (but not necessarily in the middle). A forth version added that's very short and should be fast, as we only use List.fold. New champ found.

Posted: 15 years ago by Dmitri Pavlenkov

Graham scal algorithm for finding the convex hull of a sequence of 2D points

finds the points lying on the convex hull of the given set of points and returns those points in clockwise direction, starting at the point with minimum y-value Remarks: it's a more or less direct implementation of the algorithm named after Ronald Graham that is explained on http://en.wikipedia.org/wiki/Graham_scan you can switch the definition Point for a proper type of your liking - e.g. System.Drawing.Point

Posted: 15 years ago by Carsten König

WPF DepdencyProperty

Declaring WPF DependencyProperty in F#

Posted: 15 years ago by Fahad

Implementing active objects with a MailboxProcessor

Mailbox processors can easily be used to implement active objects. This example shows how to do that with a reusable wrapper type and minimal boilerplate code in the actual class definitions. Supports both asynchronous calls and synchronous calls. For the latter case, exceptions are automatically propagated back to the caller.

Posted: 15 years ago by Wolfgang Meyer

Byte literals

Demonstrates an array initialized from byte literals, which use the 'uy' suffix, and an array initialized from a string byte array literal

Posted: 15 years ago by Tim Robinson

Curry / Uncurry

Helpers to convert functions that take a 2-tuple to curried functions and vice versa. Very helpfull for the "Zip"-functor together with operators - see example

Posted: 15 years ago by Carsten König

ZipMap

Helper function to fold an operator over two sequences so {x1; x2; x3; x4; ...} and {y1; y2; y3; y4; ..} is mapped with an operator f to {f x1 y1; f x2 y2; ...} See example

Posted: 15 years ago by Carsten König

QR-decomoposition of a square-matrix using the Gram-Schmidt method

shows a simple implementation of a vector and matrix type together with a QR-decomposition using the Gram-Schmidt method. The algorithms themselfes are rather easy but I think the implementation of the types and the computations using recursive techniques might be interessting

Posted: 15 years ago by Carsten König

Simple asynchronous functions

The snippet demonstrates how to compose simple asynchronous functions and how to use try .. with to handle exceptions in asynchronous workflows.

Posted: 15 years ago by Tomas Petricek

Functional XML Construction and Query

This snippet shows how to construct and query XML using XLinq without too many helper functions.

Posted: 15 years ago by Taha Hachana

Yahoo Historical Quote Implementation

F# module to return historical EOD: open | high |low | close | volume quotes from Yahoo. Single day requests only. DataContract provided on the result record for easy serialization.

Posted: 15 years ago by akaPhenom

TCP/IP Proxy

A minimal TCP/IP proxy implementation with F# asynchronous workflows

Posted: 15 years ago by Ademar Gonzalez

Chronological sequence window beginnings

An abstraction of the following use case: Given a sequence of dates and max temperatures for each date, extract out the initial dates on which the temp is greater than a given threshold for n consecutive days. (Originally posted as an answer to this StackOverflow question: http://stackoverflow.com/questions/5267055 )

Posted: 15 years ago by ildjarn

Monadic Memoization

Modular memoization within a pure functional setting that is implemented as a convenient computation builder.

Posted: 15 years ago by Nick Palladinos

Lexer

Hand-written efficient JavaScript lexer from the IronJS project https://github.com/fholm/IronJS

Posted: 15 years ago by fholm

Asserting Series Convergence: Ramanujan's 1/pi formula

Asserting a series convergence using high order functions taking for example the 1/pi formula by Ramanujan. Play with the parameters to see where the numeric data types limits makes the function to return false.

Posted: 15 years ago by Horacio Nuñez

Dumping record type sequence to file

Easy dump of record type sequence to file

Posted: 15 years ago by Chief Inspector Clouseau

Member constraints on records

Demonstrates explicit member syntax as applied to record fields

Posted: 15 years ago by Tim Robinson

Compiler Regression in VS2010-SP1

Compiler regression in VS2010-SP1 ?

Posted: 15 years ago by fholm

Restartable File.ReadLines

.Net 4.0 added File.ReadLines to view a file as a sequence, but the sequence can only be read once. A simple wrapper with seq{yield!} fixes that.

Posted: 15 years ago by Tony Lee

MD5 hash

A function that computes an MD5 hash from a block of bytes. MD5 isn't cryptographically secure, but it's a handy way of condensing a block of data into a short string.

Posted: 15 years ago by Tim Robinson

Pretty Print Source Code Errors

A snippet that allows you to pretty print source code errors

Posted: 15 years ago by fholm

sum the nodes in a (not-binary) tree using continuations

you can easily find how to use continuations to iterate over a binary tree but what if the count of children for each node is not known at design time? It's not so obvious how to do this in order to get a tail-recursive method. This short snippet shows how to do this to sum the values of every leaf. The second part demonstrates a general approach for other operations than addition.

Posted: 15 years ago by Carsten König

List Comprehensions with float iterator

Is it a bug or a feature? :)

Posted: 15 years ago by Oldrich Svec

Black Scholes Option Pricing

The code shows simple implementation of blackscholes algorithm.

Posted: 15 years ago by Kishor Aher

Historical Volatility

The code snippet is capable of calculating historical volatility using Close Price, High Low Price and Close High Low Price methods. Simply provide symbol, start date and end date of the specific volatility method and it extracts the market data from the yahoo service and calculated the volatility.

Posted: 15 years ago by Kishor Aher

Type-a-head search tree for strings

This is a search tree for strings I've built for work to back fast type-a-head for AJAX forms, it could be made million times more space efficient but there was no real need for it so.

Posted: 15 years ago by fholm

Hosting the DLR with IronPython or Ruby

Definition of the dynamic resolution operators for hosting the DLR. You can either use Ruby or Python, as the module isn't language specific.

Posted: 15 years ago by Rainer Schuster

Manage Variable Length Dictionary Entries

Populate and displaythe contents of a dictionary with a variable number of nested records - useful if you want to store and retrieve an arbitrary set of data from a database or other data source

Posted: 15 years ago by Brendan Campbell

Functor => Applicative => Monad

Yet another attempt of mine to "haskellify" my F# coding.

Posted: 15 years ago by Nick Palladinos

CSV reader

I've modified the CSV sample from Expert F# to my needs. I don't wann be forced to use the csv schema as defined by column rows. Therefore I've done two major modifications. 1. remove the permutation 2. added a new column name option to the ColumnAttribute 3. added a name to csv index mapping So basically you now have 3 options. 1. Don't annotate your record at all and use it as POCO. The order of the record fields is mapped directly to the order in the csv. UPDATE: I don't recommend this any more. As of the writing of this snippet I wasn't aware of the fact, that field order isn't guaranted by the reflection mechanism. 2. Use the index option of the ColumnAttribute. Same as before. 3. Use the name option. This is what I've looked for. I've to deal with tons of csv that has more columns I'm interested in. Have a look at the sample usage below. I've moved the type conversion out of the CsvReader class in order to be easyly expandable with custom type conversation (i.e. for combined column values - denormalized data)

Posted: 15 years ago by Rainer Schuster

IRC Jokes

Simple snippet that demonstrates recursively defined discriminated unions, the Y combinator (for encoding recursive functions) and recursive processing of tree-like structures

Posted: 15 years ago by Daniel Jackson

Nullable Refs without using AllowNullLiteral

Nullable Refs without using AllowNullLiteral

Posted: 14 years ago by fholm

How to write a financial contract

Implements the theory from 'How to write a financial contract' by S.L Peyton Jones and J-M Eber

Posted: 14 years ago by Ademar Gonzalez

Imperative computation builder

Defines an F# computation builder for encoding imperative computations. The 'return' construct returns immediately and terminates the rest of the computation. It is also possible to return value from a 'for' or 'while' loop.

Posted: 14 years ago by Tomas Petricek

Resource cleanup event combinator

Declares an event combinator 'Event.using' that automatically releases resources allocated by a previous event occurence. Each event occurence creates a value using a function specified by the user and automatically calls 'Dispose' when generating a new value.

Posted: 14 years ago by Tomas Petricek

Nullable to Option

it's allways a pain to work with F#'s Option values outside of F# - there you've got the Nullable-class this is a short snippet to convert Nullable<'a> to 'a option

Posted: 14 years ago by Carsten König

Use of Partial-Case with Parameters

Depicts use of one kind of active pattern matching; partial-case with parameters.

Posted: 14 years ago by Joel Huang

Combinatorial functions

Here is my F# take on some combinatorial functions from the book "Introduction to Functional Programming" by Richard Bird and Philip Wadler.

Posted: 14 years ago by Cesar Mendoza

Solution to the problem mentioned at : http://professor-fish.blogspot.com/2011/01/tiny-bit-of-denotational-semantics.html

Solution to the problem mentioned at : http://professor-fish.blogspot.com/2011/01/tiny-bit-of-denotational-semantics.html

Posted: 14 years ago by Ankur Dhama

calculating the distance on earth (with units of measure)

calculating the distance between two locations on earth using haversine formula see http://en.wikipedia.org/wiki/Haversine_formula and implementing it using the posibilities of F#'s unit of measure system to avoid unit-conversion-errors concerning radians convertet the code found here: http://www.movable-type.co.uk/scripts/latlong.html for an concrete implementation

Posted: 14 years ago by Carsten König

Powerset

Powerset of set represented as a list. Does not check for repeated elements

Posted: 14 years ago by Andrew Le Couteur Bisson

ML style module example

ML style module example

Posted: 14 years ago by fholm

Wrapped Class/Interface

Wrapped Class/Interface Remark: better this way - see example

Posted: 14 years ago by fholm

Rope

Simple implementation of the rope data structure, http://en.wikipedia.org/wiki/Rope_(computer_science)

Posted: 14 years ago by fholm

Typed access to IEnumerable

This snippet provides a way to gain typed access to System.Collection.IEnumerable values (such as instances of System.Text.RegularExpression.MatchCollection), as long as they support a Count property and an Item accessor.

Posted: 14 years ago by kvb

Fholm

Fast Concatenated String

Posted: 14 years ago by fholm

Efficient Immutable String Concat

Efficient Immutable String Concat

Posted: 14 years ago by fholm

Lazy String

Lazy string based on seq

Posted: 14 years ago by Ankur Dhama

store yahoo quotes in kdb

This snippet will download the constituents from ftse, stoxx50e,dji,hsi,gspc and store quotes beginning from 1981 into kdb. To get this to work you need to download kpnet from http://kpnet.codeplex.com/ and kdb.

Posted: 14 years ago by Kim Tang

Actors acting as Lambdas

The Untyped Lambda Calculus encoded as actors (F#'s MailboxProcessors)

Posted: 14 years ago by Nick Palladinos

High precedence, right associative backward pipe

High precedence, right associative backward pipe

Posted: 14 years ago by Stephen Swensen

A failed attempt at evaluating sequence items in terms of a try-with block

A broken code example demonstrating how it's you can't catch a single throwing enumeration and continue with F#'s IEnumerable.

Posted: 14 years ago by Rick Minerich

Partition a sequence into groups linearly by predicate

Partitions a sequence into groups linearly by predicate. I use this for breaking up my lazy record parsing with sequences into entity-sized chunks which are then easily digestible. Note: Edited back from the previous edit as these were heavily profiled and yield! tends to be slow. Edit #2: Now correctly using "use" instead of "let" for sequence.GetEnumerator () (Thanks Vladimir Matveev)

Posted: 14 years ago by Rick Minerich

Fun with polynoms and inline

for all those wanting to see the (rather unknown) statical interference of type-parameters (in contrast to generic type parameters) in action. I demonstrated this by having som e fun with basic algebra and polynoms

Posted: 14 years ago by Carsten König

palindromes

Find every substring that is a palindrome. A bit lazier than the original.

Posted: 14 years ago by Kevin Cantu

Permutations

computes the list of all permutations of a list for example the permutations of [1;2;3] will be [1;2;3]; [1;3;2]; [2;1;3]; [2;3;1]; [3;1;2]; [3;2;1]

Posted: 14 years ago by Carsten König

Spreadsheet

Spreadsheet script runnable inside http://tryfsharp.org includes a custom DataGrid and a parser for simple formulas e.g.: =1+1 =SUM(A1,A2) Add your own functions to the evaluate function. For a more comprehensive implementation check out http://cellz.codeplex.com

Posted: 14 years ago by Phillip Trelford

Undoable Commands

A simple implementation of an Undoable Command, with a Document to hold a stack of actions. 2 examples of UndoableCommand are given - 1 allows property changes to be remembered, and another which allows the user to execute an action with a corresponding undo. Further examples could include CompositeUndoableCommands where the command is itself a list of commands.

Posted: 14 years ago by Neil Danson

Tree using sequences

Tree implementation using sequences.

Posted: 14 years ago by Ankur Dhama

Seq.filter with accumulator

Seq.filter with accumulator, without using mutable or ref.

Posted: 14 years ago by Ankur Dhama

Asynchronous Controller Helper

The snippet declares a helper for creating asynchronous controllers for ASP.NET MVC 3. It declares a new base class for asynchronous actions that exposes a computation builder for writing actions using F# asynchronous workflows.

Posted: 14 years ago by Tomas Petricek

exec with redirected io as sequences

Since F# is my new scripting language, I needed something like Perl's exec but with sequences for Std In and Out.

Posted: 14 years ago by Tony Lee

Async SNTP client

An asynchronous SNTP client that can retrieve the current time from an internet time server (such as time-a.nist.gov) and optionally update the local system clock to match. Demonstrates async UDP communication, bit-shifting, and native interop/PInvoke.

Posted: 14 years ago by Joel Mueller

Python's sorted function

This is an attempt to produce similar behavior as seen in the sorted( ) function in Python. Supporting only one of the three optional arguments. The key - Specifies a function of one argument that is used to extract a comparison key from each list element

Posted: 14 years ago by Cameron Frederick

The repmin problem

The repmin problem is to replace all elements of a tree of numbers by the minimum element, making only a single pass over the original tree. Repmin is a very ingenious example of Circular Programming.

Posted: 14 years ago by Nick Palladinos

Red-Black-Trees with insert

Found an very good article on RS-Trees in Haskell (see: http://www.eecs.usma.edu/webs/people/okasaki/jfp99.ps) It heavyly uses pattern recognition to translate those pesky balance-rules into short code. Bellowe is the simple rewrite of the haskell-implementation in F# - enjoy

Posted: 14 years ago by Carsten König

.NET Interop

Facilities for interop with languages supporting null.

Posted: 14 years ago by Daniel Robinson

General power function with units

The snippet demonstrates how to write a general power function that has correct type involving units-of-measure. The function uses numbers represented using types. The snippet is mainly an example of what can be done (not recommended for the real world).

Posted: 14 years ago by Tomas Petricek

sscanf - parsing with format strings

A more complete version of sscanf, as proposed on stackoverflow by kvb: http://stackoverflow.com/questions/2415705/read-from-console-in-f Fixed bug in previous version to work with visual studio '13

Posted: 14 years ago by Wolfgang Meyer

Type based Regex Active Patterns

Regex match via Active Patterns with Type based value extraction.

Posted: 14 years ago by Nick Palladinos

Seq.partition

A partition function on sequences, like List.partition and Array.partition, but yields elements in either partition on demand. Suitable as an extension to Seq.

Posted: 14 years ago by Stephen Swensen

Computation Builder for Cartesian Products

Sample framework for computing Cartesian products using a computation builder.

Posted: 14 years ago by TechNeilogy

Abstraction of the "tail-recursive loop" pattern

A novel, due to performance inadequacy, abstraction of the "tail-recursive loop" pattern. Approaching what a built-in language feature might look like.

Posted: 14 years ago by Stephen Swensen

"use"able temporary file

A simple shortcut for creating temporary files for unit tests.

Posted: 14 years ago by Benjol

SHA512 hash code from a string

Generates SHA512 hash code from a string. Usually used in some kind of validity checks, e.g. check first timestamp and then check SHA-hash over id and timestamp to ensure a valid session.

Posted: 14 years ago by Tuomas Hietanen

F# Quotations with INotifyPropertyChanged

ViewModelBase for F# users who want to use it in WPF / Silverlight

Posted: 14 years ago by Fahad

WebSharper Hello World

This sample implements "Hello, world!" as a WebSharper application. It demonstrates how to compose HTML/XML using combinators, how to dynamically create a button with a handler and how to update an existing DOM element.

Posted: 14 years ago by Tomas Petricek

Moving Average

Given a period and a sequence of values, calculates the moving average of the input. E.g., given a period of 4 and a sequence of { 2.0, 8.0, 12.0, 10.0, 6.0, 4.0, 14.0 }, the result of this function is { 8.0, 9.0, 8.0, 8.5 }.

Posted: 14 years ago by Brett V. Forsgren

Check if value is a valid enum or flags combination

-

Posted: 14 years ago by Daniel Robinson

Calculator

Simple Silverlight Calculator UI interactive sample runnable inside http://tryfsharp.org.

Posted: 14 years ago by Phillip Trelford

Calculator

Simple Silverlight Calculator UI interactive sample runnable inside http://tryfsharp.org.

Posted: 14 years ago by Phillip Trelford

Formula Calculator

Simple formula calculator including dynamic unit of measure support. Run as a script in Try F#, and try formula with units like 3m * 3m.

Posted: 14 years ago by Phillip Trelford

Structural BeginUpdate / EndUpdate with Lambda

Several WinForms controls, like TreeView and ListView, implement methods BeginUpdate and EndUpdate, which suspend repainting of the control while items are being individually added to a control, preventing flicker caused by rapid repainting. But using BeginUpdate and EndUpdate is very imperative, and opens up the possibility for bugs, such as neglecting to call the matching EndUpdate. An obvious improvement would be to create an extension method on types implementing this pattern which takes a unit -> unit lambda which is executed between update pairs. But the pattern is only conventional, rather than through a common base class or interface. Hence this presents a reasonable opportunity to use F#'s statically resolved structural type system to implement a function which only works on Control types with the correct structural signature.

Posted: 14 years ago by Stephen Swensen

Seq.triplewise

Triple version of Seq.pairwise.

Posted: 14 years ago by ptan

Select n elements in group from seq

Select n elements in group from seq

Posted: 14 years ago by Ankur Dhama

Create Open XML Word document

Create Open XML Word document using the open XML SDK

Posted: 14 years ago by Piet Amersfoort

Create Open XML Spreadsheet

Create Open XML Spreadsheet using the open XML SDK

Posted: 14 years ago by Piet Amersfoort

Alternative Conditional Printfn

A different approach to conditional debug functions

Posted: 14 years ago by David Klein

Incremental (Functional) QuickSort

Functional quicksort inspired by the Haskell Quick Sort at http://www.haskell.org/haskellwiki/Introduction. Since F# lists aren't lazy, uses sequences instead of lists to be haskell like. Roughly O(n) if you Seq.take 1, full on QS if you enumerate the whole thing.

Posted: 14 years ago by Tony Lee

A fun-ny WPF DataTemplate DSL

Parts of a little DSL to create WPF DataTemplate's in F#. Don't even want to think about the length of a corresponding C#. The F# code corresponds 1-to-1 to the visual tree constructed for the template.

Posted: 14 years ago by Cetin Sert

Async File Crawl

Async File Crawl

Posted: 14 years ago by fholm

Miss Grant's Controller Parser

State machine example, from Martin Fowler's Domain-Specific Languages book, implemented as an External DSL parser in F#. A set of mutually recursive functions are used to parse the string tokens and build the State Machine as an F# record type.

Posted: 14 years ago by Phillip Trelford

Hughes's FuncList

A FuncList is a "list-like" datatype with constant time append (represented as a function of cons-lists). The implementation is based on a convenient computation builder.

Posted: 14 years ago by Nick Palladinos

Create a Open Xml word document from a string array

Create a Open Xml word document from a string array. In this snippet I did not reference the Open Xml SDK

Posted: 14 years ago by Piet Amersfoort

Simple F# ViewModel for Silverlight MVVM

Silverlight default architecture is Model-View-ViewModel. This code gives full design time support for Microsoft Expression Blend. The F# ViewModel is seen as strongly typed data source in the Blend UI. There are two properties binded to the view: HiLabel (OneWay data binding) and MyName (TwoWay data binding). ViewModel implements the INotifyPropertyChanged to support the binding. The view project (HelloApp) is made with Blend (by designers) and it is Silverlight 5.0 project. The view codebehind is c# file and it has only this.DataContext -assignment. The viewmodel project (HelloApp.ViewModel) is F# Silverlight 4.0 library. It is made with VS2010 and F# (by developers). It contains the logical functionality of the current view.

Posted: 14 years ago by Tuomas Hietanen

Sequence Generator from Async

Generates a sequence using a sequence generator and Async.StartWithContinuations. This is an attempt at modeling the OWIN delegate structure in F#

Posted: 14 years ago by Ryan Riley

Hughes's CPSFuncList

A CPS version of FuncList, in order to avoid blowing the stack.

Posted: 14 years ago by Nick Palladinos

Throttling agent

Agent that can be used for controlling the number of concurrently executing asynchronous workflows. The agent runs a specified number of operations concurrently and queues remaining pending requests. The queued work items are started as soon as one of the previous items completes.

Posted: 14 years ago by Tomas Petricek

ReplaySubject

The ReplaySubject type implements both IObserver and IObservable. It is functionally equivalent to the class of the same name in the Reactive Extensions (Rx) library with a replay buffer of a specified size .

Posted: 14 years ago by Phillip Trelford

Asynchronous Workflow Controller

The snippet overrides default AsyncControllerActionInvoker so F# async workflows can be used for ASP.NET MVC 3. It declares a new base class for asynchronous controller. Controller method has to have return type Async.

Posted: 14 years ago by Dmitry Morozov

String explode and implode

Convert string to and from character lists.

Posted: 14 years ago by petebu

Active pattern for comparison

An active pattern for comparing two objects of the same type and implementing IComparable. Modeled on Standard ML comparison.

Posted: 14 years ago by petebu

Active pattern to define default values

This active pattern allows you to specify default values for option arguments in the signature of your function, so you can remove unnecessary calls to defaultArg. It also save you having to define a new name for the defaulted value.

Posted: 14 years ago by Kurt Schelfthout

Silverlight asynchronous WebService call with UI-thread syncronization dispatcher

You can use this code to make a async WebRequest from Silverlight to update ViewModel.

Posted: 14 years ago by Tuomas Hietanen

Weighted Quick-Union with Path Compression

Implementation of Mutable Weighted Quick-Union with Path Compression in F#

Posted: 14 years ago by Rick Minerich

Reading a collection of records from database

This snippet can be used to read all records from a given table and expose them as an IEnumerable (seq)

Posted: 14 years ago by Eduardo Claudio

Create Open XML Spreadsheet with data

Create a Open Xml spreadsheet fromxml. In this snippet I did not reference the Open Xml SDK

Posted: 14 years ago by Piet Amersfoort

Incremental auto-completion

Returns subsets of strings which match a specified prefix. The prefix is built incrementally by repeatedly calling a search function.

Posted: 14 years ago by Johann Deneux

Agent based ObjectPool

This is a simple implementation of an object pool using an agent (MailboxProcessor). The pool is created with an initial number of object using the specified generator. The ObjectPool has three functions: Put: An item can be 'Put' into the pool. Get: An item can be taken from the pool ToListAndClear: A list of all the items in the pool is returned and the pool is cleared.

Posted: 14 years ago by 7sharp9

Discount/Zero Curve Construction

A simplistic discount curve bootstrapping process

Posted: 14 years ago by Wayne Bradney

Quotation property name + comp + value extract

for zec_ on irc

Posted: 14 years ago by fholm

RichTextBox SQL highlighting

Simple RichTextBox SQL highlighting with win32 LockWindowUpdate DllImport

Posted: 14 years ago by nCdy

Functions not so first class in active patterns

It seems that you can't pass anonymous functions as parameters to active patterns.

Posted: 14 years ago by Kurt Schelfthout

escaping string

escaping string, very terse . Update: a bit more terse, and perf improvement by using .ToCharArray() and Array.iter

Posted: 14 years ago by hammett

Simple string escaping

Simple string escaping.

Posted: 14 years ago by fzandona

Moving average

Saw a Moving Average example on this site ( http://fssnip.net/4S ) and wondered if it could be done in even fewer lines of code. It can. This is why I love F#!

Posted: 14 years ago by Paul Papathomas

All subsets of a set

A function implemented using sequence expressions that returns all subsets of a specified set. The function is not optimized, but it is very easy to understand.

Posted: 14 years ago by Tomas Petricek

F# Future

Similar to an async { } block but captures the result for future consumption. This structure can be very useful for performing multiple result-returning operations in parallel when the results aren't needed immediately. For example, performing several read/transform operations or pre-populating a cache with yet-to-be computed values. Microsoft's Task Parallel Library in .NET 4.0 includes a Future implementation so this version is only needed on earlier .NET versions. Comments, suggestions, and improvements are always welcome.

Posted: 14 years ago by Jason McCampbell

Seq.sumBy implemented in terms of Seq.fold

Seq.sumBy implemented in terms of Seq.fold

Posted: 14 years ago by ildjarn

F# Future using lazy and a threading event

F# Future using lazy and a threading event. Supports creating futures from functions or asyncs. Eager evaluation of can be specified.

Posted: 14 years ago by Ankur Dhama

Tetris

Playable Tetris mini-game. Use arrow keys to move left and right and up to rotate, down to drop. Try it out in the browser on TryFSharp.org

Posted: 14 years ago by Phillip Trelford

Functional Unparsing SQL

A combinator based DSL for composing type-safe parameterized sql queries. Inspired by Olivier Danvy's "Functional Unparsing" paper.

Posted: 14 years ago by Nick Palladinos

Repeat until

Repeatedly call a function until it returns a positive result. Implemented using sequences.

Posted: 14 years ago by Johann Deneux

Still Mouse Click Event

Detects a mouse down then up event without a move.

Posted: 14 years ago by Phillip Trelford

Still Mouse Click Event Using Scan

Detects a mouse down then up event without a move.

Posted: 14 years ago by Zach Bray

Improved map declaration

Ruby like map declaration syntax

Posted: 14 years ago by Saagar Ahluwalia

WPF/Silverlight Value Converter

Example of a WPF/Silverlight Value Converter base class and concrete implementation.

Posted: 14 years ago by Tao Liu and Daniel Mohl

memoizeBy

Sometimes you might wish to memoize a function whose input doesn't have the equality and comparison constraints, or maybe the comparison of your given type is just too slow for what you need. To fix this, you simply provide a function which converts the input into something more fitting as an extra parameter.

Posted: 14 years ago by Rick Minerich

Cancellable agent

The snippet implements a wrapper for standard F# agent that can be cancelled using the IDisposable interface. This makes it possible to use the agent locally (e.g. inside asynchronous workflow). When it is no longer needed, the agent's body is cancelled.

Posted: 14 years ago by Tomas Petricek

Wimbledon special!

Tennis scoring system (at the game level). Includes some pattern-matching examples including 'when' guards.

Posted: 14 years ago by Kit Eason

LazyBuilder

I made LazyBuilder. The synthesis of the lazy function is troublesome. When the call of the Force() method increases, it is ugly. This solves the problem.

Posted: 14 years ago by zecl

Creating Visual Studio Macros in F#

this snippet presents a way to create macros in F# to automato VS IDE environment. To compile, just open a Command prompt window and type: fsc --out:fsmacros.dll --reference:envdte.dll --target:library fsmacros.fs Where FSMACROS.FS is the file name I gave for the code. After compile, copy the dll to C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\PublicAssemblies To use, just open F# interactive in Visual Studio (CTRL+ALT+F) and type: #r “envdte”;; #r “fsmacros”;; Let dte = vs10macros.getDte “The main window title appearing in you VS 2010”;;

Posted: 14 years ago by Eduardo Claudio

Interface workaround for circular dependency problem

Interface workaround for circular dependency problem

Posted: 14 years ago by fholm

Agent Based Scheduler

An agent based scheduler, can be sent a single schedule message (ScheduleOnce) and multiple schedule message (Schedule). The schedule messages comprise of a function to receive the message, the message, an initial TimeSpan before the message is scheduled, and another timespan for the schedule repeat. Check out my blog below for more details: http://bit.ly/mK4prb

Posted: 14 years ago by 7sharp9

Extensions for HTTP servers

This snippet extends several types from the System.Net namespace. It provides an easy to use API for creating asynchronous (as well as synchronous) HTTP servers using F# asynchronous workflows.

Posted: 14 years ago by Tomas Petricek

Synchronous, event-based and asynchronous HTTP proxy

This snippet shows the implementation of three HTTP proxy servers in F#. The first is written using simple synchronous style (that isn't scalable). The second version uses event-based approach in the Node.js style, but is difficult to write. The third version uses F# async workflows and is both scalable and easy to write.

Posted: 14 years ago by Tomas Petricek

Asynchronous HTTP proxy with chunking and caching

This snippet shows two improvements to asynchronous HTTP proxy from: http://fssnip.net/6e. First extension is to process page in chunks (instead of downloading the entire content first). The second extension is to use simple agent-based in-memory cache for previously visited pages.

Posted: 14 years ago by Tomas Petricek

Iteratee

An iteratee based on https://john-millikin.com/software/enumerator/ and http://okmij.org/ftp/Haskell/Iteratee/IterateeIO-talk-notes.pdf

Posted: 14 years ago by Ryan Riley

Tiny IO Monad

Haskell-style IO in F#.

Posted: 14 years ago by igeta

one to nine puzzle

Solve the one to nine puzzle with a utility function that handles the depth first search. First saw the puzzle here: http://msdn.microsoft.com/en-us/vcsharp/ee957404

Posted: 14 years ago by dave jones

N-Queens

Code to solve the N-Queens problem.

Posted: 14 years ago by dave jones

Calculating the angle between the hour and minute hand

This is a response to a Google interview question that someone encountered. A friend of mine was recently hired there and I've heard some thrilling stories of their interview process. So every now and then, I plan to code up a response to one of the hoards of interview questions they have.

Posted: 14 years ago by Antwan "A-Dubb" Wimberly

Calculating the angle between the hour and minute hand redux

This snippet introduces a further subtlety into the previous posting, whereby the intra-hour movement of the hour hand is captured.

Posted: 14 years ago by HP

Sudoku with general solve function

Using the general solve function to solve Sudoku. The puzzle specific code was translated from Norvig's Sudoku code, but any errors are mine. Reuses code from fssnip.net/6m and fssnip.net/6n

Posted: 14 years ago by dave jones

Erlang Ring problem

Here's an attempt at the Erlang ring problem in F#.

Posted: 14 years ago by David Grenier

Get COM instances from Running Object Table

Type extensions for System.Activator which enable the retrieval of COM instances from the Running Object Table.

Posted: 14 years ago by Huw Simpson

Seq group continuous matching elements

Seq group continuous matching elements [1;1;1;2;2;2] will become [ [1;1;1] ; [2;2;2] ]

Posted: 14 years ago by Ankur Dhama

Union-Friendly Generic Binary Serializer

Implements binary serialization. The encoding supports all records, unions, numeric types, strings, rank-1 arrays, maps, sets, lists and dictionaries. Strings are interned for efficiency. The encoding also uses binary compression (GZIP).

Posted: 14 years ago by Anton Tayanovskyy

raiseAfterHandlers

Raises an exception again after attempting to run one or more handlers. Any failures in the handlers will be put into a new AggregateExeption. If no additional errors are raised, the original exception will be re-raised with a preserved stack trace.

Posted: 14 years ago by Sebastian Good

Turtle

Turtle graphics library implemented as an internal DSL, providing a very similar syntax to Logo, it is runnable inside TryFSharp.org.

Posted: 14 years ago by Phillip Trelford

Split sequences

Split sequences based on a predicate.

Posted: 14 years ago by Ankur Dhama

ByteString

An initial attempt at creating a ByteString type based on the Haskell version.

Posted: 14 years ago by Ryan Riley

Permutation and Combination

Permutation and Combination using ListBuilder.

Posted: 14 years ago by zecl

Return the first result using Async.Choice

The snippet implements Async.Choice method that takes several workflows and creates a workflow, which returns the first result that was computed. After a workflow completes, remaining workflows are cancelled using the F# async cancellation mechanism. (The method doesn't handle exceptions.)

Posted: 14 years ago by Tomas Petricek

Splice sequence into other sequence

Splices a sequence into another sequence at a specified index n. Can replace the existing element at n or keep it.

Posted: 14 years ago by Henrik Ravn

Erik Lippert's Comma Quibbling

An old solution of mine to Erik Lippert's Comma Quibbling challenge. I really like this snippet because it shows that with F# we can hack elegant but also fast code.

Posted: 14 years ago by Nick Palladinos

Soundex Algorithm

Algorithms for generating US Census and Daitch-Mokotoff soundex string(s) based on a text input. Soundex is a phonetic algorithm for indexing names by sound, as pronounced in English. The goal is for homophones to be encoded to the same representation so that they can be matched despite minor differences in spelling.

Posted: 14 years ago by Matt Wilson

Take value from a sequence only when it changes

Take value from a sequence only when it changes (based on a predicate). Ex: Seq [1;1;1;3;3;3;5;5;5] will result in [3;5]

Posted: 14 years ago by Ankur Dhama

JoinList

A JoinList is a variation on the list type that offers a constant time append operation.

Posted: 14 years ago by Ryan Riley

Overloads to get tuple items

The static representations, unlike the encoded System.Tuple<_,...,_> forms, of tuples do not have ItemX properties and therefore static structural constraints cannot be used to obtain the nth item of a tuple. Here we give a utility with overloads for obtaining the nth item of a tuple. However, type inference is undermined in the presence of overloads

Posted: 14 years ago by Stephen Swensen

Universal Type

Implements a type into which any other type can be embedded. Check out this link for a discussion: http://ocaml.janestreet.com/?q=node/18

Posted: 14 years ago by Ademar Gonzalez

Basic WinForms drag and drop

Quick example of using drag-n-drop with WinForms.

Posted: 14 years ago by MichaelGG

Seq.reduceBallanced function

The function has the same type as Seq.reduce. Instead of reducing elements from the left to the right, it splits the input into two halves, reduces each half separately and then aggregates the results using the given function. This means that the values are aggregated into a ballanced tree, which can save stack space.

Posted: 14 years ago by Tomas Petricek

Async based MapReduce

Async is a very versatile structure, which has been used to compose CPU/IO bound computations. So it is very tempting to implement a MapReduce function based on Async and borrowing ideas from the theory of list homomorphisms.

Posted: 14 years ago by Nick Palladinos

Finding matching pairs in two sequences

Here's a function which takes a comparator function and two sequences, and returns tuples consisting of an item from each sequence, where the comparator function returns true for those two items. This is a small part of my wider project to generate guitar chord shapes. One of the requirements there is to take a list of 'wanted' notes for a chord, and a list of 'available' notes within a range of frets and to combine them into an actual set of frettings. That's what led to tryFindFirstPair and hence to findPairs.

Posted: 14 years ago by Kit Eason

Her name is Cherry; we've just met

Third cut of a guitar chord shape generator. Given a fretted instrument with a particular tuning (eg. 6 string guitar tuned EADGBE), the generator will produce the frettings necessary to play any specified chord. This is not done from a chord library, but algorithmically (hence should work with whacky tunings). This version doesn't fully respect the limitations of the human hand beyond specifying a maximum 'stretch' of a few frets, so some of the shapes generated would need a friend to help play them! This will be dealt with in a future version. This third version contains improved handling of differing tunings and instruments (eg. DADGAD; banjo) but still doesn't check for unplayable shapes.

Posted: 14 years ago by Kit Eason

IterateeCPS

An iteratee that uses continuation-passing style as an optimization. There is no more discriminated union, and the signature should feel familiar to those using Async.StartWithContinuations.

Posted: 14 years ago by Ryan Riley

Continuation Monad with Call/CC

This is an implementation of the Continuation monad using a type, taking an exception handler, and allowing for Call/CC. This specific implementation is mostly Matt Podwysocki's. I have a similar implementation using a purely functional, exception-handler-less version in FSharp.Monad. Until now, I haven't been able to resolve the callCC operator.

Posted: 14 years ago by Ryan Riley

Simple job processor

Generic batch job processor using Mail box processor. Sending quit message using PostAndReply will ensure that all jobs are completed before returning. (Exception handling is responsibility of the job)

Posted: 14 years ago by Ankur Dhama

AsyncSeq - Introduction and Crawler

This snippet demonstrates programming using asynchronous sequences. It contains (hidden) implementation of AsyncSeq type and combinators for working with it. More importantly, it demonstrates how to use asynchronous sequences to implement a simple sequential on-demand crawler.

Posted: 14 years ago by Tomas Petricek

Chain of responsibility

The following sample wants to make sure the person’s age is between 18 and 65, weight is no more than 200 and tall enough (>120).

Posted: 14 years ago by Tao Liu

Decorate pattern

implement the decorate pattern in F#. The decorate pattern is to add new featuures to an object at runtime.

Posted: 14 years ago by Tao Liu

Observer pattern

Observer pattern in F#

Posted: 14 years ago by Tao Liu

Strategy pattern

Strategy pattern in F#

Posted: 14 years ago by Tao Liu

State Pattern

the interest rate is decided by the internal state: account balance

Posted: 14 years ago by Tao Liu

Adapter pattern

Invoke the methods from incompatible types

Posted: 14 years ago by Tao Liu

Command pattern for Redo-Undo

Command pattern for redo-undo scenario.

Posted: 14 years ago by Tao Liu

Composite pattern and Visitor Pattern

use composite pattern to construct a tree and visitor pattern to bring back the traverse result.

Posted: 14 years ago by Tao Liu

Singleton Pattern

singleton pattern in F#

Posted: 14 years ago by Tao Liu

Factory Pattern

Factory pattern in F#

Posted: 14 years ago by Tao Liu

Rx CombineLatest for list of IObservable<'a> to IObservable<'a array>.

Rx CombineLatest for list of IObservable<'a> to IObservable<'a array>.

Posted: 14 years ago by Ankur Dhama

Proxy Pattern

Proxy pattern is a class functioning as an interface to something else.

Posted: 14 years ago by Tao Liu

Clumsy LoopBuilder

Clumsy LoopBuilder.It's mischievous trick.

Posted: 14 years ago by zecl

Euler #5

Euler #5 solution

Posted: 14 years ago by Michael Falanga

Chain of responsibility II

Unlike the previous chain of responsibility, this version use the pipeline to chain responsibilities.

Posted: 14 years ago by Tao Liu

Scrap Your Boilerplate

Scrap Your Boilerplate with the help of F#. Based on the original paper by Ralf Laemmel and Simon Peyton Jones.

Posted: 14 years ago by Nick Palladinos

Prime numbers - Sieve of Eratosthenes

Basic prime number generator

Posted: 14 years ago by d95danb

Prime testing

Simple check if a number is prime. See also http://fssnip.net/2w.

Posted: 14 years ago by d95danb

Calculating when the 1000th XKCD will appear

Calculate's when a the nth XKCD will appear, starting from XKCD 946. For a full explanation this snippet see: http://strangelights.com/blog/archive/2011/09/02/calculating-when-the-1000th-xkcd-will-appear.aspx

Posted: 14 years ago by Robert Pickering

Coroutine

An implementation of Coroutine by using a continuation monad. It's using a monad library [1]. [1] https://github.com/fsharp/fsharpx

Posted: 14 years ago by einblicker

Parallel Strassen Matrix Multiplication

Strassen's Multiplication Algorithm works much better than the standard approach when the matrix is large. The program implements a parallel version of it.

Posted: 14 years ago by Zhuobo Feng

Circular queue

A circular queue implemented over an array.

Posted: 14 years ago by Johann Deneux

Delimited Continuation Monad

Oleg's delimited continuation monad [1] and creating an external iterator from an internal iterator using it. [1] http://okmij.org/ftp/continuations/implementations.html#genuine-shift

Posted: 14 years ago by einblicker

WPF / SilverLight Converter II

version 1 is http://fssnip.net/62. This new version support convert from any existing function to a converter function by using composition and pipeline. The convert function is to make the function signature agree to the IValueConverter interface. You can add new functions in the FunctionLibrary module and reuse the class definition to reduce the coding effort. The first sample is to show how to make the converter pipeline work, the second one is a debugger converter used to debug the data binding problem.

Posted: 14 years ago by Tao Liu

Command pattern for Redo-Undo II

This command redo-undo implement group the command under Do/Undo category.

Posted: 14 years ago by Tao Liu

Call/CC for Async

An implementation of call-with-current-continuation for Async.

Posted: 14 years ago by Ryan Riley

Minesweeper in 99 lines of code

This program is written in only 99 lines of actual code and remains enough readability. I used few short-coding technics. 1. no XAML. 2. pre-calculate every useful data for the purpose of eliminating useless states 3. using record type with set property as an alternative of view-model 4. initialize everything in one place. 5. encapsulate all states in one place.

Posted: 14 years ago by nagat01

Download stock prices as async sequence

The snippet uses asynchronous sequences (from F# AsyncExtensions) to download historical stock data from Yahoo. Data is downloaded in a buffered way on demand (as needed) and returned line by line. The sample then prints OHLC values for first 30 items.

Posted: 14 years ago by Tomas Petricek

Creating observable using Async.StartDisposable

Implements a simple Async.StartDisposable extension that can be used to easily create IObservable values from F# asynchronous workflows. The method starts an asynchronous workflow and returns IDisposable that cancels the workflow when disposed.

Posted: 14 years ago by Tomas Petricek

Sliding window for Observable

Implements the Observable.windowed function that creates an observable returning a sliding window. The function is an observable version of Seq.observable. The implementation uses a simple F# agent that keeps partial windows and sends them to an observer.

Posted: 14 years ago by Tomas Petricek

Get the F# module or type of the calling code.

This code snippet enables the retrieval of the entity (Module or F# Type) in which the calling code is executing. This can be used to find the module or type name.

Posted: 14 years ago by Huw Simpson

Integer factorization

Return a list of the prime factors for a natural number using trial division and a prime sieve. Ref: http://en.wikipedia.org/wiki/Trial_division Ref: http://fssnip.net/7D

Posted: 14 years ago by d95danb

Integer factorization

Return a list of the prime factors for a natural number using trial division and a prime sieve. Ref: http://en.wikipedia.org/wiki/Trial_division Ref: http://fssnip.net/7D

Posted: 14 years ago by d95danb

Pack consecutive duplicates of list elements into sublists

Pack consecutive duplicates of list elements into sublists.If a list contains repeated elements they should be placed in separate sublists.

Posted: 14 years ago by Naveen

Project Euler Problem 19

How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?

Posted: 14 years ago by Gene Belitski

Project Euler Problem 31

In England the currency is made up of pound, £, and pence, p, and there are eight coins in general circulation: 1p, 2p, 5p, 10p, 20p, 50p, £1 (100p) and £2 (200p). It is possible to make £2 in the following way: 1x£1 + 1x50p + 2x20p + 1x5p + 1x2p + 3x1p How many different ways can £2 be made using any number of coins?

Posted: 14 years ago by Gene Belitski

Gluing-up sequence members

While thinking on Project Euler Problem 40 solution (http://projecteuler.net/index.php?section=problems&id=40) the following subproblem has surfaced: how to glue up string presentations of a sequence members to reach a given length of result string. The snippet gives at least 3 different implementations of such function with performance comparison; as a bonus a solution to Problem 40 is given.

Posted: 14 years ago by Gene Belitski

Read roman numerals

Function that parses a Roman-numeral string and return the number it represents.

Posted: 14 years ago by Naveen

SHA256

Calculates sha256 of the files passed in on the command line. Usage: fsi sha256.fsx downloadedFile.zip

Posted: 14 years ago by Tony Lee

Yet another command-line parser

The snippet shows a parser for command-line arguments supporting value lists for single commands. Calling with the following arguments: "Arg 1" "Arg 2" -test "Case 1" "Case 2" -show -skip "tag" produces the following map: map [("", seq ["Arg 1"; "Arg 2"]); ("show", seq []); ("skip", seq ["tag"]);("test", seq ["Case 1"; "Case 2"])] which can be used to find what data have been sent along with different commands. Calling with the following: "Arg 1" "Arg 2" /test="Case 1" "Case 2" --show /skip:tag produces the same result.

Posted: 14 years ago by Gennady Loskutov

Write roman numerals

Just a pendant to Naveen's readromannumerals; takes an int and produces a roman numeral string

Posted: 14 years ago by Jonas Avelin

Clojure-like lambda function syntax

This snippet implements a Clojure-like lambda function syntax using Code Quotations. However, this implementation is slow and, moreover, not type-safe. So I'm looking for a way to solve the issues.

Posted: 14 years ago by einblicker

RSK algorithm

Implements a bijective mapping between permutations and pairs of standard Young tableaux, both having the same shape. http://en.wikipedia.org/wiki/Robinson%E2%80%93Schensted_correspondence

Posted: 14 years ago by Ademar Gonzalez

Twitter Stream API

Twitter now provides a streaming API which can be used to obtain a continuous stream of tweets on any set of topics, locations, etc., in real time. Read the full details here. It would be nice to convert this stream into an F# sequence so that it can be treated just as any other sequence if F#. This provides “composability”; separation of the generation of a sequence from its consumption. Here is a snippet that does that.

Posted: 14 years ago by Faisal Waris

Monadic Retry

A Monad for composing computations with retry logic. (Useful when we work with Cloud Services)

Posted: 14 years ago by Nick Palladinos

csproj-file parsing with Linq2Xml

This program reads all *.csproj-files from a path and then uses Linq2Xml to show data about the projects. This should be a good template for scripts to manage tons of c#-project files. F# and LINQ-to-XML is very powerful combination.

Posted: 14 years ago by Tuomas Hietanen

Times Table game

Simple times table console based game.

Posted: 14 years ago by Phillip Trelford

Longest Increasing Sub Seq

Find the longest consecutive sub-sequence of increasing numbers.

Posted: 14 years ago by Naveen

Async.Choose operation

Non-deterministic choice operation for F# asynchronous workflows - creates a workflow that returns the result of one of two asynchronous workflows, depending on which completes first. (The other workflow is not cancelled.)

Posted: 14 years ago by Tomas Petricek

JSON Parser

JSON Parser using Regular Expressions & Active Patterns (just for fun).

Posted: 14 years ago by Phillip Trelford

CRC16

simple CRC16

Posted: 14 years ago by nCdy

String to Int and String

Regex String and Int, e g : "qwe123" -> "qwe" and 123, "qwe" -> "qwe", 123 -> 123

Posted: 14 years ago by nCdy

Lazy variable

When we need lazy evaluation, we use the Lazy<'T>. However, the Lazy<'T> must evaluate explicitly. This example enables implicit evaluation(call-by-need).

Posted: 14 years ago by Nobuhisa

Simple Reactive Extensions Example

Subject is a class that implements both IObservable<'T> and IObserver<'T>

Posted: 14 years ago by Tuomas Hietanen

Simple timed-expiry cache

Basic thread-safe timed-expiry cache, implemented as a MailboxProcessor.

Posted: 14 years ago by Yusuf Motara

Compute CC.Net build statistics

Written against CruiseControl.NET v1.5. Queries a CruiseControl.NET server for a project list and then computes min, max, average, and standard deviation of the build durations based on the statistics.csv CC.NET maintains.

Posted: 14 years ago by Matt Wilson

ipv4 conversion snippet

ipv4 conversion snippet, updated based on current version, changed a lot to make it a bit more .NETish

Posted: 14 years ago by david klein

F#-friendly SocketAsyncEventArgs

The name is a bit trying, but the overall callback approach greatly simplifies the mechanism for calling and handling the System.Net.Sockets.Socket Async methods.

Posted: 14 years ago by Ryan Riley

Calculate PI number

PI number calculation based on the wikipedia page(http://en.wikipedia.org/wiki/Pi#cite_note-59). I used Newton's , Machine's and Ramanujan's formula. (updated: line 21: Seq.take => Seq.truncate)

Posted: 14 years ago by nagat01

A fast sieve of Eratosthenes

A prime Eratosthenes' sieve, using a bit array and sieving only odd composites to conserve memory and keep things fast.

Posted: 14 years ago by Arjen Kopinga

Folding over prime factors

Let's have some fun with higher order functions and instead of folding over a list, fold over the prime factors of a number. It can be optimized further by dividing out real primes instead of numbers of the form 6k+/-1, but it's not embarrassingly slow.

Posted: 14 years ago by Arjen Kopinga

Memoization for dynamic programming

The snippet shows how to implement reusable memoization function and how to use it to implement efficient Fibonacci number generator using dynamic programming.

Posted: 14 years ago by Tomas Petricek

Another tennis implementation

Simple game of tennis... refactored after reading Richard Minerich blog post @http://richardminerich.com/2011/02/the-road-to-functional-programming-in-f-from-imperative-to-computation-expressions/

Posted: 14 years ago by Colin Bull

Tennis Kata

Another solution to the Tennis Kata, to score a tennis game.

Posted: 14 years ago by Don Syme

Parser Monad and Combinators

Simple Parser Monad implementation based on the paper "Monadic Parsing in Haskel" by Graham Hutton and Erik Meijer. Code discussion available here: http://blogs.msdn.com/b/fzandona/archive/2011/10/17/parsing-json-the-fun-way-monadic-parsers-records-and-type-providers-part-2.aspx

Posted: 14 years ago by fzandona

JSON Parser Monad

Simple JSON parser implemented using the Parser Monad. Code discussion here: http://blogs.msdn.com/b/fzandona/archive/2011/11/02/parsing-json-the-fun-way-json-parser-monad-part-3.aspx

Posted: 14 years ago by fzandona

Yet another Tennis Kata

It's a joke one liner implementation of Tennis Kata.Please see this code not seriously.

Posted: 14 years ago by nagat01

Caching agent

Agent that keeps a cache of web pages that were downloaded previously. The agent handles messages to add and get data as well as message to clear the cache.

Posted: 14 years ago by Tomas Petricek

Copy-set an array

Copy an array into a new one, changing the value at index 42 to 123. Uses "function" and pattern patching.

Posted: 14 years ago by Johann Deneux

The dining philosophers

The dining philosophers problem implemented using a waiter.

Posted: 14 years ago by Alex Muscar

Convert the number of indentation spaces in a sourcecode.

This small script converts continuous 4 spaces to 2 spaces by using Regex. It gets the source code from a clip board text and save it to clip board. Since this program doesn't parse the source code, conversion is not perfect. But writing script which interacts with clipboard is so easy, you can automate your trivial coding work with a small effort. Using F#interactive with Clipboard is my favorite way of meta-programming.

Posted: 14 years ago by nagat01

Seq.groupAfter function

This snippet is basically the same as http://fssnip.net/6A, except that the element whose predicate holds ends the previous group and the element after it starts a new one. Those two snippets (Seq.groupWhen, Seq.groupAfter) would be generally equivalent to the Haskell functions 'breakBefore' and 'breakAfter' from Data.List.Grouping.

Posted: 14 years ago by Thorsten Meinecke

Concatenate two strings together

Concatenates two strings together: ML or OCaml style

Posted: 14 years ago by Cameron Frederick

Simple JS Calculator

Simple calculator application for adding numbers, compiles to JavaScript via Pit (v0.1) (http://pitfw.posterous.com). Run: http://trelford.com/PitCalculatorApp.htm

Posted: 14 years ago by Phillip Trelford

LINQ to SQLite

Simplest possible sample code for accessing an in-process SQLite database file using LINQ The code does not use a dbml file for the mapping, but an attribute enriched type. (F# script, .Net 4.0, F# 2.0)

Posted: 14 years ago by Dirk Devriendt

Semi-Coroutine

This snippet implements a semi-coroutine by continuations.

Posted: 14 years ago by einblicker

Template pattern

Template pattern is a behavior-based pattern. Realized the importance of high order function, this is a way to use high order function. Still keep the type structure to organize my code.

Posted: 14 years ago by Tao Liu

Non-deterministic computation builder

Computation builder for writing non-deterministic computations.

Posted: 14 years ago by Tomas Petricek

Human Date

Datetime Readable for Humans, Ported from Clojure https://github.com/pmn/noir-messageboard/blob/master/src/noir_messageboard/utils/utils.clj

Posted: 14 years ago by christophd

University enrollment (CZE vs. EU)

Using World Bank type provider and FSharpChart to show average university enrollment in Czech Republic, European Union and OECD members.

Posted: 14 years ago by Tomas Petricek

Times Table JS game

Simple times table browser based game., compiles to JavaScript via Pit (v0.1) (http://pitfw.posterous.com). Run: http://trelford.com/SevenSixes.htm

Posted: 14 years ago by Phillip Trelford

Mini IoC Container

Minimal Inversion of Control (IoC) Container for Dependency Injection (DI) in under 100 lines of code. Implements the 3 Rs of DI: Register, Resolve, Release. Note: missing thread safety and fluent interface.

Posted: 14 years ago by Phillip Trelford

Bi directional map

Bi directional map to implement toString and fromString function for descriminated unions.

Posted: 14 years ago by nagat01

toString and fromString for discriminated unions

General toString and fromString for discriminated unions using FSharp.Reflection

Posted: 14 years ago by Jonas Avelin

Make a chain of functions

Function composition can be done by using >> operator. The snippet at http://fssnip.net/S is a wonderful sample. But that version generates a function which is not easy when you want to debug. This version is to use pipeline (|>) operator.

Posted: 14 years ago by Tao Liu

Building a WPF application in functional way

I started to write pure F# + WPF application in about half a year ago. Today, I found a good way to compose WPF controls with dependent values. It's only writing a dependency object type as a class and give it to constructors of GUI controls. In this snippet "Volume","ColorVolume" and "ShapeContainer" has no properties. But works as a View which represents internal Model and allows users to change internal data. You only need calling a constructor of them. It means that you can compose GUI controls and it's functionality as a immutable data structure. (Update 2011/12/02 8:33:00(UTC+09:00) : Removed some user defined operators and renamed a type similar to DependencyObject in this snippet Reactor to SharedValue.) (Update 2011/12/02 9:04:01(UTC+09:00) : renamed some variables..)

Posted: 14 years ago by nagat01

Forking console output to a string

Higher order function 'withOutStr' to fork console output to a string. The function temporarily redirects Console.Out to a custom TextWriter

Posted: 14 years ago by Jonas Avelin

Serial Port Reader

Code to drive a serial port. Trivial application to read a paper tape to a file from a GNT4604 paper tape reader attached to serial port COM3:

Posted: 14 years ago by Andrew Herbert

Mixed number

A function to calculate 'mixed numbers' - eg. 1 1/8. (With fix to reduce the fractional part to its lowest terms)

Posted: 14 years ago by Kit Eason

Union Editor for WinForms PropertyGrid

A quick-and-dirty editor for discriminated unions in a property grid. I use this for editing trees of F# records and unions. Note that any records must have a "Default" static property which returns a default instance.

Posted: 14 years ago by Rick Minerich

Polyvariadic fixpoint

Polyvariadic fixpoint combinator in F# (heavily inspired by Haskell)

Posted: 14 years ago by Nick Palladinos

Starbucks

Simple DSL for describing cups of Starbucks coffee and computing prices (in dollars).

Posted: 14 years ago by Phillip Trelford

Light XML DSL

A light domain specific language for declaring xml in F# as code.

Posted: 14 years ago by Huw Simpson

Between operators

A couple of operators for 'between, inclusive' and 'between, exclusive'.

Posted: 14 years ago by Kit Eason

DSL for financial contracts

Simple domain-specific language (DSL) for describing financial contracts in F#. A contract is represented using a discriminated union. Evaluating a contract gives the orders that may happen at a given date.

Posted: 14 years ago by Tomas Petricek

Active pattern to extract HttpStatusCode from WebException

A simple active pattern that allows you to match WebExceptions by HttpStatusCode. I find it useful for quick scripts where I only need WebClient and don't have to get involved with WebRequest etc.

Posted: 14 years ago by Leaf Garland

Simple typeclass implementation

I learned how to implement this by reading this great good project http://code.google.com/p/fsharp-typeclasses/ But I can't understand why the project needs ternary operator. I used binary operator and seems it's okay.

Posted: 14 years ago by nagat01

Random Subset

A function that takes a random subset from a seq<'T>.

Posted: 14 years ago by Taha Hachana

Tidy up text using composed functions

Some simple functions to tidy up text and quote it, so that it's suitable to go into a CSV.

Posted: 14 years ago by Kit Eason

Tidy up text using composed functions

Some simple functions to tidy up text and quote it, so that it's suitable to go into a CSV.

Posted: 14 years ago by Kit Eason

Observable Async Subject

Simple Async Observable Subject<'T> based on MailboxProcessor. Type declaration is more ML like, but the idea is represented in a simple way!

Posted: 14 years ago by Fahad

Enum -> MVC3 SelectList

Converts an Enum to a Selectlist which can be used by a @Html.DropDownList

Posted: 14 years ago by christophd

XNA's Vector3 with units of measure

A vector type with units of measure built on top of XNA's Vector3. Not complete, the point is mainly to show how to use generic units of measure to adapt an existing type.

Posted: 14 years ago by Johann Deneux

Using units of measure for safe array access

A typical problem when working with arrays and indices is that it's easy to access an array with the wrong index. Units of measure in F# can be applied to integers, which makes it possible to abuse them to prevent this kind of error.

Posted: 14 years ago by Johann Deneux

Calculate left margins

Take some text and work out where the left margins are, returning the most common margin settings first. Useful for processing somewhat messy text items like movie scripts. Left margins are defined by leading spaces. Tabs must be expanded before calling.

Posted: 14 years ago by Kit Eason

Fast inverse square root

This is an implementation of the famous 'magic number' method of rapidly calculating (inverse) square roots. (See http://en.wikipedia.org/wiki/Fast_inverse_square_root.) In practice, this version is no faster in F# than using 1./sqrt(x). I've posted it as an example of how you can get down-and-dirty with the bits in F# if you need to.

Posted: 14 years ago by Kit Eason

Drag move for GUI controls

This script opens a window with a red rectangle which is moved by dragging. I like writing interactive GUI without MVVM, FRP and Markup language.

Posted: 14 years ago by nagat01

Baccarat

Shuffles a deck of cards, deals 2 hands applying punto banco rules before declaring a winner or a tie.

Posted: 14 years ago by Phillip Trelford

Point of Sale

10 line Point of Sale (POS) application takes barcodes from a USB barcode scanner or keyboard adding matching products. Entering an empty string completes the action and gives the total.

Posted: 14 years ago by Phillip Trelford

Heterogeneous container

OCaml original here : http://eigenclass.org/R2/writings/heterogeneous-containers-in-ocaml

Posted: 14 years ago by Ademar Gonzalez

F# counter agent

The snippet shows a simple F# agent that calculates average from the received values. It supports one message for adding numbers to the statistics and one for resetting the state. Moreover, the agent limits the processing rate to 1 message per second.

Posted: 14 years ago by Tomas Petricek

Transform expressions into Excel formulae

Sometimes it is extremely useful to check some calculations with Excel. The snippet shows how F# expressions can be transformed into Excel formulae. The data is exported together with the formulae, e.g. a, b and sum function as input sets A1's value to a, B1's to b and C1's formula to "=$A$1+$B$1"

Posted: 14 years ago by Natallie Baikevich

WMI F#

Determining If You Are Running the Checked Build p.48 Windows Internals 5th Edition.

Posted: 14 years ago by David Klein

n-ary Seq.map

A pattern for creating n-ary Seq.map functions.

Posted: 14 years ago by Nick Palladinos

n-ary Seq.map (Numerals)

A pattern for creating n-ary Seq.map functions, based on numerals.

Posted: 14 years ago by Nick Palladinos

F# async mailprocessor

F# koodia async käsittelyyn

Posted: 14 years ago by Not important

paraller exec

Async & paraller

Posted: 14 years ago by Not important

BrainFuck

A Small BrainFuck Interpretor (~50 lines). Probably not very efficient only started learning F# a few days ago.

Posted: 14 years ago by Adam Speight

Loading .fs files

This script facilitates to load all the .fs files in the specified F# project in correct compilation order.

Posted: 14 years ago by nagat01

Nest items of a sequence

A function that nests items of a sequence that do not match a specified predicate under the last item that matches the predicate. The input is a sequence of values and the result is a sequence of pairs where the second element is a list of nested items.

Posted: 14 years ago by Tomas Petricek

Tiny F# EDSL for creating system / hardware IDs on Windows using WMI classes

A quick and reconfigurable way to create system or hardware IDs based on WMI Win32 classes for software licensing or similar purposes. (Perhaps a perfect fit for type providers in F# 3.0!)

Posted: 14 years ago by Cetin Sert

Send HTTP POST request

The snippet shows how to send HTTP POST request to a web page and download the generated HTML result. The POST data is encoded as a byte array and written to the request stream of HttpWebRequest.

Posted: 14 years ago by Tomas Petricek

Circular Buffer

A Circular, or Ring, Buffer that flattens incoming arrays and allows consumers to take arbitrary-sized chunks. Improvements and suggestions welcome. Fork my gist at https://gist.github.com/1648579.

Posted: 14 years ago by Ryan Riley

Async.Parallel2 and Async.Parallel3

Async.Parallel2 and Async.Parallel3, for running three Async's in parallel as thread pool tasks. Alternative versions given which use Async.Parallel under the hood.

Posted: 14 years ago by Don Syme

Simple sql command helper

Minimalist assistant to read data / execute database command. //I have question //How to Print the read value i.e.Customer.Id and Customer.Name //some sample regarding are available?? //Link For convering c# code to f# would be helpful-reply me at

Posted: 14 years ago by S. Kasperovich

Bananas in F#

A pattern for programming with generic folds (catamorphisms). Based on the classic "Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire" (1991) (Meijer, Fokkinga, Paterson).

Posted: 14 years ago by Nick Palladinos

Peano constructs

Here we define Peano arithmetic using F# abstract data types.

Posted: 14 years ago by Daniil

Async.Sleep with immediate cancellation

Implementation of Async.Sleep in f# 2.0 doesn't allow break it execution until the time elapsed. Here is the alternate implementation which support immediate cancellation. According to discussion http://stackoverflow.com/questions/9041491/is-there-any-reason-why-async-sleep-can-not-be-canceled-immediately .

Posted: 14 years ago by Andrei Kolomentsev

Peter Henderson's picture language from SICP

An implementation of (part of) Peter Henderson's picture language from the SICP book.

Posted: 14 years ago by Jonas Avelin

Auto-completion in any winforms text box

The standard windows.forms text box supports auto-completion, but only for single-line text boxes. The code below can be used to add auto-completion against a fixed set of words to any text box that inherits from TextBoxBase.

Posted: 14 years ago by Johann Deneux

Curve difference by sum-of-squares

An operator to compare two curves by the sum-of-squares-of-differences method.

Posted: 14 years ago by Kit Eason

Discrete Fréchet Distance

Compute the Discrete Fréchet Distance between two arrays (which may be of different lengths). Based on the 1994 algorithm by Thomas Eiter and Heikki Mannila. Not extensively tested, so use at your peril! (This version with some small fixes.)

Posted: 14 years ago by Kit Eason

Ninety-Nine F# Problems - Problems 1 - 10 - Lists

These are F# solutions of Ninety-Nine Haskell Problems which are themselves translations of Ninety-Nine Lisp Problems and Ninety-Nine Prolog Problems. The solutions are hidden so you can try to solve them yourself.

Posted: 14 years ago by Cesar Mendoza

Ninety-Nine F# Problems - Problems 11 - 20 - List, continued]

These are F# solutions of Ninety-Nine Haskell Problems which are themselves translations of Ninety-Nine Lisp Problems and Ninety-Nine Prolog Problems. The solutions are hidden so you can try to solve them yourself.

Posted: 14 years ago by Cesar Mendoza

Ninety-Nine F# Problems - Problems 21 - 28 - Lists again

These are F# solutions of Ninety-Nine Haskell Problems which are themselves translations of Ninety-Nine Lisp Problems and Ninety-Nine Prolog Problems. The solutions are hidden so you can try to solve them yourself.

Posted: 14 years ago by Cesar Mendoza

Ninety-Nine F# Problems - Problems 31 - 41 - Arithmetic]

These are F# solutions of Ninety-Nine Haskell Problems which are themselves translations of Ninety-Nine Lisp Problems and Ninety-Nine Prolog Problems. The solutions are hidden so you can try to solve them yourself.

Posted: 14 years ago by Cesar Mendoza

Ninety-Nine F# Problems - Problems 46 - 50 - Logic and Codes

These are F# solutions of Ninety-Nine Haskell Problems which are themselves translations of Ninety-Nine Lisp Problems and Ninety-Nine Prolog Problems. The solutions are hidden so you can try to solve them yourself.

Posted: 14 years ago by Cesar Mendoza

Ninety-Nine F# Problems - Problems 54 - 60 - Binary trees

These are F# solutions of Ninety-Nine Haskell Problems which are themselves translations of Ninety-Nine Lisp Problems and Ninety-Nine Prolog Problems. The solutions are hidden so you can try to solve them yourself.

Posted: 14 years ago by Cesar Mendoza

Ninety-Nine F# Problems - Problems 61 - 69 - Binary trees

These are F# solutions of Ninety-Nine Haskell Problems which are themselves translations of Ninety-Nine Lisp Problems and Ninety-Nine Prolog Problems. The solutions are hidden so you can try to solve them yourself.

Posted: 14 years ago by Cesar Mendoza

Ninety-Nine F# Problems - Problems 70 - 73 - Multiway Trees

These are F# solutions of Ninety-Nine Haskell Problems which are themselves translations of Ninety-Nine Lisp Problems and Ninety-Nine Prolog Problems. The solutions are hidden so you can try to solve them yourself.

Posted: 14 years ago by Cesar Mendoza

Ninety-Nine F# Problems - Problems 80 - 89 - Graphs

These are F# solutions of Ninety-Nine Haskell Problems which are themselves translations of Ninety-Nine Lisp Problems and Ninety-Nine Prolog Problems. The solutions are hidden so you can try to solve them yourself.

Posted: 14 years ago by Cesar Mendoza

Ninety-Nine F# Problems - Problems 90 - 94 - Miscellaneous problems]

These are F# solutions of Ninety-Nine Haskell Problems which are themselves translations of Ninety-Nine Lisp Problems and Ninety-Nine Prolog Problems. The solutions are hidden so you can try to solve them yourself.

Posted: 14 years ago by Cesar Mendoza

Ninety-Nine F# Problems - Problems 95 - 99 - Miscellaneous problems]

These are F# solutions of Ninety-Nine Haskell Problems which are themselves translations of Ninety-Nine Lisp Problems and Ninety-Nine Prolog Problems. The solutions are hidden so you can try to solve them yourself.

Posted: 14 years ago by Cesar Mendoza

md5 cracking

Simple md5 cracker, example of using permutations and pseq rather than cracking.

Posted: 14 years ago by david klein

Frequency Tables, Shift Cipher

Solving Ceasar shfit with frequency tables.

Posted: 14 years ago by David Klein

Stackoverflow API script

A script that consumes the Stackoverflow API in a dynamic fashion

Posted: 14 years ago by Mauricio Scheffer

Matrix

Matrix

Posted: 14 years ago by Matrix

TicTacToe(Joinads Example)

TicTacToe game simulator implemented by using Joinads(http://tomasp.net/blog/joinads-async-prog.aspx). Game logic in this snippet was simplified so nicely by using Joinads. You can run this snippet on Try Joinads (http://tryjoinads.org/).

Posted: 14 years ago by nagat01

Save attachments from exchange inbox

Save the attachments of the first 10 mails to disk

Posted: 14 years ago by Joeri Belis

Team Foundation Server: Check Out a file

Team Foundation Server (TFS): Check Out a file.

Posted: 14 years ago by Tuomas Hietanen

read CSV with .net FileHelpers library

example to use the open source .net FileHelpers library to read a CSV ( http://filehelpers.sourceforge.net/ ). csv example with no exception error field1,field2,field3 123,123,aaa 456,123,aaa example with exception where the functions returns an empty array field1,field2,field3 123,aaa,aaa 456,123,aaa

Posted: 14 years ago by Joeri Belis

WrapPanel

Positions child elements in sequential position from left to right, breaking content to the next line at the edge of the containing box. Tryable at http://tryfsharp.org

Posted: 14 years ago by Phillip Trelford

Factoring out FSharpChart

Using FSharpChart control. Just call Charting.Plot() to chart series or collections of series. No need to create forms, etc.

Posted: 14 years ago by Boris Kogan

Dining philosophers (Joinads)

A simple and declarative solution based on Joinads.

Posted: 14 years ago by Nick Palladinos

Transform a sequence into a sequence-of-sequences

Take a sequence and make it into a sequence of sequences, where the inner sequences are of a specified length. (The last inner sequence may be shorter.) Useful, for instance, for rending sequences into two-way HTML grids.

Posted: 14 years ago by Kit Eason

Take a sample of a sequence

Take a sample of a specified length from a sequence. The sample is guaranteed to be of the requested size (unless there are too few elements in the original sequence). Sample items will be taken at equal intervals. (This version with some simplifications and tidy-ups.)

Posted: 14 years ago by Kit Eason

csproj-file parsing with Linq2Xml - part 2

This program reads all *.csproj-files from a path and then uses Linq2Xml to show or modify data about the projects. This should be a good template for scripts to manage tons of c#-project files. F# and LINQ-to-XML is very powerful combination.

Posted: 14 years ago by Tuomas Hietanen

WPF Command in F#

demonstrate how to use object expression to create a WPF/Silverlight command.

Posted: 14 years ago by Tao Liu

n-gram algorithm

Simple n-gram algorithm implementation

Posted: 14 years ago by Daniil Frumin

Private Implementation Inheritance without boilerplate

How to avoid delegation boilerplate in inhertance heavy OOP code while maintaining proper accessibility like seen here https://github.com/fsharp/fsharp/blob/master/src/fsharp/FSharp.Core/seq.fs#L82 and mentioned in Expert F# 2.0 "Using Partially Implemented Types via Implementation Inheritance " Uses auto-properties that only work with F# 3.0

Posted: 14 years ago by Associat0r

Turing machine interpreter

A Turing machine emulator. An infinite tape is simulated by a zipper, instructions are stored in the binary tree for faster lookup.

Posted: 14 years ago by Daniil

Polymorphic Maybe monad with default value.

Polymorphic (via generics) Maybe monad/computational expression with default value + Zipper

Posted: 14 years ago by Daniil

How many words can you spell on a calculator?

We all know about BOOBIES - but how many other dictionary words can you spell upside-down on a calculator?

Posted: 14 years ago by Kit Eason

Langton's ant

Implementation of Langton's ant route.. Takes first 1000 steps and returns only black fields.

Posted: 14 years ago by stejcz

Langton's ant // OOP :)

Implementation of Langton's ant route.. Takes first 1000 steps and returns only black fields.

Posted: 14 years ago by stejcz

unit test in VS11 beta

Demo F# unit test in VS11 beta. In VS 2010 unit testing requires a hack whereby you add a c# test project to your solution and add to that project a linked item to the DLL of the F# project with the test methods.

Posted: 14 years ago by Jack Fox

Lab3

Lab3

Posted: 14 years ago by Mikhail Dubov

Remove duplicate list elements

I have been working on my "Functional Style" and like to think that I have improved a bit. The list order is no longer maintained in this snippet; however as the order change is simply a feature of the foldBack process the reversal of input and reversal of output is a reliable (and efficient?) fix.

Posted: 14 years ago by visProcessEngg

A simple sieve

A simple implementation for the sieve of Eratosthenes.

Posted: 14 years ago by Gab_km

MbUnit DSL

DSL for functional style, HUnit-like testing with MbUnit.

Posted: 14 years ago by Mauricio Scheffer

How many lines of code does your project contain?

A simple way to count the non-blank, non-comment lines in your code. (Doesn't use project files to identify source; just a wildcard. Doesn't support multi-line comments.)

Posted: 14 years ago by Kit Eason

Powerset

Powerset function followed by with tiny sample.

Posted: 14 years ago by notostraca

Haskell to F# (some operators)

Just toying around with making my F# code a little smaller with Haskell operators

Posted: 14 years ago by Cameron Frederick

Poll a file until it is quiet

One of the problems with using FileSystemWatcher to detect new files and process them is that it tells you when the file starts being created, not when it finishes. Use this little function to poll the file until it stops being written to.

Posted: 14 years ago by Kit Eason

Sierpinski triangle, WPF

Draws a Sierpinski triangle using WPF

Posted: 14 years ago by Mathias Brandewinder

Exception Retry Computation Expression

Retry monad: chaining functions together, retrying each one if exceptions are thrown, until the first time a function can no longer be retried

Posted: 14 years ago by Boris Kogan

EditDistance

Computes the Minimum Edit Distance or the Levenshtein Distance between two words

Posted: 14 years ago by Gustavo Guerra

Lazy Xml

A Lazy Xml structure for processing large xml documents.

Posted: 14 years ago by Nick Palladinos

Lightweight syntax for creating JSon objects using Newtonsoft's Json.Net

There's an easy way to create JSon objects using Newtonsoft's Json.Net. The common problem with Json.Net is that there's usualy a lot of overhead when creating Json with it as there're a lot of 'new', parentheses, nested objects when we don't need them. And it becomes annoying quite fast. DU Json and toJson function allow to create Json tree and convert it to Json.Net JObject hierarchy. On the examples the usage of lightweight syntax doesn't give a lot of win but it will be more clearer when it come to more complicated objects.

Posted: 14 years ago by Dmitry Lobanov

HTML File Type

Discriminated unions to represent a HTML file.(not completely)

Posted: 14 years ago by Gab_km

What word is most like the word "turtle"?

A while ago I posted a snippet to calculate the 'Discrete Fréchet Distance' between two curves. If we treat a word as a 'curve' by giving each letter an index (with similar-sounding letters having closer indices) we can compare words by the Fréchet distance between them! An alternative to edit-distance...

Posted: 14 years ago by Kit Eason

Expression parsing with monads

Compositional expression parsing with monads. https://bitbucket.org/ZachBray/parsad

Posted: 14 years ago by Zach Bray

Levenshtein distance

Computes Levenshtein (min edit) distance between two strings http://en.wikipedia.org/wiki/Levenstein_Distance

Posted: 14 years ago by Lakret

reflection

reflection, not exactly efficient but good canvas to start exploring

Posted: 14 years ago by David Klein

In-place parallel QuickSort

It's fairly straightforward in-place QuickSort implementation which uses ThreadPool for parallelization. Still slower than library function Array.sortInPlace, though.

Posted: 14 years ago by Lakret

Single Life Annuity

A single life annuity function in F# including supporting functions such as probability of survival, pure endowment and discounted interest rate calculation. I've gone for (what I believe to be) a more functional approach than the previous version. I've cobbled together a sort of computation expression type to facilitate transforming the AgeVector. The code below contains test data and sample tests so that you can see how it should be used. If you have any queries or advice about this please contact me on twitter @CdeRoiste . Have fun!

Posted: 14 years ago by Kevin Roche

JSON parsing with monads

JSON parsing with monads. See also "Expression parsing with monads" (http://fssnip.net/bi). Author URL: http://www.zbray.com

Posted: 14 years ago by Zach Bray

Async HTTP server

Creating an asynchronous HTTP Server in F#.

Posted: 14 years ago by Julian Kay

Bayesian Monte Carlo of Let's Make a Deal

This code illustrates Bayes' Theorem in action on the Let's Make a Deal problem (aka Monty Hall Problem), which several authors have used to illustrate Bayes' Theorem. (It's easy to search the internet for further explanation.) Run with the audit option to audit up to the first 100 games. Running without audit is faster and can simulate a couple billion games.

Posted: 13 years ago by Jack Fox

Monotone Chain Convex Hull Algorithm

Andrew's Monotone Chain Convex Hull algorithm: given points in 2 dimensions, determine their convex hull by constructing the upper and lower hull.

Posted: 13 years ago by Mathias Brandewinder

Monadic transactions for Clojure-style atoms

This is a simple implementation of a monadic transaction builder for Clojure-style atoms. Based on original code by Nick Palladinos.

Posted: 13 years ago by Eirik Tsarpalis

Expanding quotations

The snippet implements a function "expand" that takes a quotation and performs two operations. It replaces all calls to methods marked with ReflectedDefinition with the body of the method and it simplifies all expressions that can be reduced in call-by-name style (let binding & application of lambda).

Posted: 13 years ago by Tomas Petricek

Building Strings

When sprintf and String.concat is either too slow or not really what is needed, one can use System.Text.StringBuilder. This snippet makes working with StringBuilder much more convenient and the resulting code more succint.

Posted: 13 years ago by Bent Rasmussen

Tesco in 70 lines of code

Domain model for the Tesco checkout implemented in F# using discriminated unions (in 20 lines of code) and console-based user interface for scanning products and calculating the total price.

Posted: 13 years ago by Tomas Petricek

Finalizing Tesco purchase

The sample shows two different reprezentations of Tesco checkout. The first one stores scanned items - as a list of either purchase or cancel items - and the second stores final bill with product and total quantity. The snippet implements transformation that corresponds to finalizing the purchase.

Posted: 13 years ago by Tomas Petricek

Simple NumericLiteral example

You can use numeric literals, constant expressions and operator overloading to make your own arithmetics. Useful in DSL languages. With NumericLiterals, you can use any of Q, R, Z, I, N, G. Basic syntax: [Number][Letter] will forward the call to the type NumericLiteral[Letter] to FromInt32 [Number] (or FromInt64 or FromString...)

Posted: 13 years ago by Tuomas Hietanen

F# 3.0 - EntityFramework Type Provider usage with Northwind DB

A small sample how to use F# 3.0 Entity Framework (EF) Type Provider. Visual Studio 11 Beta (and Northwind sample database) needed.

Posted: 13 years ago by Tuomas Hietanen

Statistical functions

Some basic statistics functions in F#, including erfc, erfcinv, normcdf, normpdf, norminv, additiveCorrection, multiplicativeCorrection, a Box-Mueller RandomSampler and a unitized type for a Gaussian distribution. Based on Ralf Herbrich's samples at http://blogs.technet.com/b/apg/archive/2008/04/05/trueskill-through-time.aspx

Posted: 13 years ago by Robert Herman

Simple builder example: Nullable

Simple Computational expressions / monad / builder -example, using .NET Nullable as demo.

Posted: 13 years ago by Tuomas Hietanen

F# Koan Setup

Setup Code for Online F# Koans

Posted: 13 years ago by Chris Marinos

F# Koans

An online version of the F# Koans for use with tryfsharp

Posted: 13 years ago by Chris Marinos

DSL for Financial Contracts

Simple domain-specific language for modeling of financial contracts.

Posted: 13 years ago by Tomas Petricek

DSL for Price Patterns (Setup)

Domain-specific language for detecting patterns in stock prices. Run using try F#.

Posted: 13 years ago by Tomas Petricek

DSL for Price Patterns (Demo)

Examples that use domain-specific langauge for detecting price patterns. To run the sample, load the previous snippet in TryF#. It opens the sample automatically.

Posted: 13 years ago by Tomas Petricek

Fun with Ping and Pong

Yet another ping pong sample with agents.

Posted: 13 years ago by Ryan Riley

Ping and Pong go Chunking Along

Parameterizing pong allows us to do even more fun things. Here we use a few message types to allow stateful consumption of data sent by ping to its pongs.

Posted: 13 years ago by Ryan Riley

Inverse Fizz Buzz

Inspired by this post: http://www.jasq.org/2/post/2012/05/inverse-fizzbuzz.html (fixed small typo, plus trying out this editing fssnip for the first time)

Posted: 13 years ago by Tony Abell

Yet another Fibonacci

In mathematics, the Fibonacci numbers or Fibonacci series or Fibonacci sequence are the numbers in the following integer sequence: [0; 1; 1; 2; 3; 5; 8; 13; 21; 34; 55; 89; 144; 233; 377; ...] http://en.wikipedia.org/wiki/Fibonacci_number

Posted: 13 years ago by Tuomas Hietanen

Scrap Your Boilerplate (with class)

A typecast free experiment in Generic Programming. Inspired by "Scrap Your Boilerplate (with class)".

Posted: 13 years ago by Nick Palladinos

Async Primitives

A set of Async primitives as described by Dave Thomas [1] (and derived from Stephen Toub [2]). [1] http://moiraesoftware.com/blog/2012/04/22/back-to-the-primitive-ii/ [2] http://blogs.msdn.com/b/pfxteam/archive/2012/02/11/10266923.aspx

Posted: 13 years ago by Ryan Riley

How to check whether an F# function/method has been initialized

Sometimes, we may run into this kind of situation that we want to check if the given method/function has been initialized. We all know this is fairly easy in C#, since we can use delegate to invoke the function , then verify if the value of delegate is null. But in F# , delegate is rarely needed because F# can treat a function as a value, without the need for any wrapper. So , here is an easy way to solve this problem.

Posted: 13 years ago by ZackZhou

Speech Stackoverflow article automatically

This snippet automatically speeches text of question,answers and comments in a Stackoverflow article. It requires HtmlAgilityPack(available from Nuget package manager).(Attention: You need reset F# interactive to stop the speech)

Posted: 13 years ago by nagat01

Traits, Mixins and Aspect-Oriented Programming in F#

A compositional type system built using generics and monads in F#. It is only a very limited, _toy_ project exploring traits, mixins and aspect-oriented programming.

Posted: 13 years ago by Zach Bray

tryNth

Computes the nth value of a sequence if the nth value is past the length of the sequence then None is returned else some

Posted: 13 years ago by Colin Bull

F# yet another Interop example

Quick demo of using F# to interop with a native C library. C Library has not been checked for algorithm correctness (but works exactly as the origional).

Posted: 13 years ago by David Klein

Concurrent Memoization

Memoize a function in a thread-safe manner. Added a wrapper around the value a. The idea being, that a unit value is represented as a null value at run time and as such the concurrent dictionary throws.

Posted: 13 years ago by Matt Collins

How to Serialize Record, Discriminated Union and Tuple in Azure?

Here is the implementation of the three types in WCF Azure, and a sample using WCF in worker role, a WPF test project to invoke the three kinds of data type from worker role. Link is http://fsharp3sample.codeplex.com/SourceControl/changeset/view/13876

Posted: 13 years ago by AndrewXue

Translating quotations to LINQ

A sample that translates simple F# quotations (method calls, property getters) to stnadard C# LINQ expression trees.

Posted: 13 years ago by Tomas Petricek

Using AutoMapper with F#

This wrapper will handle translating F# quotations into LINQ expressions that AutoMapper can use, enabling AutoMapper to be configured from F# code. You must reference AutoMapper and FSharp.PowerPack.Linq, or include Linq.fsi and Linq.fs from the PowerPack into your project.

Posted: 13 years ago by Joel Mueller

Berzerk

Zombie state machine code sample. Use arrow keys to move humanoid. Robots activate when in range of humanoids. Try it out in the browser with TryFSharp.org.

Posted: 13 years ago by Phillip Trelford

Minesweeper Kata

Solution to Minesweeper Kata challenge at Goto Copenhagen 2012 conference "Programming with the Stars" track.

Posted: 13 years ago by Phillip Trelford

Minesweeper Kata 2

Solution to Minesweeper Kata second challenge at Goto Copenhagen 2012 conference "Programming with the Stars" track. Runnable at http://tryfsharp.org.

Posted: 13 years ago by Phillip Trelford

Get Assemblies from NuGet

Given a NuGet package name, this code will download the package, extract it to a temp directory, and return a sequence of FileInfo objects representing assemblies from that package, with a preference for .NET 4.5 and 4.0 assemblies, if present. Requires the "DotNetZip" package.

Posted: 13 years ago by Joel Mueller

Minesweeper Tweet

Minesweeper computation Kata as a tweet (140 characters) not counting code to open namespace and to prepare field as a 2D array.

Posted: 13 years ago by Phillip Trelford

Codomains through Reflection

Any type signature has the form of a curried chain T0 -> T1 -> .... -> Tn, where Tn is not a function type. The codomain of a type is precisely Tn. This is a simple implementation that uses reflection to determine the codomain for arbitrary types.

Posted: 13 years ago by Eirik Tsarpalis

Eurovision - Some(points)

The Eurovision final scoring system using records and some higher order functions. (Results are fictional - no-one seems to publish the full voting live online.)

Posted: 13 years ago by Kit Eason

Simple Markov chains

Small example illustrating how to use Arrays and Sequences to simulate simple Markov chain and evaluate their stationary distribution.

Posted: 13 years ago by Mathias Brandewinder

Brainfuck

A minimal Brainfuck Interpreter (<30 lines) running Hello World!

Posted: 13 years ago by Phillip Trelford

MailboxProcessor with exception handling

An extension of MailboxProcessor that catches all unhandled exceptions (in the body of the mailbox processor) and reports them using an event. Otherwise, the public interface is the same as for MailboxProcessor.

Posted: 13 years ago by Tomas Petricek

Merge two sorted lists by a key

Merges two sorted lists by a key.

Posted: 13 years ago by Simon Weijgers

Befunge

Minimal Befunge-93 interpreter.

Posted: 13 years ago by Phillip Trelford

Asynchronous Entity Framework Query

Entity Framework doesn't currently support async operations, but as long as the underlying provider is System.Data.SqlClient we can make it work.

Posted: 13 years ago by Joel Mueller

Processing Prices & Charting (Setup)

Implements simple library for downloading Yahoo stock prices and displaying charts in Try F#. This snippet loads another one with examples.

Posted: 13 years ago by Tomas Petricek

Processing Prices & Charting (Demo)

Sample code using a simple library for downloading Yahoo stock prices. The demo shows how to process sequences and so on (to run this, load & run previous snippet).

Posted: 13 years ago by Tomas Petricek

Yet Another Financial Contracts (Setup)

Yet another tutorial based on the DSL for modelling financial contracts. This part just loads library for downloading prices & loads another snippet. Designed to run in Try F#.

Posted: 13 years ago by Tomas Petricek

Yet Another Financial Contracts (Demo)

Yet another tutorial based on the DSL for modelling financial contracts. This is a walkthrough with examples and tasks that is loaded by the previous 'Setup' snippet. Designed to run in Try F#.

Posted: 13 years ago by Tomas Petricek

Calculate PI using Monte Carlo

Simple walkthrough that demonstrates how to estimate the value of PI using Monte Carlo simulation. A few holes need to be filled in and then you can run & parallelize the sample!

Posted: 13 years ago by Tomas Petricek

ad hoc tagged sets

Given an ordered set S and an arbitrary set T, any function T -> S induces a natural ordering on T. We use this idea and the infrastructure provided by Tagged.Set to quickly construct sets over arbitrary types with custom comparison rules.

Posted: 13 years ago by Eirik Tsarpalis

Fsi with PropertyGrid

This is a small fsx script that views the current 'it' value of Fsi in a PropertyGrid. How to use it: - Copy the source code into a file called FsiProp.fsx and place it next to Fsi.exe - Start Fsi.exe with --load:FsiProp.fsx - Maximize Fsi.exe for full enjoyment. (I placed the PropertyGrid Form on the right screen half.) (Make a .lnk to this if you find it useful, there set Maximize on Fsi.exe) Take FsEye if you want to see what's in 'it' in detail. But you cannot change it there. ;)

Posted: 13 years ago by Karsten P.

crc32

have a project to write some basics from gzip, needed crc32, seems fast enough, fixed one bug!

Posted: 13 years ago by David Klein

Skip that is safe when not enough lines

A version of Seq.skip which doesn't throw an exception if there are fewer lines in the sequence than you have asked to skip.

Posted: 13 years ago by Kit Eason

Here's another fine fractal you've gotten me into

An ASCII Mandelbrot visualisation. (Suggested by a tweet from Jon Harrop, but any bugs are mine.)

Posted: 13 years ago by Kit Eason

Generates punched card image

This snippet generates a punched card image from a text. It punches holes in the places where a letter would be written and you can use it to generate jokes such as this one: http://bit.ly/M2oqOw

Posted: 13 years ago by Tomas Petricek

Reporting events from agents

This snippet shows different options for reporting events from an F# agent. The options include triggering the event directly, using a thread pool or using a specified synchronization context.

Posted: 13 years ago by Tomas Petricek

Monadic state lifting combinators

The generic model for stateful computation (S -> S x R) provides a convenient mechanism of threading stateful computation results since the functor λR . S -> S x R is monadic. But what happens if we want to thread state itself? Well, the mapping λS. S -> S x R is not even functorial! But it turns out it can become so with a bit of trickery. This snippet demonstrates a way to lift, project or inject stateful computations into ambient state monads.

Posted: 13 years ago by Eirik Tsarpalis

Heatmap Color Generating Function

Function to generate color values to reflect the relative intensity of numeric values in a range. --- Fixed edge case of when max=min

Posted: 13 years ago by Faisal Waris

Eliminating type annotations with single case Active Patterns

When passing objects as arguments to F# functions, it is almost certain that a type annotation will be required. This may generate long and noisy code at times, but thankfully we can use active patterns to mitigate this annoyance.

Posted: 13 years ago by Eirik Tsarpalis

AI

Tiny robot simulate, it's available to run on tryfs.net (but not on iPad).

Posted: 13 years ago by a_a

IEnumerator

seq to IEnumerator and IEnumerable

Posted: 13 years ago by Graham Spiers

Y(n) Polyvariadic fixpoint

Encoding mutually-recursive functions with a Polyvariadic fixpoint combinator.

Posted: 13 years ago by Nick Palladinos

Game of Life

Simple implementation of Conway's Game of Life for the TryF# web site.

Posted: 13 years ago by Tomas Petricek

A Generic Pretty-Printer for Record types

The following is an implementation of a general-purpose pretty printer for tables. Its generality is achieved by passing an upcast rule to an untyped record type as argument.

Posted: 13 years ago by Eirik Tsarpalis

Simple single-server queue simulation

Simulation and performance measurement of a single-server queue with various arrival and processing rates configurations. More comments on this can be found at http://www.clear-lines.com/blog/post/Simulating-a-simple-Queue-in-FSharp.aspx

Posted: 13 years ago by Mathias Brandewinder

A Small DSL for Building Graphs

A small DSL for graph building by combining paths. It's just a set of edges under the hood, so no need to worry about duplication causing problems. This is part of a larger project I'm calling edgy.

Posted: 13 years ago by Rick Minerich

A Slightly Larger DSL for Building Weighted Graphs

A small DSL for graph building by combining weighted paths. It's just a map of edges to weights under the hood, so no need to worry about duplication causing problems. This is part of a larger project I'm calling edgy.

Posted: 13 years ago by Rick Minerich

PacMan

Single level retro game playable inside TryFsharp using the cursor keys.

Posted: 13 years ago by Phillip Trelford

Easy string approvals testing

This simple tool is useful for string based approvals testing. When tests are run in DEBUG mode, the code opens the p4merge diff tool (change it to point to yours) to clearly show the differences between the expected and actual strings. The actual, or received string is copied, in escaped form, to the clipboard so that it can be easily pasted into the associated test to approve the changes if appropriate. When a debugger isn't attached, this tool reverts to using a standard Assert so that it won't attempt to open a diff viewer when executed on a CI server.

Posted: 13 years ago by Russell Politzky

HLists, Peano & Type-level computations

An experiment on type-level computations.

Posted: 13 years ago by Nick Palladinos

Asynchronous cancellation of a workflow

The snippet implements Async.StartCancellable method that can be used to start a given workflow and then cancel it. The cancellation of the workflow is done asynchronously, which means that the caller will wait until the workflow is actually cancelled.

Posted: 13 years ago by Tomas Petricek

A Computation Expression wrapper for StringBuilder

A bit of syntax eye candy for your string building code.

Posted: 13 years ago by Eirik Tsarpalis

Game of Life

Conway's Game of Life example at F#unctional Londoners July 2012 meetup.

Posted: 13 years ago by Phillip Trelford

Rename JSON properties

Rename JSON property names by reconstructing JSON object.

Posted: 13 years ago by Dmitry Lobanov

Earth Similarity Index

Calculating the Earth Similarity Index of a planet. http://phl.upr.edu/projects/earth-similarity-index-esi

Posted: 13 years ago by Kit Eason

Euler 28

Implementation of Project Euler question 28.

Posted: 13 years ago by Bret Colloff

Parametric Dependency Injection

This is a simple IoC implementation that allows registration with optional parametrization.

Posted: 13 years ago by Eirik Tsarpalis

Global Events

The following is a simplistic implementation of global events, which is the precise dual of the dependency injection implementation found in http://fssnip.net/dg. This is just a proof of concept, unwise to use in real life.

Posted: 13 years ago by Eirik Tsarpalis

Checking for perfect squares

An implementation of John D. Cook's algorithm for fast-finding perfect squares: http://www.johndcook.com/blog/2008/11/17/fast-way-to-test-whether-a-number-is-a-square/

Posted: 13 years ago by Kit Eason

Raising arbitrary exceptions with failwith-style syntax

failwith/failwithf are a useful operators, but they only raise exceptions of type SystemException. Here's a simple way to generalize them.

Posted: 13 years ago by Eirik Tsarpalis

Automatic install of Nuget with a script

When versioning a solution, I like to just version the packages.config and not the binaries themselves. that means upon checkout, one has to install the referenced Nugets. This is the purpose of this script. [For some reason you have to press 'enter' between commands..]

Posted: 13 years ago by Nicolas2

playing with dns + async composition

just some snippets ive been using to play around with async + DNS, nothing production, updated: ipsOfDomain and domainOfIp now both return string array

Posted: 13 years ago by david klein

Unlambda

A minimal interpreter for David Madore's crazy-esoteric programming language.

Posted: 13 years ago by Nick Palladinos

FSI dependencies <-> VS dependencies

This script generates a file named __project.fsx, for each proejct which can be #load "__project.fsx" in script intending to use the same dependency graph as the code in VS a file named __solmerged.fsx, at the solution root which can be #load "__solmerged.fsx" in script intending to use the same dependency graph as the code in VS In both cases, this enforce that : **a script compiling in VS should run from FSI **

Posted: 13 years ago by nicolas2

Map for ObservableCollection

The snippet implements 'map' and 'init' functions for the 'ObservableCollection' type. These are similar to well-known functions for sequences, but 'map' works in an incremental fashion. When the source collection changes, the resulting collection is updated.

Posted: 13 years ago by Tomas Petricek

Simple exception analysis

A simple script to list the exceptions that can be thrown during the method invocation (both caught and uncaught).

Posted: 13 years ago by Natallie Baikevich

Affine Cipher

simple affineCipher translated from https://github.com/asweigart/codebreaker/blob/master/affineCipher.py not sure if actually correct. I updated the below to make it easier to understand because I was bored, made some more changes, now pass in lambda as function to pxn instead of individual functions, as suggested by rwbarton for my haskell version.

Posted: 13 years ago by david klein

Target VS2012 and VS2010

This is a simple script which, recursively walking a folder structure, updates .fsproj files so they may be run in VS2012 or VS2010. This should be run *after* VS2012 has converted a particular solution. Also, I didn't really test it too much, but it worked for me. So there's your disclaimer.

Posted: 13 years ago by Paulmichael Blasucci

fast Fourier transforms (FFT)

Naive "school-book" implimentation.

Posted: 13 years ago by Kaspar

Using Theories with FSUnit, XUnit and NUnit

Here's how to use the [] and [] attributes to throw a set of data at a single test.

Posted: 13 years ago by Kit Eason

Shrink your ISerializable boilerplate

A pair of extension methods for SerializationInfo that make custom ISerializable implementations much more straightforward to write.

Posted: 13 years ago by Eirik Tsarpalis

Partition a list

The snippet implements 'List.partitionWhile' which behaves as a combination of 'Seq.takeWhile' and 'Seq.skipWhile': It splits the list into a part containing elements from the beginning of a list that match a given predicate and remaining elements.

Posted: 13 years ago by Tomas Petricek

DSL for detecting patterns in 2D

A simple domain specific langauge (DSL) that can be used to specify and recognize patterrns in 2D arrays. A pattern is defined by composing primitive checks, rotating and translating patterns. See also: http://t.co/6Poty4FL

Posted: 13 years ago by Tomas Petricek

BatchedDeque

A batched Deque

Posted: 13 years ago by Nicolas2

Monadic Trampoline

A monadic trampoline for stack-overflow free programming.

Posted: 13 years ago by Nick Palladinos

NUnit assertions with pattern matching

A simple utility that allows making assertions using potentially complex pattern matches.

Posted: 13 years ago by Eirik Tsarpalis

IDisposable in a Type

This sample illustrates how to use an IDisposable inside an object, as well as a simple use of object expression

Posted: 13 years ago by nicolas2

Async.Choice

A simple extension method for asynchronous non-deterministic computations.

Posted: 13 years ago by Nick Palladinos

An implementation of Async.Choice

This is an implementation of the Async.Choice combinator that composes a sequence of workflows into one whose result is that of the first workflow that returns a *valid* result. You can think of it as a nondeterministic version of (Seq.tryPick id). This implementation draws ideas from Tomas Petricek's choice implementation in http://fssnip.net/6D. UPDATE (11/2015): Following the discussion in https://fslang.uservoice.com/forums/245727-f-language/suggestions/10575069-add-async-choice-to-fsharp-core I have updated the snippet.

Posted: 13 years ago by Eirik Tsarpalis

Faster exception handling with Async.Raise

Code by me and Nick Palladinos.

Posted: 13 years ago by Eirik Tsarpalis

Slicing for Math.Net vectors and matrices

This snippet adds the 'GetSlice' operation to Math.Net vector and matrix types. This makes it possible to get sub-vectors and sub-matrices using the convenient syntax (For vectors 'vect.[start .. end]` or 'vect.[start ..]' and for matrices 'mat.[r1 .. r2, c1 .. c2]' and similar).

Posted: 13 years ago by Tomas Petricek

Square root for integral types

Square root for integral types

Posted: 13 years ago by ildjarn

CRC-32 implementation

An implementation of a CRC-32 algorithm, as described in RFC-1952 "GZIP file format specification version 4.3"

Posted: 13 years ago by Henrik Ravn

Code Kata: Writing Markdown parser

Sample for Coding Kata

Posted: 13 years ago by Tomas Petricek

WinAPI IniFile F# Interface

work with ini file with WritePrivateProfileString, GetPrivateProfileString easy as pie

Posted: 13 years ago by nCdy

Twitter OAuth

Generates the value string for the "Authorization:" header given Twitter application/user keys and tokens and the parameters for the request being authorized.

Posted: 13 years ago by Faisal Waris

Twitter OAuth

Generates the value string for the "Authorization:" header given Twitter application/user keys and tokens and the parameters for the request being authorized. Slightly updated to allow additional oauth parameters to be included in the header. This version handles the case when the token is not yet available, i.e. when you want to request a new token/token_secret pair.

Posted: 13 years ago by Faisal Waris

Phone number to words

Creates all possible mobile phone letter combinations from a number.

Posted: 13 years ago by Phillip Trelford

Hashtable

Readonly generic Hashtable class implementation example.

Posted: 13 years ago by Phillip Trelford

Bulk copy into table with IDENTITY column

Want to do a SqlBulkCopy into a table which has an IDENTITY column? If your DataTable has the same columns as the target (but without the ID), you can map the columns numerically, skipping the first target column.

Posted: 13 years ago by Kit Eason

Successive fold functions

fold by applying a list of function to a list of arg, last one behaving as usual

Posted: 13 years ago by nicolas2

Another successive enumeration

Applying functions on the n first elements

Posted: 13 years ago by Nicolas2

A Simple Implementation of Lazy Type

A Simple Implementation of Lazy Type.

Posted: 13 years ago by Joel Huang

Appending Two Lists Based on A Discriminated Union Type Using Continuation

Lists are pointers to the head of list. It can be defined by a discriminated union type. Using continuation can do a tail-recursion version of appending two lists.

Posted: 13 years ago by Joel Huang

FizzBuzz with Rule Engine

Inspired by http://dave.fayr.am/posts/2012-10-4-finding-fizzbuzz.html Rules are in a list of lambdas that can be easily modified. A pattern-matching recursive function applies them in the correct order.

Posted: 13 years ago by Richard Broida

FizzBuzz with Forward Composition

This version of FizzBuzz uses forward composition instead of recursive pattern matching (see http://fssnip.net/e7). All the rules, including the default case, are in a list of lambdas that can be easily modified. The function executeRules composes the list into a single rule and executes it.

Posted: 13 years ago by Richard Broida

Insertion Sort on List

A continuation function takes the result when it is computed. Here is an implementation of sorting on List via insertion.

Posted: 13 years ago by Joel Huang

Merge Sort on List

Merge Sort falls into 'Divide and Conquer' problem solving technique and it is a stable sorting. The worst case of running time is (nlogn). This implementation below follows the two abstract steps to achieve Merge Sort, i.e., * Recursively divide input list into two sub-lists. * Repeatedly merge the sub-lists.

Posted: 13 years ago by Joel Huang

Generic Latin Square generator

A type which generates a Latin Square - ie. an n x n array where no value is repeated in any one row or column. Useful in experimental design and some forms of testing. The argument is generic so you can generate a Latin Square of ints, floats, strings, dates, classes etc. (Needs some optimisation - this is a first cut!)

Posted: 13 years ago by Kit Eason

Apply Operators to Options

Simple function to apply operators to option types. Applies the operator to each value and returns a new option containing the result. Treats None as the operator's identity element (i.e., ignores it).

Posted: 13 years ago by Richard Broida

Option.map2

Simplification of 'Apply operators to Options' http://fssnip.net/ee using higher order functions. Should also be part of the Option module.

Posted: 13 years ago by @rojepp

Coding Kata: Score a Bowling Game

Score a Bowling game. The game is represented as a list of integers. A game of bowling consists of ten frames. In each frame, the bowler will have two chances to knock down as many pins as possible with his bowling ball. If a bowler is able to knock down all ten pins with the first ball, he is awarded a strike. If the bowler is able to knock down all 10 pins with the two balls of a frame, it is known as a spare. Bonus points are awarded for both of these, depending on what is scored in the next 2 balls (for a strike) or 1 ball (for a spare). If the bowler knocks down all 10 pins in the tenth frame, the bowler is allowed to throw 3 balls for that frame. This allows for a potential of 12 strikes in a single game, and a maximum score of 300 points, a perfect game.

Posted: 13 years ago by Cesar Mendoza

Get the memory address of Array in F#

It's not convenient to get the memory address of object in F#, and the following code will illustrate how to get the memory of given index item of an array:

Posted: 13 years ago by ZackZhou

Modify the value at given memory address by F#

It's not easy for F# programmer to deal with the unsafe code, here I tried to provide a small code snippet to demonstrate the issue.

Posted: 13 years ago by ZackZhou

Multi construct for class in F#

When we defined an F# class in explicit way, it's easy for new F# programmers to make this kind of mistakes when they define mult constructors: people will forget to initliza the class first before use it.

Posted: 13 years ago by ZackZhou

Define a static property for F# class

it's quite easy to define a modifiable static property in C# , but in F#,a defined static filed is required first when the class want to define a static property.

Posted: 13 years ago by ZackZhou

EnumerateDirectoryFilesInfo

the function returns entire files sequence for given root directory, including sub-directories.

Posted: 13 years ago by Michael Gringauz

Quotation type erasure

An implementation of the inverse of Expr.Cast<_>, with erasure happening at reflection level.

Posted: 13 years ago by Eirik Tsarpalis

Enumerable extraction in query expressions

Adds "enumerable extraction" support to query expressions

Posted: 13 years ago by kvb

Sum of Squares Monoid

This snippet defines a computation builder that sums the squares of float values. It includes Combine, Zero, Yield, Delay, and For operations.

Posted: 13 years ago by Joel Huang

Implementation of Immutable Stack

Immutable stack can be implemented via Discriminated Union Type with methods like Push and Pop. The following snippet is a simple version of it.

Posted: 13 years ago by Joel Huang

Split A Seq Into Chunks

This function splits a sequence into lists of length n until there is less than n elements then those are returned.

Posted: 13 years ago by Taha Hachana

Formal Concept Analysis

Formal Concept Analysis (FCA) is a method to determine cohesive groupings of functions and data structures, especially in program comprehension research. For example, consider an object set, O = {1,2,3,4,5,6,7,8,9,10}, and an attribute set, A = {composite,even,odd,prime,square}, we can build a lattice table that holds the relations between O and A.

Posted: 13 years ago by Joel Huang

Declarative validation

Simple combinator library to declarative validation.

Posted: 13 years ago by Kaspar

Pex4fun - Merging strings

A random pex4fun puzzle to write a snippet to merge two strings.

Posted: 13 years ago by Joel Huang

Porter Stemmer

An Implementation of the Porter Stemming Algorithm in F# for text analysis. Please see: http://tartarus.org/martin/PorterStemmer/

Posted: 13 years ago by Faisal Waris

Density of sparse matrix product

A quick exploration of the rather useless question "how does the density of the product of 2 sparse matrices look like?"

Posted: 13 years ago by Mathias Brandewinder

Fibonacci snippet implement with Continuation

Normally, when we implement Fibonacci sequence, we use recursive function, but it will encounter the overflow exception with the big data. Below is the Fibonacci snippet with continuation, and in this way, it won't encounter the overflow exception.

Posted: 13 years ago by Jeallyn Duan

Reversi Kata

Quick & dirty solution to Reversi kata: http://codingdojo.org/cgi-bin/wiki.pl?KataReversi

Posted: 13 years ago by Phillip Trelford

FsSql usage example

FsSql is originally here: https://github.com/mausch/FsSql and better sample is there too but I just want to share it.

Posted: 13 years ago by Ash Harley

Reversi Kata at ProgFsharp

The Official Solution.

Posted: 13 years ago by Nick

Undertone: First line of Baa baa black sheep

Playing with Undertone, using operators for terse tune definitions.

Posted: 13 years ago by Michael Newton

OData Type Provider to StackOverflow

References and type definition to open StackOverflow API over OData

Posted: 13 years ago by Phillip Trelford

Primes

Generates the Prime Number Sequence.

Posted: 13 years ago by AdamSpeight2008

An equilibrium list

An equilibrium index of this array is any integer P such that 0 ≤ P < N and the sum of elements of lower indices is equal to the sum of elements of higher indices. The following is an implementation of such equilibrium list (given the input is a list).

Posted: 13 years ago by Joel Huang

Joint Life Annuity

This Joint Life Annuity calculation relies on the objects and functions defined in Single Life Annuity. A joint life annuity calculates the present value of an annuity from current age to death of a member and another life (spouse). The implementation below uses the AgeVectorBuilder from the Single Life Annuity snippet in two examples: The first defines a simple Joint Life Annuity that assumes no age difference between the two lives. The second assumes an N year age difference. The samples both rely on a male mortality table (PMA92 (C=2003)) and a female mortality table (PFA92 (C=2003)) which are extracts of publicly available mortality tables (http://www.actuaries.org.uk/research-and-resources/documents/pma92-pensioners-males-amounts).

Posted: 13 years ago by Kevin Roche

Yet another immutable queue implementation

Yet another immutable queue implementation

Posted: 13 years ago by Eirik Tsarpalis

'until' function inspired by Scala

Create a list of int in range [init, upper).

Posted: 13 years ago by Gab_km

Conway sequence

Generate a Conway "look and say" sequence. Each sequence element is generated by reading the previous element from left to right and saying how many repeats of each item there are. Eg. 1211-> 111221 (ie. "one one, one two, two ones").

Posted: 13 years ago by Kit Eason

Sequence of all Subsets of a set

A function that returns a sequence of subsets generated by the power set of a specified set. The function use bit patterns to generate sets. for example the power set generated by a set with 3 elements set [1;2;3;] has 2^3 sets. each set in the power set is represented by the set bits in each of the integer from 0 to (2^3) -1

Posted: 13 years ago by isaiah perumalla

Break a sequence on a predicate

Break a sequence into sub-sequences, where the break occurs at points where the specified function returns true when provided with the n'th and the n+1'th elements of the input sequence.

Posted: 13 years ago by Kit Eason

Maximum Sublist Problem

According to Wikipedia, the maximum sub-array problem is a programming task of finding the contiguous sub-array within a one-dimensional array of numbers (containing at least one positive number) which has the largest sum. The following is an attempt to solve this problem by using F# list rather than array.

Posted: 13 years ago by Joel Huang

Mocking library

F# Mocking library with a fluent interface Moq users should find familiar. Generate mocks for interfaces and abstract types. Supports mocking methods, properties and events. Specify arguments as wildcards or values to match. Define results as values, computed values or exceptions.

Posted: 13 years ago by Phillip Trelford

The Dominator of Array

The dominator of array A is the value that occurs in more than half of the elements of A. It is a zero-indexed based array consisting of N integers (A [] with N length). To find the index array of the dominator from a A [], we can use a helpful function from Seq module call 'Seq.groupBy' to mitigate the implementation of a solution.

Posted: 13 years ago by Joel Huang

Factorial

Factorial versus tail recursion

Posted: 13 years ago by Laco

Fibonacci

fibonacci by Seq.Unfold

Posted: 13 years ago by Laco

Substituting names

An example that shows how we can represent unique names (using classes) and how to substitute names in any F# type type defined using records, discriminated unions and tuples.

Posted: 13 years ago by Tomas Petricek

All subsets of a set

A function implemented using sequence expressions that returns all subsets of a specified set. The function is not optimized, but it is very easy to understand.

Posted: 13 years ago by test

test.fsx

A script exported from Try F#

Posted: 13 years ago by chriscanary

Enumerate files without permissions errors

It's comparatively hard to enumerate files in a directory and subdirectories without getting exceptions for items you don't have permission to read. Here's a function which just ignores items you can't read and enumerates everything else. Useful for searching big network shares.

Posted: 13 years ago by Kit Eason

one.fsx

A snippet generated by Try F#

Posted: 13 years ago by chrismarinos

one.fsx

A snippet exported from Try F#.

Posted: 13 years ago by chrismarinos

one.fsx

A snippet exported from Try F#.

Posted: 13 years ago by chrismarinos

one.fsx

A snippet exported from Try F#.

Posted: 13 years ago by chrismarinos

one.fsx

A snippet exported from Try F#.

Posted: 13 years ago by chrismarinos

one.fsx

A snippet exported from Try F#.

Posted: 13 years ago by chrismarinos

Detecting fraud with Benford's law

Many datasets, particularly those which span several orders of magnitude, have a special property. About 30% of the initial digits of all the data items will be the digit '1'. This can be used to detect fraud, for instance in expenses claims, as people tend to concoct figures which don't have this property. These functions implement one possible test for matching Benford's law. (Credits in the comments.)

Posted: 13 years ago by Kit Eason

Implement a suppression list

Take a sequence and exclude values from it based on another 'suppression list' sequence.

Posted: 13 years ago by Kit Eason

Type-inference friendly division and multiplication

F# necessarily forces you to explicitly cast between int and float for operations such as division. This is necessary because implicit conversion would make type inference much harder. However having to cast all the time in your code can be a pain. These operators reduce the overhead to one or at most two characters of code.

Posted: 13 years ago by Kit Eason

numerics-portable.fsx

A snippet exported from Try F#.

Posted: 13 years ago by cpoulain

numerics-portable.fsx

A snippet exported from Try F#.

Posted: 13 years ago by cpoulain

file1.fsx

A snippet exported from Try F#.

Posted: 13 years ago by nicolas2

file1.fsx

A snippet exported from Try F#.

Posted: 13 years ago by nicolas2

file2.fsx

A snippet exported from Try F#.

Posted: 13 years ago by Levert

file2.fsx

A snippet exported from Try F#.

Posted: 13 years ago by Levert

Combinations n choose k

given an array n generates all lists with k choices from n

Posted: 13 years ago by isaiah perumalla

Preempting NullReferenceExceptions

When interfacing .NET libraries that potentially yield null values, a lot of boilerplate code is required to ensure no NullReferenceExceptions are raised. This is an attempt to avoid such repetition with computation expressions.

Posted: 13 years ago by Eirik Tsarpalis

file2.fsx

A snippet exported from Try F#.

Posted: 13 years ago by Levert

test.fsx

only a test

Posted: 13 years ago by chriscanary

test.fsx

only a test

Posted: 13 years ago by chriscanary

test.fsx

another test

Posted: 13 years ago by chriscanary

Rudimentary IL dissembler for use within FSI.

got distracted and decided I wanted to be able to 'disassemble' a function inside of FSI, much like you can do in many Lisps, this isnt very complete and I think it will only work on the most basic functions, but it was very challenging to get working so I thought I would paste it.

Posted: 13 years ago by David Klein

A reversible stateful execution workflow

This is an attempt to define a workflow that contains reversible stateful computations. In the event of an exception being raised, all insofar successful operations will fold back to their original state. The implementation uses the notion of reversible computation primitives, which are composed using a free monad that is interpreted with a trampoline.

Posted: 13 years ago by Eirik Tsarpalis

QuickLinq Helpers

Variations on some of the LINQ extension members which do not require a type annotation on the lambda argument when used from F#

Posted: 13 years ago by Don Syme

Calculate MD5, SHA1, SHA256, SHA384, SHA512 and RIPEMD160 of files

This is my first experience to write scripts on F# that's why I'll be pleased if somebody will make this snippet more perfectly. Usage: fsi hasher.fsx foo test.dat test.txt bar

Posted: 13 years ago by greg zakharov

Csv + Registry

Had a C tool to parse a csv of queries and check registry against query, then spit out the result, was horrible to parse and model the data in C (just too much code) so I have converted it to F#.

Posted: 13 years ago by David Klein

Lift.fsx

Example of Lift Curve

Posted: 13 years ago by zman

Lift.fsx

Example of Lift Curve

Posted: 13 years ago by zman

The Facet Pattern

The Facet Pattern Used for Principle of Least Authority (POLA) Inspired by: "The Lazy Programmer's Guide to Secure Computing" http://www.youtube.com/watch?v=eL5o4PFuxTY

Posted: 13 years ago by user3539

Generate Powerset using bit pattern

Generate the powerset of a set using a bit pattern.

Posted: 13 years ago by Muigai

file1.fsx

test

Posted: 13 years ago by Levert

streams, memoization, suspension

translation of http://www.cs.cmu.edu/~rwh/introsml/techniques/memoization.htm , no particular reason, just satisfying a tangent, read the cmu site for comments & insights.

Posted: 13 years ago by David Klein

Hex string to byte array

Hex string to byte array via sequences

Posted: 13 years ago by Gennady Loskutov

Splitting sequences of arbitrary unions

A small snippet that groups sequences of arbitrary unions by branch type.

Posted: 13 years ago by Eirik Tsarpalis

recursive to dynamic programming with ycombinator

Dynamic programming is equivalent to recursion + some way to remember the results (as far as I undertand) The y combinator allows to "tie" a previously "untied" recursion, which itself allows to compositionally inject additional steps in the recursion. This allows to go from recursion to dynamic programming in a structured way. This exemple is a bit contrived, as there are no overlapping subproblems, which would be the case in more interesting problem (dtw etc..)

Posted: 13 years ago by Nicolas2

A parametric fixpoint combinator

Writing functions that recursively generate lambdas from a given parameter is a useful practice, but things get trickier when you need the output functions themselves to be mutually recursive. This is my attempt at creating a fix-point combinator that transparently handles this requirement. It also gives memoization for free as a side-effect.

Posted: 13 years ago by Eirik Tsarpalis

Staged Interpreter

A staged intepreter that embeds a DSL in F#. Translated from MetaOCaml. Details in this paper http://www.cs.rice.edu/~taha/publications/journal/gttse07.pdf

Posted: 13 years ago by Muigai

Church numerals

Church numerals via rank-2 polymorphism

Posted: 13 years ago by Nick Palladinos

Extending the standard query builder

The example shows how to extend F# 3.0 'query' builder with a new custom operation that will work with standard lists, but also with queries that are translated using LINQ expressiont trees (such as databases).

Posted: 13 years ago by Tomas Petricek

Frequency Sort

Sort a list by a frequency distribution. Frequency is calculated as per a a provided function. In the test case a list of lists is sorted by the frequency of the length of the lists.

Posted: 13 years ago by Muigai

Inverse error function (float)

let erfinv x = let mutable p = 0.0 let mutable w = -log((1.0-x)*(1.0+x)) // corrected sign if w < 5.000000 then w <- w - 2.500000 p <- 2.81022636e-08 p <- 3.43273939e-07 + p*w p <- -3.5233877e-06 + p*w p <- -4.39150654e-06 + p*w p <- 0.00021858087 + p*w p <- -0.00125372503 + p*w p <- -0.00417768164 + p*w p <- 0.246640727 + p*w p <- 1.50140941 + p*w else w <- sqrt w - 3.000000 p <- -0.000200214257 p <- 0.000100950558 + p*w p <- 0.00134934322 + p*w p <- -0.00367342844 + p*w p <- 0.00573950773 + p*w p <- -0.0076224613 + p*w p <- 0.00943887047 + p*w p <- 1.00167406 + p*w p <- 2.83297682 + p*w p*x

Posted: 13 years ago by Clever people

Type Safe Higher-order abstract syntax

Type Safe Higher-order abstract syntax via GADT encoding

Posted: 13 years ago by Nick Palladinos

Cooperative cancellation in Async workflows

A simple implementation that protects the nested workflow from external cancellation. The external cancellation token is passed as an argument for cooperative cancellation. Kudos to Gian Ntzik for this one.

Posted: 13 years ago by Eirik Tsarpalis

Minimal SlimDX DirectX 11 Compute Shader

This is the minimum F# code required to run and view a compute shader with SlimDX in DirectX 11.

Posted: 13 years ago by gradbot

SlimDX static noise compute shader

A compute shader using wang's hash to make a static filled window. Runs at 2000 frames per second on my machine.

Posted: 13 years ago by gradbot

Triangle rendering using SlimDX

Minimal code to render some colored triangles.

Posted: 13 years ago by gradbot

Thread safe caching with expiry

A construct that caches the result of a computation/request up to a given expiration interval. Makes use of the atom implementation found in http://fssnip.net/bw

Posted: 13 years ago by Eirik Tsarpalis

JessiTron.fsx

An F# implementation of Jessica Kerr's blog post on imperative to functional. http://blog.jessitron.com/2013/01/from-imperative-to-data-flow-to.html

Posted: 13 years ago by jbuedel

Extra Micro ORM

Easy database access.

Posted: 13 years ago by igeta

What's My SuperBowl Pool Box Worth?

If I'd entered the same SuperBowl Pool every year, and received the same numbers every year, how much would I have won?

Posted: 13 years ago by Wayne Bradney

Yet another (combinatorial) way to compute the factorial

Compute the factorial of a given number by building the list of permutations of the list of first n numbers [1..n] and taking its length

Posted: 13 years ago by Dmitry Soshnikov

DivRem Operator

Defines the operator /% as DivRem for int, int64 and bigint.

Posted: 13 years ago by Diego Frata

String Manipulation

hackthissite.org programming level 12, string manipulation.

Posted: 13 years ago by David Klein

Trace-mode pipeline operators

This fake module can trace pipeline operators.

Posted: 13 years ago by Nobuhisa

Generate password-like string

Generate password-like string and save it to clipboard. Original idea is here: http://d.hatena.ne.jp/rubyco/20130202/password (Japanese)

Posted: 13 years ago by yukitos

Walking object graphs

Implemetation picked up from http://msdn.microsoft.com/en-us/library/system.runtime.serialization.objectmanager.aspx

Posted: 13 years ago by Eirik Tsarpalis

Copy a directory of files

Copies a directory of files. Based on code from http://msdn.microsoft.com/en-us/library/bb762914.aspx

Posted: 13 years ago by Wallace Kelly

Delete the matching files in a directory

Accepts a directory and wildcard pattern to delete files in a folder

Posted: 13 years ago by Wallace Kelly

A polyvariadic fixpoint in F#

Or who needs non-strict semantics when you have references?

Posted: 13 years ago by Eirik Tsarpalis

Build a Visual Studio solution

Builds a Visual Studio solution.

Posted: 13 years ago by Wallace Kelly

GC Friendly Fixpoint

Fast and GC friendly fixpoint combinator.

Posted: 13 years ago by Nick Palladinos

Declarative argument parsing

A proof of concept on how one could build an argument parsing scheme simply by declaring a discriminated union.

Posted: 13 years ago by Eirik Tsarpalis

Type-safe URL templates for Nancy

The Nancy web framework parses URLs for you, and passes requests under a given URL route and HTTP method to your program. It relies heavily on C# dynamic objects; these don't translate well in F# code, and it's easy to make mistakes that only show up at run time. Here we define one F# record type for each route, with an attribute that defines the URL, with placeholders for each field in the record. These types implement one generic interface for each HTTP method they support: for GET, PUT and POST, these generic interfaces also specify the types of the HTTP request and response bodies.

Posted: 13 years ago by Tim Robinson

Reversi Kata solution

Reversi Kata solution from February 2013 London F# Meetup Coding Kata.

Posted: 13 years ago by Phillip Trelford

worldbank-done.fsx

Comparing university enrollment rate in Czech Republic and OECD countries (works in tryfsharp.org!)

Posted: 13 years ago by tomasp

CSS EDSL in F#

F# to CSS compiler (CSS EDSL in F#) <+> inspired by Clay and FAKE - https://github.com/Cynede/Failess

Posted: 13 years ago by Heather

Eval Quotations

Evaluates a useful subset of F# quotations at run-time (without the F# PowerPack API).

Posted: 13 years ago by Phillip Trelford

Calculate PI using Monte Carlo

Estimate the value of PI using a Monte Carlo simulation.

Posted: 13 years ago by Phillip Trelford

Agent that can upgrade its functionality on the fly.

Agent that can upgrade its functionality on the fly. (F# MailboxProcessor containing function in the loop...)

Posted: 13 years ago by Tuomas Hietanen

Count noise-lines in C# code

This is the code I used to generate this pie chart: http://pic.twitter.com/PgPEFByg56 Enough said?

Posted: 13 years ago by Kit Eason

cell-simulation.fsx

F# Simulation lab Part III Systems Biology Cambridge University

Posted: 13 years ago by Samin

cell-simulation.fsx

F# Simulation lab Part III Systems Biology Cambridge University

Posted: 13 years ago by Samin

A template for projection comparison

An abstract class that implements all the boilerplate required for custom comparison semantics.

Posted: 13 years ago by Eirik Tsarpalis

LazyAsync

Allows to expose an F# async value in a C#-friendly API with the semantics of Lazy<> (compute on demand and guarantee only one computation)

Posted: 13 years ago by Gustavo Guerra

Parsing a trace file via a small cmd utility

Given an input stream of "int|int" pairs (one such pair per line), output only those lines for which the right integer has at least k distinct integers on the left side, on the entire input stream. The number k is given as a command line argument.

Posted: 13 years ago by Aggelos Biboudis

Project Euler Problem 14

Project Euler Problem 14

Posted: 13 years ago by Jon Canning

An active pattern combinator for list inputs

A few active pattern combinators useful when pattern matching on lists is necessary.

Posted: 13 years ago by Eirik Tsarpalis

Emulating higher level typing using inline functions and member constraints

This pattern shows that by using a few static member constraints, one can create an assortment of data processing functions that emulate higher level typing than is possible in F#.

Posted: 13 years ago by Greg Ros

Defining union cases that have the cons ( :: ) pattern

Here I give an example of a data structure known as a skew binary list and also an example of how to use the cons pattern, normally reserved for FSharp lists, in your own union cases. It is not possible to do the same with the nil union case, []. Nor is it possible to use any other symbols (as far as I know). This kind of sucks.

Posted: 13 years ago by Greg Ros

DSL for constructing HTML

Just another DSL for creating HTML in F#. This DSL attempts to have nice syntax using curly brackets (F# computation expression blocks) for nesting. It does not use other keywords like `yield` (to keep the syntax as non-intrusive as possible), but that means the implementation relies on mutation. I think there could be nicer implementation using automatic quoting in F# 3.0.

Posted: 13 years ago by Tomas Petricek

tcpStream abstraction

Basic (but experimental) TCP stream wrappers to help make TCP more abstracted and cleaner. Giving the user just the impression of a 'stream' that one connects to and sends and receives. This helps promote composition. The first abstraction is 'stream', really just wrapping .NET stream functions so that read returns the read n bytes and write returns the stream, all functions take NetworkStream as the first parameters, followed by other parameters. Currently we don't care about timeouts, exceptions, or other nasty's.

Posted: 13 years ago by David Klein

Dynamic (?) operator with null handling

An implementation of the ? operator that handles null

Posted: 13 years ago by Tomas Petricek

Generic Collections, Type Classes and friends

A crazy experiment for "Scalable" collections. Inspired by the paper "Fighting Bit Rot with Types"

Posted: 13 years ago by Nick Palladinos

Bloom filter implementation in F#

http://codekata.pragprog.com/2007/01/kata_five_bloom.html

Posted: 13 years ago by Suzanna

The "dir" function of Python

This snippet likes the "dir" function of Python. ( http://docs.python.org/2/library/functions.html#dir ) The "dir" function is useful on FSI. You can take a look at members of the object quickly.

Posted: 13 years ago by Nobuhisa

Kata Six: Anagrams - solution in F#

Solution to Kata Six: Anagrams from http://codekata.pragprog.com/2007/01/kata_six_anagra.html in F#

Posted: 13 years ago by Suzanna

C Struct to F#

Quick function to take a wireshark 'C Structure' and turn it into a F# byte array

Posted: 13 years ago by David Klein

hexdump (somewhat fast)

Simple functions to display a hex dump of a byte array using sequence expressions, with ASCII. Rewrote naive version that used string concat, based on optimizations in http://fssnip.net/ht, and cleaned up ASCII formatting.

Posted: 13 years ago by Matthew H. Traylor

Async function that retries work

A simple asynchronous workflow that retries running a given async workflow (until "resultOk" function returns true or until a specified number of retries is performed). The function uses tail-recursion in async workflows.

Posted: 13 years ago by Tomas Petricek

Function overloading

I came up with a gimmick. It looks like function overloading.

Posted: 13 years ago by Nobuhisa

Even more Fast hex dump

A simple function that nicely formats arrays of bytes. Useful in FSI or logging. byte array -> string seq Inspired by http://fssnip.net/hq, but optimized to become O(n).

Posted: 13 years ago by Vasily Kirichenko

Extending async with await on tasks

The snippet shows how to extend the built-in F# async computation builder with the ability to await standard .NET tasks using the let! keyword.

Posted: 13 years ago by Tomas Petricek

Parser combinators simple example

This snippet is an example of how to implement parser combinators in a simple way.

Posted: 13 years ago by Santi Albo

Async.AwaitTask with timeouts

Asynchronously await task completion with timeout support.

Posted: 13 years ago by Eirik Tsarpalis

Async.CancelAfter

Asynchronously perform a computation until it completes or timeout is reached.

Posted: 13 years ago by Eirik Tsarpalis

Workflows and parser combinators

Example on the use of Workflows in parser combinators.

Posted: 13 years ago by Santi Albo

AdaBoost in F#

I have provided a class that implements adaptive boosting (AdaBoost) which is a very elegant technique to create a strong classifier from a set of weak classifiers. The strong classifier is the sign of the weighted average of the best N weak classifiers where N is a user specified parameter. The training process consists of N selection rounds. During each round, the training samples are given a weight distribution. The classifier selected is the one that has the least error which is equal to the weighted average of incorrectly classified samples. Training samples that have been incorrectly classified are given a larger weight for the next round. This increases the likelihood of drafting a weak classifier that can help with as yet misclassified samples.

Posted: 13 years ago by Suzanna

Largest palindrome made from the product of two n-digit numbers

A generalised version of the solution to the fourth Project Euler problem - Largest palindrome product, using sequences. The key to understanding this code is how "Seq.map (fun x -> (Seq.map (fun y -> x * y) baseSeq)) baseSeq" generates a sequence of sequences that contains the products of all possible combinations of two n-digit numbers. "Seq.map (fun x -> (Seq.map (fun y -> x * y) {1..3})) {1..3}" will generate: seq [seq [1; 2; 3]; seq [2; 4; 6]; seq [3; 6; 9]]

Posted: 13 years ago by Bjørn Bæverfjord

Bin Packing

Implementation of the 'best fit' heuristic algorithm for bin packing problems. Incudes an implementation of 'binary tree with duplicates'. See this blog post for details: http://fwaris.wordpress.com/2013/04/01/best-fit-bin-packing/ Update: Bug fixes and added 'worst fit' heuristic implementation

Posted: 13 years ago by Faisal Waris

hof.fsx

Higher order function

Posted: 13 years ago by Rafael

Generic agent post operator

Generic operator that introduces a convenient syntax for "posting" messages into any agent that has Post member. Specifically, it's useful for the standard MailboxProcessor and the AutoCancelAgent (from FSharpx library).

Posted: 12 years ago by Vasily Kirichenko

Command Pattern - Simple

A simple implementation of a very basic command pattern that is being submitted to an Android app called GoF Design Patterns by Poash - highly recommended btw. This is imperative/oop in style, hope it helps someone. It is my first submission and I'm an F Sharp newbie!

Posted: 12 years ago by Richard Griffiths - SoulFireMage

Gantt Chart Visualization

Shows how to generate a Gantt chart to visualize a schedule. Note: Requires BinPacking.fs found here: http://fssnip.net/hG

Posted: 12 years ago by Faisal Waris

Finalizable function object

The snippet shows how to create an F# function value that will call a custom finalizer function when garbage collected. This is done by creating a type that inherits from FSharpFunc.

Posted: 12 years ago by Tomas Petricek

Merge Sort of int lists

A basic recursive implementation of merge sort on lists of ints.

Posted: 12 years ago by Bret Colloff

Generic Peano arithmetic

An attempt at defining Peano arithmetic for all numeric types

Posted: 12 years ago by Eirik Tsarpalis

Project Euler #4

My take at Project Euler #4

Posted: 12 years ago by ildjarn

A return combinator for F#

A combinator that enables real imperative code in F#. Use with caution!

Posted: 12 years ago by Eirik Tsarpalis

Guess what

So I disposed :(

Posted: 12 years ago by Heather

local wireless passwords

dump out saved windows wireless passwords in plaintext. they're stored in xml file, to successfully dump them you must be logged in as the same user who created them (at least in the below code ;)

Posted: 12 years ago by David Klein

Production

http://msdn.microsoft.com/en-us/library/vstudio/dd483467(v=vs.100).aspx

Posted: 12 years ago by Prue

Loop Unrolling

C++ style metaprogramming in F#

Posted: 12 years ago by Nick Palladinos

Parsing formulas

Parsing simple formulas using active patterns

Posted: 12 years ago by Tomas Petricek

Iterate B-Tree

Iterate simple b-tree

Posted: 12 years ago by devshorts

Binary search

Simple binary search of an array. Tests the array at the middle and divides the search space by half each time it looks for the target item. Returns the target item and how many iterations it took to get there

Posted: 12 years ago by devshorts

Remove block comments from a list of tokens

Cleaning up source code for a Forth like language before the compiling stage

Posted: 12 years ago by Bjørn Bæverfjord

A Happy Ending

Generates Text art in the style of Philippe Decrauzat's D.T.A.B.T.W.H.A.H.E. 2010 currently exhibited at the MoMA NYC

Posted: 12 years ago by Phillip Trelford

Option Type Support on ServiceStack

A simple module for registering option types with ServiceStack serializer.

Posted: 12 years ago by Diego Frata

Find largest mass in 2D array

This is a modification of the flood fill algorithm to find the largest contiguous block of items in a 2D array. Also includes a simple flood fill finder given a canvas and the target point

Posted: 12 years ago by devshorts

String palindrome

Tests if a string is a palindrome (whitespace independent)

Posted: 12 years ago by devshorts

String palindrome (short)

Dear #fssnip newbies, please do not write F# code as if you are still in C#. Direct ports are meaningless. Among other things, please learn what structural equality is.

Posted: 12 years ago by @kot_2010

Wrapping Tasks.Task to async

This code wraps System.Threading.Tasks.Task (that has no return value), properly, so that cancellations and exceptions are preserved, and exceptions keep their stack-traces. It is to be used when the Task only denotes a single computation or value, as it only picks the first exception from the list of exceptions.