Chaining togther a complex interaction of delegate sequences

Question

This feels quite complicated to ask, and whilst the solution seems simple, the shear mind bogglingness of delegates inside delegates returned from yet more delegates has caused my brain to implode in on itself.

Without further a do, I'll explain:

The scenario is that you have translation delegates (Func[A, B]) and translation behaviours (Func[A, Func[Func[A, B], B]]).

The idea is that around a given translation, you would have a specific set of behaviours that wrap the invocation to the translation, ie- that they take in the A, feel free to do with it what they wish, pass this on to the next behaviour, whilst being able to change the returning value (B).

There is probably some monad to describe this perfectly, but perhaps some code will help more than anything.

The victims:

public class B
{

}

public class A
{

}

The behaviour delegate

public delegate Func<Func<A, B>, B> TranslationBehavior(A input);

The function which should chain them together, and return a Func that allows a translation function to be passed in and get a new translation function which is wrapped by the behaviors

static Func<Func<A, B>, Func<A, B>> Chain(IEnumerable<TranslationBehavior> behaviors)
{
    throw new NotImplementedException();
}

usage scenario

static void Main(string[] args)
{
    var behaviors = new[]
    {
        (TranslationBehavior) (inp => next => next(inp)),
        (TranslationBehavior) (inp => next => next(inp)),
        (TranslationBehavior) (inp => next => next(inp)),
    };

    var input = new A();

    var chained = Chain(behaviors);

    var output = chained(a => new B());

}

In the example code the behaviour implementations don't do anything put call the next behaviour, and our translation implementation simply returns a new B.

The function 'chain' is the problem function, being able to link the behaviours together has eluded me, but to prove to myself this should actually work, I hard coded a naive solution which specifically chains three behaviours together:

static Func<Func<A, B>, Func<A, B>> Chain(IEnumerable<TranslationBehavior> behaviors)
{
    var behavior1 = (TranslationBehavior)null;
    var behavior2 = (TranslationBehavior)null;
    var behavior3 = (TranslationBehavior)null;

    return translation => input =>
        behavior1(input)(transformed1 =>
            behavior2(transformed1)(transformed2 =>
                behavior3(transformed2)(translation)
            )
        );
}

This works, but is obviously; quite useless.

Any help on this would be really useful, and any information on if this is a known pattern or monad would be really interesting, I don't think this code code is far from being generalizable.

Thanks in advance, Stephen.

Answer 1

I didn't fully understand your scenario - without some additional context, it just sounds too complicated :-) However, just from the types, I think the implementation you're looking for is something like this. The trick is to add a method that works with IEnumerator and is recursive:

Func<Func<A, B>, Func<A, B>> Chain
  (IEnumerable<TranslationBehavior> behaviors, Func<A, B> final) {
    return translation => Chain(behaviors.GetEnumerator(), translation);
}

// Recursive method that takes IEnumerator and processes one element..
Func<A, B> Chain
  (IEnumerator<TranslationBehavior> behaviors, Func<A, B> last) {
    if (behaviors.MoveNext())
      return input => behaviors.Current(input)(Chain(behaviors, last));
    else
      return last;
}

You could add exception handling and dispose the enumerator, but this should be the right structure.

Answer 2

The idea is that around a given translation, you would have a specific set of behaviours that wrap the invocation to the translation, ie- that they take in the A, feel free to do with it what they wish, pass this on to the next behaviour, whilst being able to change the returning value (B).

This sentence seems the clearest statement of your problem in the question. It sounds like you have

A -> {Black Box} -> B

and want

A -> pre-process A -> {same Black Box} -> B -> post-process and return B

If that is all you want, I would recommend an interface and an implementation of that interface that wraps another implementation. This seems similar to the Composite or Proxy patterns, though it's not quite either one.

interface ITranslator 
{
    B Transform(A input);
}
class TranslatorWrapper : ITranslator
{
    TranslatorWrapper(ITranslator wrapped)
    {
        _wrapped = wrapped;
    }

    ITranslator _wrapped;

    B Transform(A input)
    {
        //do preprocessing here
        B result = _wrapped.Transform(input);
        //do postprocessing here
        return result;
    }
}

The nice thing here is that you can pass "nest" or "chain" TranslatorWrappers and other similar classes by passing them in the constructor parameters. Depending on the syntax you want, you may want to add some extension methods to provide a more fluid coding style for these wrappers.