A lecture about type expressiveness using the Either monad in C#. It's a discussion about the problem that arises from a lack of a built-in mechanism that allows you to express that a function is likely to fail. We implement a solution to this problem and see how it allows us to write production-ready code.

1. Shipping
Pseudocode to
Production
Dobromir Nikolov

2. What’s this about

3. RowData ParseRow(ExcelRow row);

4. ExcelRow[] rows = ReadExcelRows();
RowData[] parsedData = rows
.Select(ParseRow)
.ToArray();

5. try
{
ExcelRow[] rows = ReadExcelRows();
RowData[] parsedData = rows
.Select(ParseRow)
.ToArray();
}
catch (ParsingException e)
{
// Handle
}

6. An error report

7. class RowData
{
...
string Error { get; set; }
...
}

8. class ParsingResult
{
RowData Data { get; set; }
string Error { get; set; }
}

9. ExcelRow row = ReadExcelRow();
ParsingResult result = ParseRow(row);
if (result.Error == null)
{
// Do something with result.Data
}
else
{
// Handle the error
}

10. Why?

11. Expressiveness

12. Expressiveness through types

13. Our first expressive function

14. The case - model a function that performs an HTTP
request

15. Details
- HTTP has 62 status codes but only 10 of them mean success
- The chance of receiving an error is 84%
therefore
- The caller should be signaled unambiguously that errors are likely to
occur
- It should be easy for the caller to handle the potential errors

16. How?

17. Communicating through the return type

18. Designing our type

19. Requirements
1. It should be able to contain 2 other types - one that is going to be
returned if the operation went successfully and another one if it failed
a. In the HTTP request case, we would like one type of response if the server returned a
status code of 2XX and another one if it failed
2. It should never be null
a. It makes no sense for a type that signals a likely error to be null as that will lead to even
more errors

20. public struct Either<T, TException>
{
...
public bool HasValue { get; }
...
public static Either<T, TException> Success(T value) =>
new Either<T, TException>(value);
public static Either<T, TException> Error(TException exception) =>
new Either<T, TException>(exception);
}

21. Either<SucessfulHttpResponse, HttpError> PerformHttpRequest(...)

22. Either<SucessfulHttpResponse, HttpError> responseResult =
PerformHttpRequest("GET", "http://someurl.com/");
// ??????

23. public struct Either<T, TException>
{
// Implementation details omitted for brevity
public bool HasValue { get; private set; }
public void Match(Action<T> some, Action<TException> none) =>
HasValue ? some(value) : none(exception);
public TResult Match<TResult>(Func<T, TResult> some, Func<TException, TResult> none) =>
HasValue ? some(value) : none(exception);
}

24. Either<SucessfulHttpResponse, HttpError> responseResult =
PerformHttpRequest("GET", "http://someurl.com/");
// Compiler error
responseResult.Match(
some: response => ...
)

25. Either<SucessfulHttpResponse, HttpError> responseResult =
PerformHttpRequest("GET", "http://someurl.com/");
responseResult.Match(
some: response => /* Happy path */,
none: error => /* Sad path */
)

26. Performing consecutive requests

27. HttpResponse response = HttpRequest(...);
if (response.IsSuccessfull)
{
HttpResponse anotherResponse = HttpRequest(... response.Data);
if (anotherResponse.IsSuccessfull)
{
HttpResponse thirdResponse = HttpRequest(... anotherResponse.Data);
if (thirdResponse.IsSuccessfull)
{
}
}
}

28. var responseResult = HttpRequest(...);
responseResult.Match(
some: response =>
{
var anotherResponseResult = HttpRequest(... response.Data);
anotherResponseResult.Match(
some: anotherResponse =>
{
var thirdResponseResult = HttpRequest(... anotherResponse.Data);
thirdResponseResult.Match(
some: thirdResponse
{
},
error: /* Error handling */
)
},
error: /* Error handling */
)
},
error: /* Error handling */
)

29. // Perform a request
// If the request is successful, perform another request
// If the consequent request is successful, perform another request
// ...

30. // Perform a request
// If the request is successful, perform another request
// If the consequent request is successful, perform another request
// If the consequent request is successful, perform another request

31. // Perform a request
// If the request operation is successful, perform another request operation
// If the consequent request operation is successful, perform another request
operation
// If the consequent request operation is successful, perform another request
operation

32. public struct Either<T, TException>
{
public Either<TResult, TException> Map<TResult>(Func<T, TResult> mapping) =>
Match(
some: value => Either.Success<TResult, TException>(mapping(value)),
none: exception => Either.Error<TResult, TException>(exception)
);
}

33. var responseResult = HttpRequest(...);
responseResult.Map(response =>
{
var anotherResponseResult = HttpRequest(... response.Data);
anotherResponseResult.Map(anotherResponse =>
{
var thirdResponseResult = HttpRequest(... anotherResponse.Data);
thirdResponseResult.Map(thirdResponse =>
{
})
})
})

34. HttpRequest(...).Map(response =>
HttpRequest(... response.Data).Map(anotherResponse =>
HttpRequest(... anotherResponse.Data).Map(thirdResponse =>
HttpRequest(... thirdResponse.Data))))

35. Either<SuccessfulHttpResponse, HttpError> ChainFour() =>
HttpRequest(...).Map(response =>
HttpRequest(... response.Data).Map(anotherResponse =>
HttpRequest(... anotherResponse.Data).Map(thirdResponse =>
HttpRequest(... thirdResponse.Data))))

36. The type of
HttpRequest(...).Map(response =>
HttpRequest(... response.Data).Map(anotherResponse =>
HttpRequest(... anotherResponse.Data).Map(thirdResponse =>
HttpRequest(... thirdResponse.Data))))
is

37. Either<Either<Either<Either<Sucessful
HttpResponse, HttpError>, HttpError>,
HttpError>, HttpError>

38. Either<Either<Either<Either<SucessfulHttpResponse, HttpError>, HttpError>,
HttpError>, HttpError>
->
Either<SucessfulHttpResponse, HttpError>

39. HttpRequest(...).Map(response =>
HttpRequest(... response.Data).Map(anotherResponse =>
HttpRequest(... anotherResponse.Data).Map(thirdResponse =>
HttpRequest(... thirdResponse.Data))))

40. Either<SuccessfulHttpResponse, HttpError>
->
Map the SuccessfulHttpResponse into Either<SuccessfulHttpResponse, HttpError>
->
Either<Either<SuccessfulHttpResponse, HttpError>, HttpError>

41. public struct Either<T, TException>
{
public Either<TResult, TException> Map<TResult>(Func<T, TResult> mapping) =>
Match(
some: value => Either.Success<TResult, TException>(mapping(value)),
none: exception => Either.Error<TResult, TException>(exception)
);
}

42. public struct Either<T, TException>
{
public Either<TResult, TException> FlatMap<TResult>(Func<T, Either<TResult, TException>> mapping) =>
Match(
some: mapping, // We skip wrapping the value into an Either
none: exception => Either.Error<TResult, TException>(exception)
);
}

43. HttpRequest(...).FlatMap(response =>
HttpRequest(... response.Data).FlatMap(anotherResponse =>
HttpRequest(... anotherResponse.Data).FlatMap(thirdResponse =>
HttpRequest(... thirdResponse.Data))))

44. Either<SuccessfulHttpResponse, HttpError> ChainFour() =>
HttpRequest(...).FlatMap(response =>
HttpRequest(... response.Data).FlatMap(anotherResponse =>
HttpRequest(... anotherResponse.Data).FlatMap(thirdResponse =>
HttpRequest(... thirdResponse.Data))))

45. HttpResponse response = HttpRequest(...);
if (response.IsSuccessfull)
{
HttpResponse anotherResponse = HttpRequest(... response.Data);
if (anotherResponse.IsSuccessfull)
{
HttpResponse thirdResponse = HttpRequest(... anotherResponse.Data);
if (thirdResponse.IsSuccessfull)
{
HttpResponse fourthResponse = HttpRequest(... thirdResponse.Data);
if (fourthResponse.IsSuccessfull)
{
}
}
}
}

46. HttpRequest(...).FlatMap(response =>
HttpRequest(... response.Data).FlatMap(anotherResponse =>
HttpRequest(... anotherResponse.Data).FlatMap(thirdResponse =>
HttpRequest(... thirdResponse.Data))))

47. Going into production

48. 1
4
3
5
2

49. // function ProcessDocument userId, category, file
// 1. check if the user is authorized
// 2. store the file into the cloud
// 3. store database log with unique key
// 4. send the unique key to an external service for post-processing

50. Either<User, Error> CheckIfUserIsAuthorized(string userId, string category);
Either<CloudRecord, Error> StoreTheFileIntoTheCloud(File file, string category);
Either<Guid, Error> StoreDatabaseLog(CloudRecord record);
Either<DocumentProcessedResult, Error> SendToExternalService(Guid key);

51. Either<DocumentProcessedResult, Error> ProcessDocument(
string userId,
string category,
File file) =>
CheckIfUserIsAuthorized(userId, category).FlatMap(user =>
StoreTheFileIntoTheCloud(file, category).FlatMap(cloudRecord =>
StoreDatabaseLog(cloudRecord).FlatMap(uniqueKey =>
SendToExternalService(uniqueKey))));

52. Where next?

53. ● Dev Adventures .NET Core template (link)
● A real world API using Either (link)
● A CLI tool for managing your music collection (link)
● A sample application using DDD and event-sourcing with complete
integration tests coverage (link)
● Real life examples of Either in C# (link)

54. Q&A

55. Thanks!