Shipping Pseudocode to Production VarnaLab

Shipping
Pseudocode to
Production
Dobromir Nikolov

RowData ParseRow(ExcelRow row);

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

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

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

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

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

The case - model a function that performs an HTTP
request

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

Communicating through the return type

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

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);
}

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

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

{
// 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);
}

// Compiler error
responseResult.Match(
some: response => ...
)

some: response => /* Happy path */,
none: error => /* Sad path */
)

Performing consecutive requests

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

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

// If the request is successful, perform another 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

{
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)
);
}

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

Either<SuccessfulHttpResponse, HttpError> ChainFour() =>

The type of
is

Either<Either<Either<Either<Sucessful
HttpResponse, HttpError>, HttpError>,
HttpError>, HttpError>

Either<Either<Either<Either<SucessfulHttpResponse, HttpError>, HttpError>,
HttpError>, HttpError>
->
Either<SucessfulHttpResponse, HttpError>

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

{
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)
);
}

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

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

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)
{
}
}
}
}

// 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

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);

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))));

● 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)

Shipping Pseudocode to Production VarnaLab

More Related Content

What's hot (20)

Similar to Shipping Pseudocode to Production VarnaLab (20)

Recently uploaded (20)

Shipping Pseudocode to Production VarnaLab

Editor's Notes