wiesław kałkus: c# functional programming

WIESŁAW KAŁKUS

Holte Software Poland

Functional ProgrammingIs it possible in C#?

Today’s Agenda

C# Functional Programming

Is It Worth An Effort? Maybe It Is

Controlling ComplexityComposition Function Composition

Programming ExampleCopying Photo Files Implementation Variants

What Is Functional Programming?Theoretical Perspective C# Programmer Perspective

What is Functional Programming?

What Is Functional Programming?

Wikipedia

Functional Programming is a programming paradigm, a style of building the structure and elements of computer programs, that treats computations as the evaluation of mathematical functions and avoids changing-state and mutable data. It is a declarative programming paradigm, which means programming is done with expressions.

Programming Paradigms

• Focus on describing how a program operates• Programs described in terms of statements that change a program

state• Structural (procedures as main actors) and object-oriented (objects as

main actors) programming styles fall into imperative paradigm

Imperative

• Focus on describing what a program should accomplish without prescribing how to do it in terms of sequences of actions to be taken

• Programs expressed in terms of computation logic without describing its control flow

• Functional (mathematical function as main actor) programming style falls into declarative paradigm

Declarative

Multi-paradigm programming languages

Type inference (C# & F#)Anonymous functions (C# & F#)Language Integrated Query (C# & F#)Currying (F#)Pattern matching (F#)Lazy evaluation (F#)Tail recursion (F#)Immutability (F#)

Control statements (C#)Classes (C#).NET framework (C# & F#)Do notation (F#)

Declarative

Imperative

Object-Oriented vs. Functional Programming Style

Characteristic Object-oriented (imperative) approach Functional (declarative) approach

Programmer focus How to perform tasks (algorithms) and how to track changes in state.

What information is desired and what transformations are required.

State changes Important. Localized and tightly controlled.

Order of execution Important. Low importance.

Primary flow control Loops, conditionals, and function (method) calls. Function calls, including recursion.

Primary manipulation unit Instances of structures or classes. Functions as first-class objects and data collections.

Programming Example

Programming Example – problem statement

Copy photo files from the source folder (include subfolders) to the destination folder (create subfolders as necessary). While copying rename each file using pattern <base-name><sequence-number>. Sequence numbers should preserve the order of date taken for each photo. Additionally allow for each source photo file to create multiple copies of the file in the target folder (useful for extending time-lapse photography sequences).

Programming Example – object-oriented approach

foreach (sourceFile in sourceFilesSortedByPhotoDateTaken){ try { CreateTargetFolderPathIfNecessary fileCopyCount = 0 while (fileCopyCount < PhotoFileCopyMultiplicationFactor) { MakeNewTargetFileName CopySourceFileToTheTargetFolderUnderTheNewName fileCopyCount += 1 } } catch { } }

Programmer focus on how to perform tasks (algorithms) and how to track changes in state.

foreach (sourceFile in sourceFilesSortedByPhotoDateTaken){ try { CreateTargetFolderPathIfNecessary fileCopyCount = 0 while (fileCopyCount < PhotoFileCopyMultiplicationFactor) { MakeNewTargetFileName CopySourceFileToTheTargetFolderUnderTheNewName fileCopyCount += 1 } } catch { } }

var sourceFiles = FolderVisitor.Visit (sourceFolder);sourceFiles.Sort(Photo.ByDateTaken);foreach (var sourceFile in sourceFiles) { try { CreateTargetFolderPathIfNecessary fileCopyCount = 0 while (fileCopyCount < PhotoFileCopyMultiplicationFactor) { MakeNewTargetFileName CopySourceFileToTheTargetFolderUnderTheNewName fileCopyCount += 1 } } catch{ } }

public static class FolderVisitor { public static List<FileInfo> Visit(string rootFolder) { return DoVisitFolder(rootFolder); } private static List<FileInfo> DoVisitFolder(string folder) { var files = new List<FileInfo>(); var thisFolder = new DirectoryInfo(folder); files.Add(thisFolder.EnumerateFiles()); var subFolders = thisFolder.EnumerateFolders(); foreach (var folder in subFolders) { files.Add(DoVisitFolder(subfolder.FullName)); } return files; }}

public static class Photo { public static int ByDateTaken (FileInfo f1, FileInfo f2) { if (f1 == null && f2 == null) { return 0; } else if (f1 == null) { return -1; } else if (f2 == null) { return 1; } return Photo.DateTaken(f1).CompareTo(Photo.DateTaken(f1)); } private static DateTime DateTaken(FileInfo f) { DateTime dateTaken = DateTime.Now; try { using (var reader = ExifReader (f.FullName)) { reader.GetTagValue<DateTime>( ExifTags.DateTimeDigitized, our dateTaken); } } catch (IOException) {} return dateTaken; }}

Add files from the current folder.Recursively add files from subfolders.

Open source Exif Library – read EXIF tag from the photo file.

Programming Example – functional approach

• Make the list of source files• Sort the source file list by picture date taken• Make the list of pairs - source file and target

folder path• Make the list of tuples – boolean flag

indicating sucessful file copy, source file, copy operation status (destination path or error message)

Programmer focus on what information is desired and what transformations are required.

• Sort the source file list by picture date taken• Make the list of pairs - source file and target

folder path• Make the list of tuples – boolean flag

indicating sucessful file copy, source file, copy operation status (destination path or error message)

• Make the list of source filesvar sourceFiles = FolderVisitor.Visit (sourceFolder);

type public FileVisitor() = static member private folderFiles folderPath filter = let emptyDirectory = List.Empty.AsEnumerable() let dirInfo = new DirectoryInfo(folderPath) try dirInfo.EnumerateFiles(filter) with | :? ArgumentException -> emptyDirectory | :? DirectoryNotFoundException -> emptyDirectory | :? SecurityException -> emptyDirectory | :? UnauthorizedAccessException -> emptyDirectory static member private subFolders folderPath = let dirInfo = new DirectoryInfo(folderPath) let noSubFolders = List.Empty.AsEnumerable() try dirInfo.EnumerateDirectories() with | :? DirectoryNotFoundException -> noSubFolders | :? SecurityException -> noSubFolders | :? UnauthorizedAccessException -> noSubFolders static member public Visit rootFolder fileNameFilter = seq { yield! FileVisitor.folderFiles rootFolder fileNameFilter for subFolder in FileVisitor.subFolders rootFolder do yield! FileVisitor.Visit subFolder.FullName fileNameFilter }

A sequence is a logical series of elements all of one type. Sequences are particularly useful when you have a large, ordered collection of data but do not necessarily expect to use all the elements. Individual sequence elements are computed only as required, so a sequence can provide better performance than a list in situations in which not all the elements are used.

var sourceFiles = FolderVisitor.Visit (sourceFolder);

IEnumerable<FileInfo>

• Make the list of pairs - source file and target folder path

• Make the list of tuples – boolean flag indicating sucessful file copy, source file, copy operation status (destination path or error message)

var sourceFiles = FolderVisitor.Visit (sourceFolder);• Sort the source file list by picture date takenvar sortedFiles = FolderVisitor.Visit (sourceFolder) .OrderBy(Photo.DateTaken);

IEnumerable<FileInfo>

public static class Photo { public static DateTime DateTaken(FileInfo f) { DateTime dateTaken = DateTime.Now; try { using (var reader = ExifReader (f.FullName)) { reader.GetTagValue<DateTime>( ExifTags.DateTimeDigitized, our dateTaken); } } catch (IOException) {} return dateTaken; }}

• Make the list of pairs - source file and target folder path

var sortedFiles = FolderVisitor.Visit (sourceFolder) .OrderBy(Photo.DateTaken);


var copier =new FileCopier(targetFolder, baseName, seqStart, noCopies);var toBeCopiedFiles = FolderVisitor.Visit (sourceFolder) .OrderBy(Photo.DateTaken) .SelectMany(copier.MakeTargetPath);

public class FileCopier { private readonly string _targetFolder; private readonly string _baseName; private readonly int _noOfCopies; private int _sequenceNo; public FileCopier(string targetFolder, string baseName, int seqStart, int noOfCopies) { _targetFolder = targetFolder; _baseName = baseName; _noOfCopies = noOfCopies; _sequenceNo = seqStart; } public IEnumerable<Tuple<FileInfo, string>> MakeTargetPath(FileInfo file) { var result = new List<Tuple<FileInfo, string>(); for (var i = 0; i < _noOfCopies; ++i) { var newFileName = string.Format(„{0}{1}{2}”, _baseName, _sequenceNo, Path.GetExtension(file.Name)); var realtivePath = file.Directory.FullName.SubString(_targetFolder.Length); var targetPath = Path.Combine(_targetFolder, relativePath, newFileName); result.Add(new Tuple<FileInfo, string>(file, targetPath)); _sequenceNo += 1; } return result; }}


IEnumerable<Tuple<FileInfo, string>>

Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence.

public static IEnumerable<TResult> SelectMany<TSource, TResult>( this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)

Programming Example – Object-Oriented vs Functional approach

var sourceFiles = FolderVisitor.Visit (sourceFolder);sourceFiles.Sort(Photo.ByDateTaken);foreach (var sourceFile in sourceFiles) { try { FolderHelper.MaterializeFolder(targetFolder, sourceFile.Directory.FullName); fileCopyCount = 0 while (fileCopyCount < noOfCopies) { FolderHelper.CopyFile(targetFolder, sourceFile, newFileNameBase, sequenceNo); fileCopyCount += 1; sequenceNo += 1; } } catch{ } }

var copier = new FileCopier(targetFolder, baseName, seqStart, noCopies);var fileCopyStatus = FolderVisitor.Visit (sourceFolder) .OrderBy(Photo.DateTaken) .SelectMany(copier.MakeTargetPath) .SelectMany(copier.CopyFile);var fileCopyObserver = new FileCopyObserver();fileCopyStatus.Subscribe (fileCopyObserver);Console.WriteLine(fileCopyObserver.Summary());Loops

State

Exceptions

Sequences

Functions

Observations

Control statements, state changesFunction call compositionControlling Complexity By

Controlling Complexity

Composition

Composition is the key to controlling complexity in software.

Expert programmers control the complexity of their designs by combining primitive elements to form compound objects, they abstract compound objects to form higher-level building blocks.

One form of composition, function composition, describes the dependencies between function calls.

Function Composition

Function composition takes two functions and passes the result of the second function as the argument of the first function – effectively creating one function taking argument of the second function and returning result of the first function.

public static Func<T, V> Compose<T, U, V>(this Func<U, V> f, Func<T, U> g) {

return x => f(g(x));

}

Anonymous function (lambda) calling second function (g) with argument x and

passing its result as first function (f) argument, and returning the result of the first function.

Function Composition

var r = f(g(x))

•Explicit dependency between f and g

var r = f.Compose(g)(x)

•Abstracted dependency between f and g

Abstract compound objects to form higher-level building blocks

Function Composition Laws

•Identity.Compose(f) = fLeft identity

•f.Compose(Identity) = fRight identity

•f.Compose(g.Compose(h) = (f.Compose(g)).Compose(h)

Associative

public static T Identity<T>(this T value){ return value;}

Function Composition – sometimes values are not enough

Generic (constructed) types package (amplify) values (integers, strings, objects of class T)

The type IEnumerable<T> represents a lazily computed list of values of type T

The type IEnumerable<T> packages (amplifies) the type T

Function Composition with IEnumerable<T>

public static Func<T, IEnumerable<V>> Compose<T, U, V>(

this Func<U, IEnumerable<V>> f,

Func<T, IEnumerable> g)

{

return x => f(g(x));

}

Error – g(x) returns IEnumerable while f takes U

We need to bind the result of g(x) with the function f. Binding will

iterate over a list returned by g(x) and pass individual list items to

the function f. The result of binding g(x) to the function f is a list of

results returned by the function f.

public static Func<T, IEnumerable<V>> Compose<T, U, V>(

this Func<U, IEnumerable<V>> f,

Func<T, IEnumerable> g)

{

return x => g(x).Bind(f);

}

public static IEnumerable<V> Bind ( this IEnumerable m, Func<U, IEnumerable<V>> f)

public static IEnumerable<V> Bind (this IEnumerable items, Func<U, IEnumerable<V>> f){ var result = new List<V>(); foreach (var item in items) { result.Add(f(item)); } return result;}

Function Composition with IEnumerable<T>

• Our Bind function allows the function f to use IEnumerable returned by the function g• We need some function converting a type T to IEnumverable<T>

public static IEnumerable<T> Unit (this T value)

• Together the amplified type IEnumerable<T>, the function Bind, and the function Unit enable function composition with amplified values

A type

A Unit functi

on

A Bind functi

on

Monad

Monads enable function composition with amplified values

Monads Satisfy Function Composition Laws

•Unit(v).Bind(f) = f(v)Left identity

•m.Bind(Unit) = mRight identity

• m.Bind(x => k(x).Bind(y => h(y)) = m.Bind(x =>k(x)).Bind(y => h(y))Associative

Creating a Monad

To define a particular monad, the writer supplies the triple (a Type, a Unit function, and a Bind function), thereby specyfying the mechanics of the aplified values

IEnumerable<T> Monad

IEnumerable<T> Monad

SelectMany function

AsEnumerable function

Type T


• Is it worth an effort?• Maybe it is• The Maybe monad is an example of a monadic

container type wrapping a value. The container can either have a value or have missing value. The Maybe monad is a better nullable type.

C# Functional Programming – Maybe monad

public class Maybe<T> { public readonly static Maybe<T> Nothing = new Maybe<T>();

public bool IsNothing { get; private set; }

public T Just { get; private set; }

public Maybe() { IsNothing = true; Just = default(T); }

public Maybe(T value) { IsNothing = false; Just = value; }

public new string ToString() { if (IsNothing) { return "Nothing"; } return Just.ToString(); } }

Nothing represents all instances lacking a value.

Just the value if we have one.

We have the type. Now we need the Unit and Bind functions to have the Maybe monad.The Unit function which we call AsMaybe, wraps a value.The Bind function which we call SelectMany, takes a Maybe instance and if there is a value then it applies the delegate to the contained value. Otherwise, it returns Nothing.

Maybe monad – Unit and Bind functions

public static class MaybeExtensions {

public static Maybe<T> AsMaybe<T> (this T value){ return new Maybe<T>(value); }

public static Maybe SelectMany<T, U>(this Maybe<T> m, Func<T, Maybe> doSemthingWith) { if (m == null) { return Maybe.Nothing; } if (m.IsNothing) { return Maybe.Nothing; } try { return doSomethingWith(m.Just); } catch (Exception) { return Maybe.Nothing; } }}

The Unit function which we call AsMaybe, wraps a value.The Bind function which we call SelectMany, takes a Maybe instance and if there is a value then it applies the delegate to the contained value. Otherwise, it returns Nothing.

The delegate takes the un-wrapped value of the type T and returns wrapped (amplified) value of the type U – we can bind another delegate to ther result Maybe.

Maybe monad – usage examples

var maybeStringArray = (new string[] {„Ala”, „ma”, „kota”}).AsMaybe();

var maybeResult = maybeStringArray .SelectMany(x => x.FirstOrDefault(s => s.Equals(„Ala”)).AsMaybe()) .SelectMany(s => s.ToUpperInvariant().AsMaybe());Console.WriteLine(maybeResult.ToString());

maybeResult = maybeStringArray .SelectMany(x => x.FirstOrDefault(s => s.Equals(„Ola”)).AsMaybe()) .SelectMany(s => s.ToUpperInvariant().AsMaybe());Console.WriteLine(maybeResult.ToString());

Writes ALA.

Writes Nothing.

Maybe<string>

Questions