A library of static classes, extension methods, and classes that apply functional techniques to C#.
I am by no means an expert in this area. This repository is acting more as my personal notes as I study this concept and try applying it to my other C# projects.
When using this library to write your own library or application, there are some items you will have to keep in mind in order if you want to stay true to functional C#.
Keeping the methods/functions to just a singular action (especially in class libraries) gives you greater flexibilty in composing functions to reach the ultimate result of your application. This can also make your library or application much more readable when a function only does one thing, and the name of that function describes what it does.
var substring = mystring.Substring(3,5);
gives the same result as
var substring = mystring.Skip(3).Take(5);
but if you did not already know the behavior of Substring the
composition of Skip and Take more clearly describes what the
result ultimately is. The separate Skip and Take functions
then also allows you to compose either or both with other functions
to obtain more complex behavior.
When creating a new class it is up to you to make it immutable to enforce the idea that your library or application does not use changing state. To do this you would use readonly getter auto properties and then initialize those properties in the class constructor.
public class MyClass
{
public readonly string MyProperty;
public MyClass(string property)
{
MyProperty = property;
}
}
Sometimes is does become nessessary to change the property of a class and thus change state that could effect the output of a function. The compromise for this situation could be to use private setters with a public function that returns the changed object.
public class MyClass
{
public string MyProperty { get; private set; }
public MyClass SetProperty(string property)
{
MyProperty = property;
return this;
}
}
Formally, a monad is constructed by defining two operations (bind and return) and a type constructor M that must fulfill several properties to allow the correct composition of monadic functions (i.e. functions that use values from the monad as their arguments). The return operation takes a value from a plain type and puts it into a monadic container of type M. The bind operation performs the reverse process, extracting the original value from the container and passing it to the associated next function in the pipeline.
The bind method on our Result<T> class is what makes the
composition of functions on this amplified type work.
Using exceptions as a sort of flow control for your library or application violates the idea of functional programming that any function should only return a single type. Using exceptions in flow control means that a function could return the type it is supposed to return or it could return an exception type. To assist with this, the Result class in this library can be used. Using that Result class, exceptions should be caught and handled at the abosulte lowest level possible (as in a library) or at the highest level (as in an application). This can be tricky to do sometimes and will probably cause more exceptions to buble up than you are used to seeing. This might cause some distress at first, but seeing these exceptions will allow you to write in a handle for those exceptions and create a more stable library or application in the long run.