Может ли C# неявно преобразовать параметр делегата универсальной функции?

Вы можете свободно говорить, если чувствуете, что вас ограничивают дженерики в C# (которые используют большинство библиотек, таких как LINQ, FluentAssertions и т. д.). Таким образом, вы можете создать свой собственный язык, специфичный для домена:

public class Program
{
    public static void Main()
    {
        bool c = Process.Object(false).Using(x=> !x);
        //or even chain them
        int garbage = Process
            .Object(false)
            .Using(x => !x)
            .Next(x => x ? "a" : null)
            .ThrowIfNull()
            .Next(x => x[0])
            .Do_A_Barrel_Roll()
            .Do_A_Barrel_Roll()
            .Do_A_Barrel_Roll()
            .Next(x => x & 8); //not null as you see

        bool g = Process
            .Object(false)
            .Using(x => x ? x : (bool?)null)
            .ThrowIfNull(); //not null either
    }
}

public class ProcessorInput<TIn>
{
    public Func<TIn> InputProvider { get; set; }
}

public class Processor<TIn, TOut>
{
    public Func<TIn> InputProvider { get; set; }
    public Func<TIn, TOut> OutputProvider { get; set; }
    
    public static implicit operator TOut(Processor<TIn, TOut> processor)
    {
        return processor.Eval();
    }

    public TOut Eval()
    {
        return OutputProvider(InputProvider());
    }
}

public static class Process
{
    public static ProcessorInput<TIn> Object<TIn>(TIn input)
    {
        return Object(() => input);
    }
    public static ProcessorInput<TIn> Object<TIn>(Func<TIn> inputProvider)
    {
        return new ProcessorInput<TIn>() { InputProvider = inputProvider };
    }
    public static Processor<TIn, TOut> Using<TIn, TOut>(this ProcessorInput<TIn> processorInput, Func<TIn, TOut> outputProvider)
    {
        return new Processor<TIn, TOut>()
            { InputProvider = processorInput.InputProvider, OutputProvider = outputProvider };
    }
    public static Processor<TOut, TNextOut> Next<TIn, TOut, TNextOut>(this Processor<TIn, TOut> processor, Func<TOut, TNextOut> nextOutputProvider)
    {
        return new Processor<TOut, TNextOut>
        {
            InputProvider = processor.Eval,
            OutputProvider = nextOutputProvider
        };
    }

    public static Processor<TIn, TOut> Do_A_Barrel_Roll<TIn, TOut>(this Processor<TIn, TOut> processor)
    {
        return new Processor<TIn, TOut>
        {
            InputProvider = processor.InputProvider,
            OutputProvider = (x =>
            {
                Console.WriteLine("Barrel roll!");
                return processor.OutputProvider(x);
            })
        };
    }
    
    public static Processor<TIn, TOut> ThrowIfNull<TIn, TOut>(this Processor<TIn, TOut?> processor)
        where TOut : class
    {
        return new Processor<TIn, TOut>
        {
            InputProvider = processor.InputProvider,
            OutputProvider = (x => processor.OutputProvider(x) ?? throw new ArgumentNullException())
        };
    }
    
    public static Processor<TIn, TOut> ThrowIfNull<TIn, TOut>(this Processor<TIn, TOut?> processor)
        where TOut : struct
    {
        return new Processor<TIn, TOut>
        {
            InputProvider = processor.InputProvider,
            OutputProvider = (x => processor.OutputProvider(x) ?? throw new ArgumentNullException())
        };
    }
}

Я думаю, что лучшее решение, которое вы, вероятно, найдете, — это «Идея 3», используя notnull:

public static TResult Process<TInput, TResult>(TInput input, Func<TInput, TResult?> processor)
    where TResult : struct
{
    return processor(input) ?? throw new Exception();
}

public static TResult Process<TInput, TResult>(TInput input, Func<TInput, TResult?> processor)
    where TResult : notnull
{
    return processor(input) ?? throw new Exception();
}

Проблема, которую вы указали в этом подходе, связана с неявной типизацией, которая является более фундаментальной, чем обобщения: C# не может узнать, что null означает нулевое логическое значение в этом выражении.

var a = true ? true : null;

CS0173: Type of conditional expression cannot be determined because there is no implicit conversion between 'bool' and '<null>'

Поскольку TInput и TResult могут быть разными типами, вам нужно будет дать компилятору подсказку о том, какой тип возвращает ваше выражение:

bool e = Process(false, x => x ? x : (bool?)null);

Надеюсь, это не слишком многословно.