different properties and apply functions on these parts and then recombine the results into a combined result via a specified combinator function, sometimes called a 'join function'.
public static class FunctionalExtensions {
public static TOutput Map<TInput, TOutput>(
this TInput @this,
Func<TInput, TOutput> func) => func(@this);
public static TOutput Fork<TInput, TMiddle, TOutput>(
this TInput @this,
Func<IEnumerable<TMiddle>, TOutput> combineFunc,
params Func<TInput, TMiddle>[] parts)
{
var intermediateResults = parts.Select(p => p(@this));
var result = combineFunc(intermediateResults);
return result;
}
public static TOutput Fork<TInput, TMiddle, TOutput>(
this TInput @this,
Func<TInput, TMiddle> leftFunc,
Func<TInput, TMiddle> rightFunc,
Func<TMiddle, TMiddle, TOutput> combineFunc)
{
var leftResult = leftFunc(@this); // @this.Map(leftFunc);
var rightResult = rightFunc(@this); // @this.Map(rightFunc);
var combineResult = combineFunc(leftResult, rightResult);
return combineResult;
}
}
Let's take a familiar mathematical example, calculating the Hypotenuse in a triangle using Pythagorean theorem. This states that the length of the longest side A of a 'right triangle' is the
square root of the sum of the squares of the shorter sides B and C :
A = √(B² + C²)
Consider this class:
public class Triangle {
public double CathetusA { get; set; }
public double CathetusB { get; set; }
public double Hypotenuse { get; set; }
}
Let's test the first Fork helper extension method accepting two functions for specifying the left and right components:
var triangle = new Triangle
{
CathetusA = 3,
CathetusB = 4
};
triangle.Hypotenuse = triangle.Fork(
t => t.CathetusA * t.CathetusA,
t => t.CathetusB * t.CathetusB,
(l,r) => Math.Sqrt(l+r));
Console.WriteLine(triangle.Hypotenuse);
This yields '5' as the answer via the forked result above. A simple example, but this allows us to create a simple combinatory
logic example on an object of any type using functional programming (FP).
Let's look at a simpler example just combining multiple properties of an object with a simple string-join, but using the Fork version supporting arbitrary number of parts / components:
public class Person {
public string JobTitle { get; set; }
public string FirstName { get; set; }
public IEnumerable<string> MiddleNames { get; set; }
public string LastName { get; set; }
}
var person = new Person{
JobTitle = "Detective",
FirstName = "Alexander",
MiddleNames = new[] { "James", "Axel" },
LastName = "Foley"
};
string contactCardText = person.Fork(parts => string.Join(" ", parts), p => p.FirstName,
p => string.Join(" ", p.MiddleNames), p => p.LastName);
Console.WriteLine(contactCardText);
This yields:
Alexander James Axel Foley
Fork can be very useful in many cases you need to 'branch off' on an object and recombine parts of the object with some specific function, either two parts or multiple parts and either continue
to work on the results or retrieve the results.
