Monadic Comprehensions and Functional Composition with Query Expressions

Monadic Comprehensions and Functional Composition with Query Expressions
Chris Eargle

LINQ to Objects

Oh, that’s a monad!

List Monad

LINQ to Objects
from x in new[] {1, 2, 3}from y in new[] {1, 2, 3}select Tuple.Create(x, y)
List Monad
do x <- [1,2,3] y <- [1,2,3] return (x,y)

Query Expressions

var words = new[] { "the", "quick", "brown", "fox"};
IEnumerable<string> query = from word in words
select word;

var query = from word in words
orderbyword.Length
select word;

var query = from word in words
orderbyword.Length
select word.Replace(‘o’, ‘a’);

var query = words.OrderBy(w => w.Length)
.Select(w => w.Replace('o', 'a'));

Functional Design Pattern

Return
Bind

public struct Monad<T>
{
private T value;
public Monad(T value)
{
this.value = value;
}
public Monad<U> Bind<U>(Func<T, Monad<U>> func)
{
return func(value);
}
}

public static class Monad
{
public static Monad<T> Create<T>(T value)
{
return new Monad<T>(value);
}
}

varmonad = Monad.Create(1);
varmonad2 = monad.Bind(v => Monad.Create(v));
Assert.IsInstanceOfType(monad, typeof(Monad<int>));
Assert.AreEqual(monad, monad2);
Assert.AreNotSame(monad, monad2);

Identity Monad

public struct Identity<T>
{
T value;
public T Value { get { return value; } }
public Identity(T value)
{
this.value = value;
}
}

public static class Identity
{
public static Identity<T> Create<T>(T value)
{
return new Identity<T>(value);
}
}

varresult = from x in Identity.Create(1)
select x.ToString();
Assert.AreEqual("1", result.Value);

public Identity<TResult> Select<TResult>
(Func<T, TResult> selector)
{
return Identity.Create(selector(value));
}

var result = from x in Identity.Create(2)
from y in Identity.Create(3)
select x + y;
Assert.AreEqual(5, result.Value);

public Identity<TResult> SelectMany<U, TResult>(
Func<T, Identity<U>> selector,
Func<T, U, TResult> resultSelector)
{
return Identity.Create(resultSelector(value, selector(value).Value));
}

var result = from x in Identity.Create(2)
from y in Identity.Create(3)
select x + y;
Assert.AreEqual(5, result.Value);

Cut the Middle Man

var result = from x in 2
from y in 3
select x + y;
Assert.AreEqual(5, result);

public static TResultSelectMany<T1, T2, TResult>(
this T1 source,
Func<T1, T2> selector,
Func<T1, T2, TResult> resultSelector)
{
return resultSelector(source, selector(source));
}

Tuples

var result = from info in ConferenceInfo()
from dates in ConferenceDates()
select new
{
Name = info.Item1,
StartDate = dates.Item1,
EndDate = dates.Item3
};

Assert.AreEqual("IEEE ICCSIT", result.Name);
Assert.AreEqual(july9th, result.StartDate);
Assert.AreEqual(july11th, result.EndDate);

Continuation Monad

public class Continuation<R, A>
{
private readonlyFunc<Func<A, R>, R> value;
internal Continuation(Func<Func<A, R>, R> func)
{
this.value = func;
}
public R Run(Func<A, R> k)
{
return value(k);
}
}

public static class Continuation
{
public static Continuation<R, A> Create<R, A>(Func<A> func)
{
return Continuation.Create<R, A>(k => k(func()));
}
public static Continuation<R, A> Create<R, A>(Func<Func<A, R>, R> func)
{
return new Continuation<R, A>(func);
}
}

public static Continuation<R, int> Square<R>(int x){ return Continuation.Create<R, int>(() => x * x);}

public static Continuation<R, double> Hypotenuse<R>
(int x, int y){ return from h in Square<R>(x)
from w in Square<R>(y)
select Math.Sqrt(h + w);}

Assert.AreEqual(5, Hypotenuse<double>(3, 4).Run(n => n));

Cut the Middle Man

Func<int, int> square = x => x * x;
Func<int, double> squareRoot = x => Math.Sqrt(x);

varhypotenuse = from h in square
from w in square
select squareRoot(h + w);
Assert.AreEqual(5, hypotenuse(3, 4));

public static Func<T1, T2, TResult3>SelectMany<T1, T2, TResult, TResult2, TResult3>( this Func<T1, TResult> leftFunc, Func<T1, Func<T2, TResult2>> rightFunc, Func<TResult, TResult2, TResult3> selector)
{
return (x, y) => selector(leftFunc(x), rightFunc(x)(y));
}

Func<int, int> f = x => x + 2;
var result = from x in f
select x * 2;
Assert.AreEqual(6, result(1));

public static Func<T, TResult2> Select <T, TResult, TResult2>( this Func<T, TResult> func, Func<TResult, TResult2> selector)
{
return a => selector(func(a));
}

public static Func<Int32, Double> Sum(this Func<Int32, Double> func, intstart = 0)
{
return end =>
{
Double result = default(Double);
for (int k = start; k <= end; k++)
{
result += func(k);
}
return result;
};
}

Factorial

Func<int, int> f = x => x;
varfactorial = from x in f.Sum()
where x != 0
select x ?? 1;
Assert.AreEqual(1, factorial(0));
Assert.AreEqual(6, factorial(3));

public static Func<T, dynamic> Where<T, TResult>(
this Func<T, TResult> func,
Func<TResult, bool> predicate)
{
return a =>
{
TResult result = func(a);
return predicate(result) ? result as dynamic : null;
};
}

4k=0∞−1k2k+1

Func<Int32, Double> f = k => 4 * Math.Pow(-1, k) / (2.0 * k + 1);
varcalculatePi = f.Sum();
Assert.AreEqual(3.14159, calculatePi(200000), 7);

monadic.codeplex.com

Monadic Comprehensions and Functional Composition with Query Expressions

by Chris Eargle on Jul 10, 2010

Accessibility

Categories

Tags

Upload Details

Usage Rights

2 Embeds 220

Statistics

Monadic Comprehensions and Functional Composition with Query Expressions — Presentation Transcript

http://www.kodefuguru.com	214
http://www.chriseargle.com	6