Compze.Functional 0.6.0

Compze.Functional

Code that reads the way you would describe the algorithm in words, not code that must be read inside out. Powered by the pipe forward operator and friends.

Sometimes very little goes a very long way. With just a handful of trivially simple extension methods we enable you to write code like this:

public OperationResult SomeBusinessMethod(Guid userId) =>
    userId
    ._(LoadFromDatabase)
    ._tap(it => { /*log*/ })
    ._assert(MayExecuteThisOperation)
    ._(ActualOperationLogic)
    ._tap(it => { /*log*/ })
    ._assert(ResultIsWhatWeExpected);

Pipe forward operator

Chain operations fluently with ._():

var result = initialValue
    ._(Transform)
    ._(Validate)
    ._(Format);

Primary methods:

• _tap() — execute side effect, return original value
• _mutate() — intent declaring alias for _tap
• _then() — discard the current value and continue with a new one. Enables one-liner implementations when the previous value is irrelevant.

Note: The _assert() method used in the examples above comes from Compze.Contracts — you may want to check it out.

The Unit type

Like void but without splitting Action<T> from Func<T,T2>

In .NET Action<T> and Func<T, T2> are not compatible, resulting in tons of code needing one version for action and one for Func. Unit is the solution. Methods with no meaningful return value return unit removing incompatibility since unit is a value, a single uniform value.

Painlessly convert void methods to unit returning methods that will participate frictionlessly in piping:

public unit Log(string message) => unit.From(() => Console.WriteLine(message));

Convert between Action<T> and Func<T,unit>

Action anAction = SomeVoidMethod;
Func<unit> aUnitFunc = anAction.AsFunc();
var anotherAction = aUnitFunc.AsAction(); 

var something = AMethodTakingAFunc(unit.Func(SomeVoidMethod));

What's with the naming?

These extensions apply to every type, so name collisions and polluting auto-complete lists are a very real concern. _camelCase provides:

• Near zero collision risk — no standard .NET method starts with _.
• Clear visuals — instantly recognizable as something other than regular methods.
• Great discoverability — type ._ and all these extensions are right there grouped together.

._( as the pipeline operator has the same advantages and keeps something you will be using constantly as short as possible.

Lower case unit is sort of a wish for the future and the way we think it should be. We hope our unit will eventually be replaced by a language keyword and built in type.

Related packages

License

Apache-2.0