Writing strings to the screen over time
You need a way to specify how the message will be transformed into a sequence, therefore your function should be typed as Func&lt;string, IEnumerable&lt;string&gt;&gt;. And the lambda expressions would look like this:

x =&gt; x.Split(' ')
x =&gt; x.Select(c =&gt; new string(c, 1))


But why pass a delegate for the split-algorithm instead of simply passing the sequence of text pieces directly?

public IEnumerator TypeWordText(IEnumerable&lt;string&gt; pieces, message, Text textComp,
                                bool resetTextComp = false, string separator = "")
{
    if (resetTextComp)
        textComp.text = "";

    foreach (string piece in pieces)
    {
        textComp.text += separator + piece;

        if (textComp.text.Length &gt;= message.Length)
            OnMessageTyped(message);

        yield return new WaitForSeconds(2f);
    }
}


Since in one method you add a space and not in the other, I have added the separator as optional parameter.

I also suggest to transform the char-sequence into a string-sequence (with strings of length one), so that you can always work with strings.

TextTyper.TypeText(message.Split(' '), message, vanishText, true, " ")

TextTyper.TypeText(message.Select(c =&gt; new string(c, 1)), message, vanishText, true)


Note that a string is an IEnumerable&lt;char&gt;. The Selects will be executed lazily at each loop of the foreach-statement. Therefore, in a certain way, you are still passing an algorithm to the method in the second call, but hidden in an enumerator.



Algorithm: But why split the string at all, just in order to recombine it afterwards? Instead of splitting the message, you could keep it as is and keep track of the typed length in an int variable. Then display message.Substring(0, typedLength). This change requires a strategy for the increment of the typed length. See Strategy pattern.

public interface ITypingStrategy
{
    void TypeNext(string message, ref typedLength);
}


Now you can implement different strategies like CharByCharTypingStrategty or WordByWordTypingStrategy as classes. The adapted TypeWordText method would have an ITypingStrategy argument instead of an enumeration of text pieces.