Question: Looking through the source code of a 90s Doom source port (Retrodoom in this case), I found this:

```
void A_Detonate(mobj_t *actor, player_t *player, pspdef_t *psp)
{
    P_RadiusAttack(actor, actor->target, actor->info->damage, false);
}

```

This A\_Detonate function only serves as a caller to the P\_RadiusAttack function, so the question is: why not just use P\_RadiusAttack without a "parent" function?

Answer: 
This is an example of separating the interface from the implementation. So the users of

```
void A_Detonate(mobj_t *actor, player_t *player, pspdef_t *psp)

```

such as yourself can continue to use the same function signature in their code when maybe in the future the maintainers of `A_Detonate` might decide to do something like this

```
void A_Detonate(mobj_t *actor, player_t *player, pspdef_t *psp)
{
    P_DiameterAttack(actor, actor->target, actor->info->damage, false);    
    P_RadiusAttack(actor, actor->target, actor->info->damage, false);
    P_DumbAttack(actor, actor->target, actor->info->damage, false);
}

```

In other words the implementation of the function can change independently but the users of the function are blissfully unaware as they should be.
Judging by arguments, it's a handler. A\_Detonate isn't even using its player object and psp. Existence of such function suggests that somewhere is code that works with such signature, either for unification purposes, as adapter or as a handler.