PromptCallbacks design

[kindermannhubert]

After making some changes to PromptCallbacks I think it would be nicer to replace these callbacks with virtual methods.

1. There would be no need for separate definitions of delegates (e.g. CompletionCallbackAsync).
2. It would be easier to provide default implementations of these callbacks.
3. It would be easier to put some logic on top of supplied callbacks.

The current approach is simpler for "toy" applications because you can just set some lambdas to instance of existing PromptCallbacks. But for anything more complex it's an unnecessary hassle to have everything needed in delegate closures.
With the new approach, you would need to implement custom class inheriting PromptCallbacks and override methods that you wish.

(2) and (3) can be nicely seen on PromptCallbacks.SpanToReplaceByCompletionCallback.
Instead of:

public delegate Task<TextSpan> SpanToReplaceByCompletionCallbackAsync(string text, int caret);
public class PromptCallbacks
{
    private SpanToReplaceByCompletionCallbackAsync spanToReplaceByCompletionCallback;

    public PromptCallbacks()
    {
        spanToReplaceByCompletionCallback = GetSpanToReplaceByCompletionAsync;
    }

    public SpanToReplaceByCompletionCallbackAsync SpanToReplaceByCompletionCallback
    {
        get => spanToReplaceByCompletionCallback;
        init
        {
            spanToReplaceByCompletionCallback =
                async (string text, int caret) =>
                {
                    var span = await value(text, caret);
                    //... here goes some validation of resulting span....
                    return span;
                };
        }
    }

    private static Task<TextSpan> GetSpanToReplaceByCompletionAsync(string text, int caret)
    {
        //... here goes some default implementation....
    }
}

we could just have:

public class PromptCallbacks
{
    public async Task<TextSpan> GetSpanToReplaceByCompletion(string text, int caret)
    {
        var span = await GetSpanToReplaceByCompletionImplementation(text, caret);
        //... here goes some validation of resulting span....
        return span;
    }

    protected virtual Task<TextSpan> GetSpanToReplaceByCompletionImplementation(string text, int caret)
    {
        //... here goes some default implementation....
    }
}

We could even use the same name for nonvirtual public and virtual protected methods with use of (possibly internal) interface:

internal interface IPromptCallbacks
{
    Task<TextSpan> GetSpanToReplaceByCompletion(string text, int caret);
}
public class PromptCallbacks : IPromptCallbacks
{
    async Task<TextSpan> IPromptCallbacks.GetSpanToReplaceByCompletion(string text, int caret)
    {
        var span = await GetSpanToReplaceByCompletion(text, caret);
        //... here goes some validation of resulting span....
        return span;
    }

    protected virtual Task<TextSpan> GetSpanToReplaceByCompletion(string text, int caret)
    {
        //... here goes some default implementation....
    }
}

Also, it would probably be a good time to do such a change now when we have already a lot of breaking changes for upcoming release.
Any thoughts @waf?

[waf]

Agreed! Let's make the change in this next release.

The callbacks approach was OK when there were just a few, but I think it's time to go with a class / override approach like you've described.

[kindermannhubert]

Done via #87.