Converting imperative code as a functional newbie

[adameasten]

Hello!
I've been trying to refactor some imperativ legacy code but i'm having trouble wrapping my head around how to go at it.
I would love some input on how i should approach this code in a more functional manner:

using(var transaction = _queueService.BeginTransaction())
{
    var messages =  _queueService.ReadFromQueue();
    if(messages.Any())
    {
        foreach(var message in messages)
        {
            if(message.Type == EndConversation)
            {
                _queueService.EndConversation(message);
            }
            else
            {
                var converted = _messageConvert.Convert(message);
                _databaseRepository.HandleMessage(converted);
            }
        }
    }
    transaction.Commit();
}

It's so hard to translate imperative control flow when you lack functional/declarative experience!

Thank you,
/Adam

[ngenovese11]

Hey Adam,
Obviously I don't know all the in's and outs of your application, but see some proposed code below (pseudo for the most part and not unit tested).

A couple of notes first:

1. I'd highly recommend reviewing the Wiki. There's great docs about "Thinking Functionally" and "Application Architecture" that will put a lot of this into better context.
2. I've mixed an matched some styles for demonstration purposes (linq query, extension methods). Typically I try and do everything via query syntax but you'll need to find your own rhythm.
3. I'm by no means an expert, this could probably be refactored even further.

        public interface Message
	{
		string Type { get; }
	}

	public interface HasTransactions
	{
		IDbTransaction BeginTransaction();
	}

	public interface HasQueue : HasTransactions
	{
		Seq<Message> ReadFromQueue();
		Fin<Unit> EndConversation(Message message);
	}

	public interface HasMessageHandler
	{
		Fin<Unit> HandleMessage(Message message);
	}

	public static class TransactionModule
	{
		public static Fin<TResult> use<T, TResult>(T disposable, Func<T, Fin<TResult>> f) where T : IDisposable
		{
			using (var d = disposable)
			{
				return f(d);
			}
		}

		public static Fin<T> transact<T>(HasTransactions service, Func<Fin<T>> f) =>
			use(service.BeginTransaction(), transaction =>
			{
				var result = f();
				if (result.IsSucc)
					transaction.Commit();
				else
					transaction.Rollback();

				return result;
			});
	}

	public static class QueueModule
	{
		public static Fin<Seq<Message>> readMessagesFromQueue(HasQueue queue)
		{
			return FinSucc(Seq(queue.ReadFromQueue()));
		}

		public static Fin<Unit> endConversations(
			Seq<Message> messages,
			Func<Message, Fin<Unit>> processConversationEnder)
		{
			return
				messages
					.Filter(message => message.Type == "ConversationEnder")
					.FoldUntil(
						FinSucc(unit),
						(_, message) => processConversationEnder(message),
						result => result.IsFail
					);
		}

		public static Fin<Unit> handleMessages(
			Seq<Message> messages,
			Func<Message, Message> convertMessage,
			Func<Message, Fin<Unit>> handleMessage)
		{
			return
				messages
					.Filter(message => message.Type != "ConversationEnder")
					.Map(convertMessage)
					.FoldUntil(
						FinSucc(unit),
						(_, message) => handleMessage(message),
						result => result.IsFail
					);
		}
	}

	public static class QueueService
	{
		// this can be anything just a pure function that does what you need
		public static Message ConvertMessage(Message message) => message;

		public static Fin<Unit> Run(HasQueue queue, HasMessageHandler handler) =>
			from messages in QueueModule.readMessagesFromQueue(queue)
			from _1 in QueueModule.endConversations(messages, queue.EndConversation)
			from _2 in QueueModule.handleMessages(messages, ConvertMessage, handler.HandleMessage)
			select Unit.Default;

		public static Fin<Unit> RunWithTransaction(
			HasTransactions dbService,
			HasQueue queue,
			HasMessageHandler handler) =>
			from _ in TransactionModule.transact(dbService, () => Run(queue, handler))
			select _;
	}

[ngenovese11]

Also since this is IO, I'd recommend researching Eff/Aff monads once you start getting your head wrapped around the concepts

[adameasten]

Thank you for the answer, ill try it out!
I like the idea of filter and fold to determine which code to be executed after the messages is read from the queue!

[MrYossu]

If you're new to FP, I highly recommend Functional Programming In C# 2nd Edition by Enrico Buonanno. It took me a few readings and a LOT of experiments to get from the completely clueless newbie stage to my current mostly clueless not-quite-so newbie stage, but it's well worth it.

Whilst I'm still a long way from being an expert, my code is much cleaner and more elegant than it used to be, and is much easier to test. I'm actually writing unit tests as I go along, something I always avoided before, and it's really paid off in terms of productivity.

Paul Louth (the author of Language-Ext) was a technical reviewer on the book. My only criticism is that he develops his own library, rather than using Language-Ext, so you sometimes have to work a bit to translate his code into code that works here, but it's not usually that hard.

Most important thing to do is keep going and don't get put off when you get stuck.

[adameasten]

Nice!
I'll give it a read, i really like the idea of testing another paradigm to learn and improve.
This will probably lead to me getting better at programming over all!
Thanks!

[MrYossu]

@adameasten Just don't do what I did at first and read it in the bathroom! I read it twice like that, and thought I was taking it in. When I tried to put it into practice, I realised I didn't really have a clue.

This is one of those books (and subjects) where you need to set aside some time each day (if you can, or as regularly as you can if not) to work on it. Try the code as you read, and make sure to go through the exercises, trying each one. It still takes time, but it goes in bit by bit. Don't be afraid to ask here or on stackoverflow, there are some very clever and helpful people around who understand this stuff really well, and you'll learn a lot from asking.

Most of all - enjoy it! Yes it's frustrating, but you WILL be a better programmer for it.

[EivindAntonsen]

My only criticism is that he develops his own library, rather than using Language-Ext

As far as this point goes, his argument for it in the book makes sense I think. As long as the purpose of the book is to convey concepts (and not offer features), it's beneficial to avoid boilerplate and superfluous functionality for the sake of brevity.

+1 on recommending the book though, it's helped me a lot. especially in my beginner stage where I didn't quite grasp Eithers and union types in general etc.