What functional paradigm is this

I am writing some python code and I am implementing a pattern that I have done repeatedly and in numerous languages. I keep thinking this is some sort of functional paradigm, and that this can be implemented functionally (without use of a for loop), but I am not seeing it. Map takes a series and returns a new series. Reduce takes a series and reduces it to a single result. This is neither of those.

The idea of this function below is to repeatedly apply a transformation to a single string. In this case:

1. Replace all uuids
2. then replace all number groups between 5-9 digits
3. There will be more transforms

def to_template(message):
    mappers = [
        ('[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}', '{.uuid}'),
        (' [0-9]{5,9}.', ' {.request_id}.')
    ]
    result = message
    for pattern, replacement in mappers:
        result = re.sub(pattern, replacement, result)

    return result

The questions:

1. Can this be implemented functionally?
2. Is there a known functional paradigm for this?

In functional programming terms, this is a fold: you are folding (i.e., reducing) a list of replacement operations to a single string, with a string as the starting point.

In Python, you can write this using the reduce function in the functools module.

from functools import reduce


def to_template(message):
    mappers = [ ... ]
    return reduce(lambda r, p: re.sub(*p, r), mappers, message)

reduce repeatedly calls re.sub using an element from mappers for the first arguments and the result of the previous call as the second argument. (The first call uses message as the "zeroth" return value of re.sub.)

Recursively, one could implement reduce as

def reduce(f, itr, init):
    if not itr:
        return init
    else:
        return reduce(f, itr[1:], f(init, itr[0]))

Iteratively, it looks much like your function:

def reduce(f, itr, init):
    result = init
    for x in itr:
        result = f(result, x)
    return result

Theoretically, you could also imagine using function composition to fold a list of functions into a single function that gets applied to your message.

from functools import reduce, partial


def to_template(message):
    mappers = [
        partial(re.sub, '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}', '{.uuid}'),
        partial(re.sub, ' [0-9]{5,9}.', ' {.request_id}.')
    ]

    # Apply f first, so that reduce applies functions
    # in the order they appear in the list.
    def compose(f, g):
        return lambda x: g(f(x))

    def identity(x):
        return x

    f = reduce(compose, mappers, identity)
    return f(message)

However, for a large number of mapping operations, you would probably hit the recursion limit with the nested function calls that reduce and compose would build up.