Чем плохо много return?

if this.cond1():
    return res1
  this.process1();
  if this.cond2():
    return res2

def f():
    res=[sentinel:=object()]
    Done=condact1(u1(..)) and ..... condactN(uN(....)) and res[0]
    return res[0] if Done else Done

    exit_condition, result = steps[1](result)

  if cond1(x):
    return res1
  y = process1(x);

  ex, res = step1(res)
  if ex: return res
  ex, res = step2(res)
  if ex: return res

def __rshift__(self, fn)

sub f {
    $_->[1]() and return $_->[0] for (
        [ 'res 1', sub { cond1($x) } ], 
        [ 'res 2', sub { $y = process1($x); cond2($y) } ], 
        [ 'res 3', sub { cond3($y) } ], 
        [ 'res 4', sub { $z = process2($x, $y); cond4($x,$y,$z) } ], 
        [ 'res 5', sub { cond5($x,$y,$z) } ], 
        [ 'wtf?!', sub { 1 } ],
    );
}

r = res1
if not cond1(x):
    r = res2
    y = process1(x)
    if not cond2(y)
        r = res3
        if not cond3(y):
            r = res4
            z = process2(y)
            if not cond4(z):
                r = res5
                if not cond5(z):
                    ...
return r

Вместо
def find(a, x):
  for s1 in a:
    for s2 in s1:
      for s3 in s2:
        if s3 == x: 
          return True
  return False

def find(a, x):
  res = False
  for s1 in a:
    for s2 in s1:
      for s3 in s2:
        if s3 == x: 
          res = True
  return res

def find(a, x):
    return x in (s3 for s1 in a for s2 in s1 for s3 in s2)

def f(x):
  if cond1(x):
    return res1
  return f_process1(x)

def f_process1(x):
  y = process1(x)
  if cond2(y):
    return res2
  if cond3(y):
    return res3
  return f_process2(x, y)

def f_process2(x, y):
  z = process2(x, y)
  if cond4(x,y,z):
    return res4
  if cond5(x,y,z):
    return res5

def f(x):
    res=object()
    for _ in 1,:#while((a:=1)if'a'not in locals()else locals().__delitem__('a')):
        if cond1(x                    ):res=res1;break
        if cond2(y:=process1(x)       ):res=res2;break
        if cond3(y                    ):res=res3;break
        if cond4(x,y,z:=process2(x, y)):res=res4;break
        if cond5(x,y,z                ):res=res5;break
    return res
#иль же дажь:
def f(x):
    res=object()
    for _ in 1,:
        if 0: ...
        elif cond1(x                    ):res=res1
        elif cond2(y:=process1(x)       ):res=res2
        elif cond3(y                    ):res=res3
        elif cond4(x,y,z:=process2(x, y)):res=res4
        elif cond5(x,y,z                ):res=res5
    return res
#но тадлы:
def f(x):
    res=object()
    if 0: ...
    elif cond1(x                    ):res=res1
    elif cond2(y:=process1(x)       ):res=res2
    elif cond3(y                    ):res=res3
    elif cond4(x,y,z:=process2(x, y)):res=res4
    elif cond5(x,y,z                ):res=res5
    return res

void check_return_count_in_functions_new_token(struct source_file* s, struct token* toks, int tok_idx)
{
  int i = tok_idx;

  if (brace_lvl >= 1)
  {
    if (toks[i].toktyp == KW_RETURN)
       state += 1;
  }
  else
  if (brace_lvl == 0)
    state = 0;

  if (state > MAX_RETURNS_PR_FUNC)
  {
    /* one warning pr. violation is sufficient */
    if (state != state_last_warn)
    {
      state_last_warn = state;

      /* prettier names in the output: '3rd return statement in function' etc. */
      const char* endings[] = { "th", "st", "nd", "rd" };
      const char* ending = endings[0];

      if ((state < 10) || (state > 20))
      {
        if (state % 10 == 1) 
          ending = endings[1];
        else 
        if (state % 10 == 2)
          ending = endings[2];
        else
        if (state % 10 == 3) 
          ending = endings[3];
      };

      fprintf(stdout, "[%s:%d] (style) %d%s return statement in function.\n", s->file_path, toks[i - 1].lineno, state, ending);
    }; // if (state != state_last_warn)
  }; // if (state > MAX_RETURNS_PR_FUNC)

  if (toks[i].toktyp == OP_LBRACE) 
    brace_lvl += 1;
  else 
  if (toks[i].toktyp == OP_RBRACE)
    brace_lvl -= 1;

  if (brace_lvl < 0)
    brace_lvl = 0;
}

from abc import ABC, abstractmethod
from typing import Any, Optional

# Константы для результатов (для примера)
RES1 = "Результат 1"
RES2 = "Результат 2"
RES3 = "Результат 3"
RES4 = "Результат 4"
RES5 = "Результат 5"

class Request:
    """Объект, содержащий данные для обработки и промежуточные результаты."""
    def __init__(self, x):
        self.x = x
        self.y = None  # Результат process1
        self.z = None  # Результат process2

class Handler(ABC):
    """Абстрактный класс Обработчика."""
    def __init__(self, next_handler: Optional['Handler'] = None):
        self._next_handler = next_handler

    def set_next(self, handler: 'Handler') -> 'Handler':
        """Устанавливает следующий обработчик в цепочке."""
        self._next_handler = handler
        return handler

    @abstractmethod
    def handle(self, request: Request) -> Any:
        """Обрабатывает запрос или передает его дальше."""
        if self._next_handler:
            return self._next_handler.handle(request)
        return None # Если достигнут конец цепочки без результата

# Заглушки для функций
def cond1(x): return x == 1
def process1(x): return x * 10
def cond2(y): return y < 20
def cond3(y): return y == 30
def process2(x, y): return x + y + 1
def cond4(x, y, z): return z > 100
def cond5(x, y, z): return z == 55

# --- Обработчик 1: cond1(x) и возврат res1 ---
class HandlerCond1(Handler):
    def handle(self, request: Request) -> Any:
        if cond1(request.x):
            return RES1
        return super().handle(request)

# --- Обработчик 2: process1(x) и сохранение y ---
# (Этот обработчик изменяет объект Request, но не возвращает результат, а передает дальше)
class HandlerProcess1(Handler):
    def handle(self, request: Request) -> Any:
        request.y = process1(request.x)
        print(f"DEBUG: Process1 executed, y = {request.y}")
        return super().handle(request)

# --- Обработчик 3: cond2(y) и возврат res2 ---
class HandlerCond2(Handler):
    def handle(self, request: Request) -> Any:
        if request.y is not None and cond2(request.y):
            return RES2
        return super().handle(request)

# --- Обработчик 4: cond3(y) и возврат res3 ---
class HandlerCond3(Handler):
    def handle(self, request: Request) -> Any:
        if request.y is not None and cond3(request.y):
            return RES3
        return super().handle(request)

# --- Обработчик 5: process2(x, y) и сохранение z ---
class HandlerProcess2(Handler):
    def handle(self, request: Request) -> Any:
        if request.y is not None:
            request.z = process2(request.x, request.y)
            print(f"DEBUG: Process2 executed, z = {request.z}")
        return super().handle(request)

# --- Обработчик 6: cond4(x, y, z) и возврат res4 ---
class HandlerCond4(Handler):
    def handle(self, request: Request) -> Any:
        if request.z is not None and cond4(request.x, request.y, request.z):
            return RES4
        return super().handle(request)

# --- Обработчик 7: cond5(x, y, z) и возврат res5 ---
class HandlerCond5(Handler):
    def handle(self, request: Request) -> Any:
        if request.z is not None and cond5(request.x, request.y, request.z):
            return RES5
        return super().handle(request)

def f_ocp(x):
    """Функция, использующая Цепочку Обязанностей (закрыта для модификации)."""
    
    # 1. Создаем звенья цепочки
    handler1 = HandlerCond1()
    handler2 = HandlerProcess1()
    handler3 = HandlerCond2()
    handler4 = HandlerCond3()
    handler5 = HandlerProcess2()
    handler6 = HandlerCond4()
    handler7 = HandlerCond5()

    # 2. Строим цепочку
    handler1.set_next(handler2).set_next(handler3).set_next(handler4).set_next(handler5).set_next(handler6).set_next(handler7)
    
    # 3. Создаем запрос
    request = Request(x)
    
    # 4. Запускаем обработку
    return handler1.handle(request)

print(f"f_ocp(1) -> {f_ocp(1)}")
# Output: f_ocp(1) -> Результат 1 (Сработал HandlerCond1)

print("-" * 20)
# Допустим, x=3, process1(3) = 30, что соответствует cond3
print(f"f_ocp(3) -> {f_ocp(3)}") 
# Output:
# DEBUG: Process1 executed, y = 30
# f_ocp(3) -> Результат 3 (Сработал HandlerCond3)

print("-" * 20)
# Допустим, x=10, process1(10) = 100, process2(10, 100) = 111
# 111 не удовлетворяет cond4, cond5
print(f"f_ocp(10) -> {f_ocp(10)}")
# Output:
# DEBUG: Process1 executed, y = 100
# DEBUG: Process2 executed, z = 111
# f_ocp(10) -> None (Цепочка не нашла результат)

def f(x):
  if cond1(x):
    return res1

  y = process1(x);
  if cond2(y):
    return res2
  if cond3(y):
    return res3

  z = process2(x, y)
  if cond4(x,y,z):
    return res4
  if cond5(x,y,z):
    return res5
  ...