Dictionary/Collection of generic Delegates

I have want to have a collection of generic delegates, each tied to a different string key (something like a Dictionary<string, delegate<T>>). The delegates take in T and return T, meaning that the return type is the same as the input type, kind of like functional map. This means the type for each individual function is known at compile time. I see no reason why this shouldn't be possible but I haven't found a way to do it.

The main solutions I've seen are to make T an object and then cast it each time, but that's a hassle. Another option is to use dynamic, but that undermines type safety and might bring problems in the long run. There's also the possibility to implement a custom collection, but I'm not sure as to how.

Edit: I want a generic key-value pair where T is a different type for each key/pair.

You can hide the details of storage and provide your own methods to set and get the delegates in a custom class:

public class DelegateDictionary 
{
    private Dictionary<string, object> _entries = new Dictionary<string, object>();

    public void Add<T>(string key, Func<T, T> modifier)
    {
        _entries.Add(key, modifier);            
    }

    public Func<T, T> Get<T>(string key)
    {
        return _entries[key] as Func<T, T>;
    }
}

Usage:

var dictionary = new DelegateDictionary();

dictionary.Add<string>("NameLowerCase", (name) => name.ToLower());
dictionary.Add<int>("AgeIncreaseByFive", (value) => value + 5);

var lowerCasedName = dictionary.Get<string>("NameLowerCase").Invoke("JUAN");
var numberIncreasedByFive = dictionary.Get<int>("AgeIncreaseByFive").Invoke(5);

Console.WriteLine($"JUAN => {lowerCasedName}");
Console.WriteLine($"5 => {numberIncreasedByFive}");

Output:

JUAN => juan
5 => 10

This is an overly simplified example but it should be enough to get you going.

All this being said, when I see something like this, it's usually a code smell worth taking a step back and rethinking why you need this in the first place.

I'm not sure this is possible. The whole point of generics is that when T is used in a context it is the same type for the whole of that context. By using T as part of the value type for the dictionary, you are linking all of the values into the same context, and thus a single type for T.