RegexExtensions.fs

namespace Extensions
open System.Text.RegularExpressions

///Regex extensions
module Regex =
    type ActiveMatch =
        {
            Match: Match
            MatchValue: string
            Groups: Group list

gist:1406238

Originally:
https://gist.github.com/7565976a89d5da1511ce

Hi Donald (and Martin),

Thanks for pinging me; it's nice to know Typesafe is keeping tabs on this, and I
appreciate the tone. This is a Yegge-long response, but given that you and
Martin are the two people best-situated to do anything about this, I'd rather
err on the side of giving you too much to think about. I realize I'm being very
critical of something in which you've invested a great deal (both financially

leegao

(*
  We use the following grammar, which can be proven to be LL(1) by the derivation below
  
  D  -> >|<|+|-|.|,
  E  -> D E'
  E  -> [ E ] E'
  E' -> E
  E' -> epsilon ; null/empty terminal
  
  from the above, we build the following First sets

jfromaniello

Para más información acerca de mate http://es.wikipedia.org/wiki/Mate_(infusi%C3%B3n)

Colocar en el mate 2/3 de yerba sin colocar la bombilla aún.
Tapando la boca del mate "zarandear" boca abajo varias veces para que la materia fina de la yerba quede arriba.
Volver el mate boca arriba intentando que la yerba quede toda de un lado, y del otro lado quede vacío a tal punto que se pueda ver desde arriba el fondo del mate.
Verter un poco de agua tibia del lado sin yerba, y una vez humedecida la yerba, con una cuchara intentar amontonar más la yerba agrandando el espació vacío donde se puede ver el fondo del mate.
Colocar la bombilla de tal forma que la parte por donde se absorbe el agua quede del lado sin yerba.

Siempre colocar el agua por el lado sin yerba. 

biboudis

public static IObservable<Tuple<TSource, bool>> Bloom<TSource>(this IObservable<TSource> source, int size)
{
	BitArray bitmap = new BitArray(size);

	return source.Select<TSource, Tuple<TSource, bool>>(value =>
	{
		var hashCode = value.GetHashCode();
		var tuple = new Tuple<TSource, bool>(value, bitmap[hashCode] == true);
		bitmap[hashCode] = true;
		return tuple;

ovatsus

#r "System.Xml.Linq"

open System
open System.IO
open System.Xml.Linq

let script = seq {

    //TODO: this currently loads fsproj's in alphabeticall order, we should instead
    //build the dependencies graph of the fsproj's and load them in topological sort order

sebfisch

Delimited Continuations

Delimited continuations manipulate the control flow of programs. Similar to control structures like conditionals or loops they allow to deviate from a sequential flow of control.

We use exception handling as another example for control flow manipulation and later show how to implement it using delimited continuations. Finally, we show that nondeterminism can also be expressed using delimited continuations.

Exception Handling

Thorium

#I @"C:\Tools\System.Reactive"
#r "System.Core.dll"
#r "System.Reactive.dll"
 
type observable<'a> = System.Collections.Generic.IObservable<'a>
type observer<'a> = System.Collections.Generic.IObserver<'a>
 
module Observable =
  open System
  open System.Linq

palladin

// http://homepages.cwi.nl/~ralf/syb3/

let inline gmap f g  (x : ^R) : ^R = (f ? (g) <- x) 

type Data = Data with
    static member inline ($)(f : ^F, x : ^A) = gmap Data f x

    static member inline (?<-)(Data, f, x : int) = x
    static member inline (?<-)(Data, f, x : string) = x
    static member inline (?<-)(Data, f, x : bool) = x

nberardi

using System;
using System.Linq;

namespace System.Numerics
{
	public struct BigDecimal : IConvertible, IFormattable, IComparable, IComparable<BigDecimal>, IEquatable<BigDecimal>
	{
		public static readonly BigDecimal MinusOne = new BigDecimal(BigInteger.MinusOne, 0);
		public static readonly BigDecimal Zero = new BigDecimal(BigInteger.Zero, 0);
		public static readonly BigDecimal One = new BigDecimal(BigInteger.One, 0);