Functional concepts in C#

Functional Concepts in C#

Or “Who the F# Wrote This?”

https://github.com/mrdrbob/sd-code-camp-2016

Thanks Sponsors!

Let’s Manage Expectations!

What this talk is

A gentle introduction to functional paradigms using a language you may already be familiar with.

A comparison between OOP and functional styles

A discussion on language expectations

What this talk isn’t

“OOP is dead!”

“Functional all the things!”

“All code should look exactly like this!” (Spoiler: it probably shouldn’t)

Who I am

Bob Davidson

C# / Web Developer 11 years

Blend Interactive

A guy who is generally interested in and learning about functional programming concepts

https://github.com/mrdrbob

Who I am Not

A functional programming expert who says things like:

“All told, a monad in X is just a monoid in the category of endofunctors of X, with product ×replaced by composition of endofunctors and unit set by the identity endofunctor.”-Saunders Mac Lane

Let’s Build a Parser!

A highly simplified JSON-like syntax for strings and integers.

IntegersOne or more digits

StringsStarts & ends with double quote.Quotes can be escaped with slash.Slash can be escaped with slash.

Can be empty.

Iteration 1.0

The IParser<TValue> Interface

public interface IParser<TValue> {

bool TryParse(string raw, out TValue value);

}

IntegerParserpublic class IntegerParser : IParser<int> {

public bool TryParse(string raw, out int value) {

value = 0;

int x = 0;

List<char> buffer = new List<char>();

while (x < raw.Length && char.IsDigit(raw[x])) {

buffer.Add(raw[x]);

x += 1;

}

if (x == 0)

return false;

// Deal with it.

value = int.Parse(new string(buffer.ToArray()));

return true;

}

}

IntegerParserpublic class IntegerParser : IParser<int> {


value = 0;

int x = 0;



buffer.Add(raw[x]);

x += 1;

}

if (x == 0)

return false;


return true;

}

}

StringParserpublic class StringParser : IParser<string> {

public bool TryParse(string raw, out string value) {value = null;

int x = 0;if (x == raw.Length || raw[x] != '"')

return false;

x += 1;

List<char> buffer = new List<char>();while (x < raw.Length && raw[x] != '"') {

if (raw[x] == '\\') {x += 1;if (x == raw.Length)

return false;

if (raw[x] == '\\')buffer.Add(raw[x]);

else if (raw[x] == '"')buffer.Add(raw[x]);

elsereturn false;

} else {buffer.Add(raw[x]);

}

x += 1;}

if (x == raw.Length)return false;

x += 1;value = new string(buffer.ToArray());return true;

}}

Possible Issues

public class StringParser : IParser<string> {public bool TryParse(string raw, out string value) {

value = null;

int x = 0;if (x == raw.Length || raw[x] != '"')

return false;

x += 1;

List<char> buffer = new List<char>();while (x < raw.Length && raw[x] != '"') {

if (raw[x] == '\\') {x += 1;if (x == raw.Length)

return false;

if (raw[x] == '\\')buffer.Add(raw[x]);

else if (raw[x] == '"')buffer.Add(raw[x]);

elsereturn false;

} else {buffer.Add(raw[x]);

}

x += 1;}

if (x == raw.Length)return false;

x += 1;value = new string(buffer.ToArray());return true;

}}

Repeated checks against running out of input

Easily missed logic for moving input forward

No way to see how much input was consumed / how much is left

Hard to understand at a glance what is happening

public class IntegerParser : IParser<int> {


value = 0;

int x = 0;



buffer.Add(raw[x]);

x += 1;

}

if (x == 0)

return false;

// Deal with it.


return true;

}

}

Rethinking the ParserMake a little more generic / reusable

Break the process down into a series of rules which can be composed to make new parsers from existing parsers

Build a framework that doesn’t rely on strings, but rather a stream of tokens

Iteration 2.0

Composition

[Picture of Legos Here]

One or More Times

A Parser Built on Rules (Integer Parser)

[0-9]

Ignore Latter

Keep Latter

Zero or More Times

Any of these

NotKeep Latter

A Parser Built on Rules (String Parser)

“

\ “

Keep Latter

\ \

Any of these

\ “

“

A Set of Rules

Match QuoteMatch SlashMatch Digit

Match Then KeepMatch Then IgnoreMatch AnyMatch Zero or More TimesMatch One or More TimesNot

Rethinking the SourceHandle tokens other than chars (such as byte streams, pre-lexed tokens, etc)

Need the ability to continue parsing after a success

Need the ability to reset after a failure

Rethinking the Sourcepublic interface ISource<Token> {

Token Current { get; }

bool HasMore { get; }

int CurrentIndex { get; }

void Move(int index);

}

public class StringSource : ISource<char> {

readonly string value;

int index;

public StringSource(string value) { this.value = value; }

public char Current => value[index];

public int CurrentIndex => index;

public bool HasMore => index < value.Length;

public void Move(int index) => this.index = index;

}

Creating a Rulepublic interface IRule<Token, TResult> {

bool TryParse(ISource<Token> source, out TResult result);

}

Char Matches...public class CharIsQuote : IRule<char, char> {

public bool TryParse(ISource<char> source, outchar result) {

result = default(char);if (!source.HasMore)

return false;if (source.Current != '"')

return false;result = source.Current;source.Move(source.CurrentIndex + 1);return true;

}}

public class CharIs : IRule<char, char> {readonly char toMatch;public CharIs(char toMatch) { this.toMatch =

toMatch; }public bool TryParse(ISource<char> source, out char

result) {result = default(char);if (!source.HasMore)

return false;if (source.Current != toMatch)


}}

Char Matches...public abstract class CharMatches : IRule<char, char> {

protected abstract bool IsCharMatch(char c);

public bool TryParse(ISource<char> source, out char result) {result = default(char);if (!source.HasMore)

return false;if (!IsCharMatch(source.Current))


}}

public class CharIsDigit : CharMatches {protected override bool IsCharMatch(char c) => char.IsDigit(c);

}

public class CharIs : CharMatches {

readonly char toMatch;

public CharIs(char toMatch) { this.toMatch = toMatch; }

protected override bool IsCharMatch(char c) => c == toMatch;

}

First Match (or Any)public class FirstMatch<Token, TResult> : IRule<Token, TResult> {

readonly IRule<Token, TResult>[] rules;public FirstMatch(IRule<Token, TResult>[] rules) { this.rules = rules; }

public bool TryParse(ISource<Token> source, out TResult result) {foreach(var rule in rules) {

int originalIndex = source.CurrentIndex;if (rule.TryParse(source, out result))

return true;source.Move(originalIndex);

}

result = default(TResult);return false;

}}

Match Then... public abstract class MatchThen<Token, TLeft, TRight, TOut> : IRule<Token, TOut> {readonly IRule<Token, TLeft> leftRule;readonly IRule<Token, TRight> rightRule;

protected abstract TOut Combine(TLeft leftResult, TRight rightResult);

public MatchThen(IRule<Token, TLeft> leftRule, IRule<Token, TRight> rightRule) {this.leftRule = leftRule;this.rightRule = rightRule;

}

public bool TryParse(ISource<Token> source, out TOut result) {int originalIndex = source.CurrentIndex;result = default(TOut);TLeft leftResult;if (!leftRule.TryParse(source, out leftResult)) {

source.Move(originalIndex);return false;

}

TRight rightResult;if (!rightRule.TryParse(source, out rightResult)) {


}

result = Combine(leftResult, rightResult);return true;

}}

Match Then...

public class MatchThenKeep<Token, TLeft, TRight> : MatchThen<Token, TLeft, TRight, TRight> {public MatchThenKeep(IRule<Token, TLeft> leftRule, IRule<Token, TRight> rightRule) : base(leftRule, rightRule) { }

protected override TRight Combine(TLeft leftResult, TRight rightResult) => rightResult;}

public class MatchThenIgnore<Token, TLeft, TRight> : MatchThen<Token, TLeft, TRight, TLeft> {public MatchThenIgnore(IRule<Token, TLeft> leftRule, IRule<Token, TRight> rightRule) : base(leftRule, rightRule) { }

protected override TLeft Combine(TLeft leftResult, TRight rightResult) => leftResult;}

Invert Rule (Not)public class Not<Token, TResult> : IRule<Token, Token> {

readonly IRule<Token, TResult> rule;public Not(IRule<Token, TResult> rule) { this.rule = rule; }

public bool TryParse(ISource<Token> source, out Token result) {result = default(Token);if (!source.HasMore)

return false;

int originalIndex = source.CurrentIndex;TResult throwAwayResult;bool matches = rule.TryParse(source, out throwAwayResult);if (matches){


}

source.Move(originalIndex);result = source.Current;source.Move(originalIndex + 1);return true;

}}

Spot the bug!

Many (Once, Zero, and more times)public class Many<Token, TResult> : IRule<Token, TResult[]> {

readonly IRule<Token, TResult> rule;readonly bool requireAtLeastOne;

public Many(IRule<Token, TResult> rule, bool requireAtLeastOne) { this.rule = rule; this.requireAtLeastOne = requireAtLeastOne; }

public bool TryParse(ISource<Token> source, out TResult[] results) {List<TResult> buffer = new List<TResult>();while (source.HasMore) {

int originalIndex = source.CurrentIndex;TResult result;bool matched = rule.TryParse(source, out result);if (!matched) {

source.Move(originalIndex);break;

}

buffer.Add(result);}

if (requireAtLeastOne && buffer.Count == 0) {results = null;return false;

}

results = buffer.ToArray();return true;

}}

Map Resultpublic abstract class MapTo<Token, TIn, TOut> : IRule<Token, TOut> {

readonly IRule<Token, TIn> rule;protected MapTo(IRule<Token, TIn> rule) { this.rule = rule; }

protected abstract TOut Convert(TIn value);

public bool TryParse(ISource<Token> source, out TOut result) {result = default(TOut);

int originalIndex = source.CurrentIndex;TIn resultIn;if (!rule.TryParse(source, out resultIn)) {


}

result = Convert(resultIn);return true;

}}

Map Resultpublic class JoinText : MapTo<char, char[], string> {

public JoinText(IRule<char, char[]> rule) : base(rule) { }

protected override string Convert(char[] value) => new string(value);

}

public class MapToInteger : MapTo<char, string, int> {

public MapToInteger(IRule<char, string> rule) : base(rule) { }

protected override int Convert(string value) => int.Parse(value);

}

Putting the blocks together

var quote = new CharIs('"');var slash = new CharIs('\\');var escapedQuote = new MatchThenKeep<char, char, char>(slash, quote);var escapedSlash = new MatchThenKeep<char, char, char>(slash, slash);var notQuote = new Not<char, char>(quote);

var insideQuoteChar = new FirstMatch<char, char>(new[] {(IRule<char, char>)escapedQuote,escapedSlash,notQuote

});

var insideQuote = new Many<char, char>(insideQuoteChar, false);

var insideQuoteAsString = new JoinText(insideQuote);var openQuote = new MatchThenKeep<char, char, string>(quote, insideQuoteAsString);var fullQuote = new MatchThenIgnore<char, string, char>(openQuote, quote);

var source = new StringSource(raw);

string asQuote;if (fullQuote.TryParse(source, out asQuote))

return asQuote;

source.Move(0);int asInteger;if (digitsAsInt.TryParse(source, out asInteger))

return asInteger;

return null;

var digit = new CharIsDigit();var digits = new Many<char, char>(digit, true);var digitsString = new JoinText(digits);var digitsAsInt = new MapToInteger(digitsString);

A Comparison

What an Improvement!

A Comparison (just the definition)

Room for Improvementpublic abstract class MatchThen<Token, TLeft, TRight, TOut> : IRule<Token, TOut> {

readonly IRule<Token, TLeft> leftRule;readonly IRule<Token, TRight> rightRule;

protected abstract TOut Combine(TLeft leftResult, TRight rightResult);

public MatchThen(IRule<Token, TLeft> leftRule, IRule<Token, TRight> rightRule) {this.leftRule = leftRule;this.rightRule = rightRule;

}

public bool TryParse(ISource<Token> source, out TOut result) {int originalIndex = source.CurrentIndex;result = default(TOut);TLeft leftResult;if (!leftRule.TryParse(source, out leftResult)) {


}



}


}}

Out parameter :(

Managing the source’s index

Iteration 2.1

Immutability

An Immutable Sourcepublic interface ISource<Token> {



int CurrentIndex { get; }

void Move(int index);

}

public interface ISource<Token> {



ISource<Token> Next();

}

An Immutable Source



int index;

public StringSource(string value) {

this.value = value; }


public int CurrentIndex => index;


public void Move(int index) => this.index = index;

}



readonly int index;

public StringSource(string value, int index = 0) {

this.value = value; this.index = index; }



public ISource<char> Next() =>

new StringSource(value, index + 1);

}

Ditch the Outpublic class Result<Token, TValue> {

public bool Success { get; }public TValue Value { get; }public string Message { get; }public ISource<Token> Next { get; }

public Result(bool success, TValue value, string message, ISource<Token> next) {Success = success;Value = value;Message = message;Next = next;

}}

public interface IRule<Token, TValue> {

Result<Token, TValue> TryParse(ISource<Token> source);

}



public bool TryParse(ISource<char> source, out char result) {result = default(char);if (!source.HasMore)

return false;if (!IsCharMatch(source.Current))


}}

public abstract class CharMatches : IRule<char, char> {


public Result<char, char> TryParse(ISource<char> source) {

if (!source.HasMore)

return new Result<char, char>(false, '\0', "Unexpected EOF", null);

if (!IsCharMatch(source.Current))

return new Result<char, char>(false, '\0', $"Unexpected char: {source.Current}", null);

return new Result<char, char>(true, source.Current, null, source.Next());

}

}

These Don’t Change

public class CharIsDigit : CharMatches {protected override bool IsCharMatch(char c) => char.IsDigit(c);

}

public class CharIs : CharMatches {

readonly char toMatch;

public CharIs(char toMatch) { this.toMatch = toMatch; }

protected override bool IsCharMatch(char c) => c == toMatch;

}

First Match public class FirstMatch<Token, TResult> : IRule<Token, TResult> {

readonly IRule<Token, TResult>[] rules;public FirstMatch(IRule<Token, TResult>[] rules) { this.rules = rules; }

public bool TryParse(ISource<Token> source, out TResult result) {foreach(var rule in rules) {

int originalIndex = source.CurrentIndex;if (rule.TryParse(source, out result))

return true;source.Move(originalIndex);

}

result = default(TResult);return false;

}}

public class FirstMatch<Token, TResult> : IRule<Token, TResult> {readonly IRule<Token, TResult>[] rules;public FirstMatch(IRule<Token, TResult>[] rules) { this.rules = rules; }

public Result<Token, TResult> TryParse(ISource<Token> source) {foreach (var rule in rules) {

var result = rule.TryParse(source);if (result.Success)

return result;}

return new Result<Token, TResult>(false, default(TResult), "No rule matched", null);}

}

Match Then...public bool TryParse(ISource<Token> source, out TOut result) {

int originalIndex = source.CurrentIndex;result = default(TOut);TLeft leftResult;if (!leftRule.TryParse(source, out leftResult)) {


}



}


}

public Result<Token, TOut> TryParse(ISource<Token> source) {var leftResult = leftRule.TryParse(source);if (!leftResult.Success)

return new Result<Token, TOut>(false, default(TOut), leftResult.Message, null);

var rightResult = rightRule.TryParse(leftResult.Next);if (!rightResult.Success)

return new Result<Token, TOut>(false, default(TOut), rightResult.Message, null);

var result = Combine(leftResult.Value, rightResult.Value);return new Result<Token, TOut>(true, result, null, rightResult.Next);

}

Invert Rule (Not)public class Not<Token, TResult> : IRule<Token, Token> {

readonly IRule<Token, TResult> rule;public Not(IRule<Token, TResult> rule) { this.rule = rule; }

public bool TryParse(ISource<Token> source, out Token result) {result = default(Token);if (!source.HasMore)

return false;

int originalIndex = source.CurrentIndex;TResult throwAwayResult;bool matches = rule.TryParse(source, out throwAwayResult);if (matches){


}

source.Move(originalIndex);result = source.Current;source.Move(originalIndex + 1);return true;

}}

public class Not<Token, TResult> : IRule<Token, Token> {readonly IRule<Token, TResult> rule;public Not(IRule<Token, TResult> rule) { this.rule = rule; }

public Result<Token, Token> TryParse(ISource<Token> source) {if (!source.HasMore)

return new Result<Token, Token>(false, default(Token), "Unexpected EOF", null);


return new Result<Token, Token>(false, default(Token), "Unexpected match", null);

return new Result<Token, Token>(true, source.Current, null, source.Next());

}}

Getting Better, but...

Still Room for Improvement

public class Result<Token, TValue> {public bool Success { get; }public TValue Value { get; }public string Message { get; }public ISource<Token> Next { get; }

public Result(bool success, TValue value, string message, ISource<Token> next) {Success = success;Value = value;Message = message;Next = next;

}}

Only valid when Success = true

Only valid when Success = false

Iteration 2.2

Discriminated Unions and Pattern Matching (sorta)

Two States (Simple “Result” Example)

public interface IResult { }

public class SuccessResult<TValue> : IResult {

public TValue Value { get; }

public SuccessResult(TValue value) { Value = value; }

}

public class ErrorResult : IResult {

public string Message { get; }

public ErrorResult(string message) { Message = message; }

}

Two States (The Matching)

IResult result = ParseIt();

if (result is SuccessResult<string>) {

var success = (SuccessResult<string>)result;

Console.WriteLine($"SUCCESS: {success.Value}");

} else if (result is ErrorResult) {

var error = (ErrorResult)result;

Console.WriteLine($"ERR: {error.Message}");

}

Pattern Matching(ish)public interface IResult<TValue> {

T Match<T>(Func<SuccessResult<TValue>, T> success,Func<ErrorResult<TValue>, T> error);

}

public class SuccessResult<TValue> : IResult<TValue> {public TValue Value { get; }public SuccessResult(TValue value) { Value = value; }public T Match<T>(Func<SuccessResult<TValue>, T> success,

Func<ErrorResult<TValue>, T> error) => success(this);}

public class ErrorResult<TValue> : IResult<TValue>{

public string Message { get; }public ErrorResult(string message) { Message = message; }public T Match<T>(Func<SuccessResult<TValue>, T> success,

Func<ErrorResult<TValue>, T> error) => error(this);}

Pattern Matching(ish)

IResult<string> result = ParseIt();

string message = result.Match(

success => $"SUCCESS: ${success.Value}",

error => $"ERR: {error.Message}");

Console.WriteLine(message);

IResult result = ParseIt();

if (result is SuccessResult<string>) {

var success = (SuccessResult<string>)result;

Console.WriteLine($"SUCCESS: {success.Value}");

} else if (result is ErrorResult) {

var error = (ErrorResult)result;

Console.WriteLine($"ERR: {error.Message}");

}

The Match Method Forces us to handle all cases

Gives us an object with only valid properties for that state

The New IResultpublic interface IResult<Token, TValue> {

T Match<T>(Func<FailResult<Token, TValue>, T> fail,Func<SuccessResult<Token, TValue>, T> success);

}

public class FailResult<Token, TValue> : IResult<Token, TValue> {public string Message { get; }public FailResult(string message) { Message = message; }public T Match<T>(Func<FailResult<Token, TValue>, T> fail,

Func<SuccessResult<Token, TValue>, T> success) => fail(this);}

public class SuccessResult<Token, TValue> : IResult<Token, TValue> {public TValue Value { get; }public ISource<Token> Next { get; }

public SuccessResult(TValue value, ISource<Token> next) { Value = value; Next = next; }

public T Match<T>(Func<FailResult<Token, TValue>, T> fail,Func<SuccessResult<Token, TValue>, T> success) => success(this);

}

ISource also Represents Two States

public interface ISource<Token> {



ISource<Token> Next();

}

Only valid when HasMore = true

The New ISourcepublic interface ISource<Token> {

T Match<T>(Func<EmtySource<Token>, T> empty,Func<SourceWithMoreContent<Token>, T> hasMore);

}

public class EmtySource<Token> : ISource<Token> {// No properties! No state! Let's just make it singleton.EmtySource() { }

public static readonly EmtySource<Token> Instance = new EmtySource<Token>();

public T Match<T>(Func<EmtySource<Token>, T> empty,Func<SourceWithMoreContent<Token>, T> hasMore) => empty(this);

}

public class SourceWithMoreContent<Token> : ISource<Token> {readonly Func<ISource<Token>> getNext;

public SourceWithMoreContent(Token current, Func<ISource<Token>> getNext) { Current = current; this.getNext = getNext; }

public Token Current { get; set; }public ISource<Token> Next() => getNext();

public T Match<T>(Func<EmtySource<Token>, T> empty,Func<SourceWithMoreContent<Token>, T> hasMore) => hasMore(this);

}

Make a String Source

public static class StringSource {public static ISource<char> Create(string value, int index = 0) {

if (index >= value.Length)return EmtySource<char>.Instance;

return new SourceWithMoreContent<char>(value[index], () => Create(value, index + 1));}

}

public static ISource<char> Create(string value, int index = 0)=> index >= value.Length

? (ISource<char>)EmtySource<char>.Instance: new SourceWithMoreContent<char>(value[index], () => Create(value, index + 1));

Char Matches... public abstract class CharMatches : IRule<char, char> {


public Result<char, char> TryParse(ISource<char> source) {

if (!source.HasMore)

return new Result<char, char>(false, '\0', "Unexpected EOF", null);

if (!IsCharMatch(source.Current))

return new Result<char, char>(false, '\0', $"Unexpected char: {source.Current}", null);

return new Result<char, char>(true, source.Current, null, source.Next());

}

}

public abstract class CharMatches : IRule<char, char> {protected abstract bool IsCharMatch(char c);

public IResult<char, char> TryParse(ISource<char> source) {var result = source.Match(

empty => (IResult<char, char>)new FailResult<char, char>("Unexpected EOF"),hasMore =>{

if (!IsCharMatch(hasMore.Current))return new FailResult<char, char>($"Unexpected char: {hasMore.Current}");

return new SuccessResult<char, char>(hasMore.Current, hasMore.Next());});

return result;}

}

public IResult<char, char> TryParse(ISource<char> source)

=> source.Match(

empty => new FailResult<char, char>("Unexpected EOF"),

hasMore => IsCharMatch(hasMore.Current)

? new SuccessResult<char, char>(hasMore.Current, hasMore.Next())

: (IResult<char, char>)new FailResult<char, char>($"Unexpected char: {hasMore.Current}")

);

Match Then...

public IResult<Token, TOut> TryParse(ISource<Token> source) {var leftResult = leftRule.TryParse(source);var finalResult = leftResult.Match(

leftFail => new FailResult<Token, TOut>(leftFail.Message),leftSuccess => {

var rightResult = rightRule.TryParse(leftSuccess.Next);var rightFinalResult = rightResult.Match(

rightFail => (IResult<Token, TOut>)new FailResult<Token, TOut>(rightFail.Message),rightSuccess => {

var finalValue = Combine(leftSuccess.Value, rightSuccess.Value);return new SuccessResult<Token, TOut>(finalValue, rightSuccess.Next);

});return rightFinalResult;

});

return finalResult;}

public Result<Token, TOut> TryParse(ISource<Token> source) {var leftResult = leftRule.TryParse(source);if (!leftResult.Success)

return new Result<Token, TOut>(false, default(TOut), leftResult.Message, null);

var rightResult = rightRule.TryParse(leftResult.Next);if (!rightResult.Success)

return new Result<Token, TOut>(false, default(TOut), rightResult.Message, null);

var result = Combine(leftResult.Value, rightResult.Value);return new Result<Token, TOut>(true, result, null, rightResult.Next);

}

public IResult<Token, TOut> TryParse(ISource<Token> source)=> leftRule.TryParse(source).Match(

leftFail => new FailResult<Token, TOut>(leftFail.Message),leftSuccess =>

rightRule.TryParse(leftSuccess.Next).Match(rightFail => (IResult<Token, TOut>)new FailResult<Token, TOut>(rightFail.Message),rightSuccess => new SuccessResult<Token, TOut>(Combine(leftSuccess.Value, rightSuccess.Value),

rightSuccess.Next))

);

Invert Rule (Not)public Result<Token, Token> TryParse(ISource<Token> source) {

if (!source.HasMore)return new Result<Token, Token>(false, default(Token), "Unexpected EOF", null);


return new Result<Token, Token>(false, default(Token), "Unexpected match", null);

return new Result<Token, Token>(true, source.Current, null, source.Next());}

public IResult<Token, Token> TryParse(ISource<Token> source)

=> source.Match(

empty => new FailResult<Token, Token>("Unexpected EOF"),

current => rule.TryParse(current).Match(

fail => new SuccessResult<Token, Token>(current.Current, current.Next()),

success => (IResult<Token, Token>)new FailResult<Token, Token>("Unexpected match")

)

);

That’s nice but...

Let’s Be HonestAll these `new` objects are ugly.



});



AlsoSingle method interfaces are lame*.

It’s effectively a delegate.


IResult<Token, TValue> TryParse(ISource<Token> source);

}

*In a non-scientific poll of people who agree with me, 100% of respondents confirmed this statement. Do not question its validity.

Iteration 3.0

Functions as First Class Citizens

A Rule is a Delegate is a Function


IResult<Token, TValue> TryParse(ISource<Token> source);

}

public delegate IResult<Token, TValue> Rule<Token, TValue>(ISource<Token> source);



public IResult<char, char> TryParse(ISource<char> source)=> source.Match(

empty => new FailResult<char, char>("Unexpected EOF"),hasMore => IsCharMatch(hasMore.Current)

? new SuccessResult<char, char>(hasMore.Current, hasMore.Next()): (IResult<char, char>)new FailResult<char, char>($"Unexpected char: {hasMore.Current}")

);}

public static class Rules {public static Rule<char, char> CharMatches(Func<char, bool> isMatch)

=> (source) => source.Match(empty => new FailResult<char, char>("Unexpected EOF"),hasMore => isMatch(hasMore.Current)

? new SuccessResult<char, char>(hasMore.Current, hasMore.Next()): (IResult<char, char>)new FailResult<char, char>($"Unexpected char: {hasMore.Current}")

);}

public static Rule<char, char> CharIsDigit() => CharMatches(char.IsDigit);public static Rule<char, char> CharIs(char c) => CharMatches(x => x == c);

Then (Keep|Ignore)public static Rule<Token, TOut> MatchThen<Token, TLeft, TRight, TOut>(this Rule<Token, TLeft> leftRule, Rule<Token, TRight> rightRule, Func<TLeft, TRight, TOut> convert)

=> (source) => leftRule(source).Match(leftFail => new FailResult<Token, TOut>(leftFail.Message),leftSuccess =>

rightRule(leftSuccess.Next).Match(rightFail => (IResult<Token, TOut>)new FailResult<Token, TOut>(rightFail.Message),rightSuccess => new SuccessResult<Token, TOut>(convert(leftSuccess.Value, rightSuccess.Value),

rightSuccess.Next))

);

public static Rule<Token, TRight> MatchThenKeep<Token, TLeft, TRight>(this Rule<Token, TLeft> leftRule, Rule<Token, TRight> rightRule)

=> MatchThen(leftRule, rightRule, (left, right) => right);

public static Rule<Token, TLeft> MatchThenIgnore<Token, TLeft, TRight>(this Rule<Token, TLeft> leftRule, Rule<Token, TRight> rightRule)

=> MatchThen(leftRule, rightRule, (left, right) => left);

Not, MapTo, JoinText, MapToIntegerpublic static Rule<Token, Token> Not<Token, TResult>(this Rule<Token, TResult> rule)

=> (source) => source.Match(empty => new FailResult<Token, Token>("Unexpected EOF"),current => rule(current).Match(

fail => new SuccessResult<Token, Token>(current.Current, current.Next()),success => (IResult<Token, Token>)new FailResult<Token, Token>("Unexpected match")

));

public static Rule<Token, TOut> MapTo<Token, TIn, TOut>(this Rule<Token, TIn> rule, Func<TIn, TOut> convert)=> (source) => rule(source).Match(

fail => (IResult<Token, TOut>)new FailResult<Token, TOut>(fail.Message),success => new SuccessResult<Token, TOut>(convert(success.Value), success.Next)

);

public static Rule<char, string> JoinText(this Rule<char, char[]> rule)=> MapTo(rule, (x) => new string(x));

public static Rule<char, int> MapToInteger(this Rule<char, string> rule)=> MapTo(rule, (x) => int.Parse(x));

Example Usage

var quote = Rules.CharIs('"');

var slash = Rules.CharIs('\\');

var escapedQuote = Rules.MatchThenKeep(slash, quote);

var escapedSlash = slash.MatchThenKeep(slash);

The Original 2.0 Definition



});



var source = new StringSource(raw);

string asQuote;if (fullQuote.TryParse(source, out asQuote))

return asQuote;

source.Move(0);int asInteger;if (digitsAsInt.TryParse(source, out asInteger))

return asInteger;

return null;

var digit = new CharIsDigit();var digits = new Many<char, char>(digit, true);var digitsString = new JoinText(digits);var digitsAsInt = new MapToInteger(digitsString);

The Updated 3.0 Definition

var quote = Rules.CharIs('"');var slash = Rules.CharIs('\\');var escapedQuote = slash.MatchThenKeep(quote);var escapedSlash = slash.MatchThenKeep(slash);var notQuote = quote.Not();

var fullQuote = quote.MatchThenKeep(

Rules.FirstMatch(escapedQuote,escapedSlash,notQuote

).Many().JoinText()).MatchThenIgnore(quote);

var finalResult = Rules.FirstMatch(fullQuote.MapTo(x => (object)x),digit.MapTo(x => (object)x)

);

var source = StringSource.Create(raw);

return finalResult(source).Match(fail => null,success => success.Value

);

var integer = Rules.CharIsDigit().Many(true).JoinText().MapToInteger();

A Comparison V1 -> V3

A Comparison V1 -> V3 (Just Definition)

Looks Great!My co-workers are going to kill me

Is it a good idea?

public static Rule<Token, Token> Not<Token, TResult>(this Rule<Token, TResult> rule)=> (source) => source.Match(

empty => new FailResult<Token, Token>("Unexpected EOF"),current => rule(current).Match(

fail => new SuccessResult<Token, Token>(current.Current, current.Next()),success => (IResult<Token, Token>)new FailResult<Token, Token>("Unexpected match")

));

public static Rule<Token, TOut> MapTo<Token, TIn, TOut>(this Rule<Token, TIn> rule, Func<TIn, TOut> convert)=> (source) => rule(source).Match(

fail => (IResult<Token, TOut>)new FailResult<Token, TOut>(fail.Message),success => new SuccessResult<Token, TOut>(convert(success.Value), success.Next)

);

public static Rule<char, string> JoinText(this Rule<char, char[]> rule)=> MapTo(rule, (x) => new string(x));

public static Rule<char, int> MapToInteger(this Rule<char, string> rule)=> MapTo(rule, (x) => int.Parse(x));

Limitations“At Zombocom, the only limit…

is yourself.”

1. Makes a LOT of short-lived objects (ISources, IResults).

2. As written currently, you will end up with the entire thing in memory.

3. Visual Studio’s Intellisense struggles with nested lambdas.

4. Frequently requires casts to solve type inference problems.

5. It’s not very C#.

Let’s Review

Iterations

Iteration 1.0: Procedural

Iteration 2.0: Making Compositional with OOP

Iteration 2.1: Immutability

Iteration 2.2: Discriminated Unions and Pattern Matching

Iteration 3.0: Functions as First Class Citizens

That’s All

Thanks for coming and staying awake!

Functional concepts in C#

Technology

Transcript of Functional concepts in C#