Kotlin.ScopeFunctions 0.6.0

Kotlin.ScopeFunctions

Use Kotlin's Scope Functions in .NET

Like LINQ for single values, Scope Functions are a powerful way to write code that is more declarative and reads like the flow of information through your program.

Installation

The package is available from nuget.org as Kotlin.ScopeFunctions

Or, you can run install-package Kotlin.ScopeFunctions from within your IDE

Getting started

Most .NET developers are very comfortable with using chains of LINQ extension methods to process data in a pipeline that reads fluently from left to right, describing how data maps from source to result through a series of transformation steps.

Typically this is easier to read than the same thing written as nested method calls, since developers are usually happier to read a flow from left to right than to unpick a nested set of method calls.

So, what if you could do the same thing with single values as you can with enumerables?

That's where Kotlin's scope functions come in. They allow you to use an extension method that takes the source object as the argument to a supplied delegate, just like LINQ functions allow you to use an extension method that takes the elements of the source sequence as arguments to a supplied delegate.

This simple library re-implements Kotlin Scope Functions so that you can use the same pattern to improve your C# code.

They come in three flavours:

• Firstly Let() which takes the source object and returns the result of calling the delegate. This is like a scalar version of Enumerable.Select() and is useful for fluently mapping an object through a transformation, or a series of transformations.
• Secondly Also() which takes the source object and calls the supplied delegate on the object, but returs the original object. This is like a scalar version of List<>.ForEach(). This is useful for applying an action to an object (perhaps part of its initialisation) without needing to declare a local variable specifically for the purpose.
• Finally, TakeIf() and TakeUnless() which apply a predicate to the source object, returning either the object or default(T), depending on ther result and the sense of If / Unless. This is like a scalar version of Enumerable.Where() and is useful alongside the null-conditional operator ?. to allow a subsequent method call to execute only if a condition is met.

LetAsync() and AlsoAsync are also available for async use cases