¿Cómo se llama esta técnica de programación?

Encontré esta técnica de programación mientras hacía programación de pares en una entrevista y no pude encontrar el nombre en google.

La idea es que primero escriba la expresión que usa las variables y luego escriba el código que computa las variables más adelante.

Para usar un código de ejemplo aquí:

private bool ValidPolicyNumber(string policyNumber) 
{
    var hasExpectedPrefix = policyNumber.Substring(0,5) == "POLIC";
    var followedBy7Digits = Regex.IsMatch(policyNumber.Substring(6,7), "^[0-9]{7}$");
    var hasLengthOf12 = policyNumber.Length == 12;

    return hasExpectedPrefix && followedBy7Digits && hasLengthOf12;
}

Al escribir esta función utilizando la técnica que mencioné, primero escribiría la última línea return hasExpectedPrefix && followedBy7Digits && hasLengthOf12;y luego las 3 líneas que la preceden.

La técnica más cercana que pude encontrar es "ilusiones" y eso es de SICP, pero se relaciona con las funciones de llamada que implementará más tarde en lugar de usar variables que va a inicializar más tarde.

Es solo una variación de la composición funcional.

Testigo:

private bool ValidPolicyNumber(string policyNumber) 
{
    return hasExpectedPrefix(policyNumber) 
        && followedBy7Digits(policyNumber) 
        && hasLengthOf12(policyNumber);
}

private bool hasExpectedPrefix(string policyNumber)
{
    return policyNumber.Substring(0,5) == "POLIC";
}

private bool followedBy7Digits
{
    return Regex.IsMatch(policyNumber.Substring(6,7), "^[0-9]{7}$");
}

private bool hasLengthOf12
{
    return policyNumber.Length == 12;
}

La única diferencia real es que su versión combina los resultados calculados de las funciones más pequeñas en un solo alcance funcional, que es lo que desea a menos que las expresiones funcionales más pequeñas estén destinadas a ser reutilizadas en otro lugar.

Esto podría ser solo una sugerencia de Clean Code (el libro), que se utilizará cuando la descomposición funcional (como explicó Robert) no sea aplicable debido a que las funciones resultantes no son reutilizables por sí mismas.

Sin embargo, si desea obtener información técnica al respecto, el libro Implementation Patterns , de Kent Beck, nombra esta técnica como Explicando las variables locales (énfasis mío):

Variable local

Las variables locales solo son accesibles desde su punto de declaración hasta el final de su alcance. Siguiendo el principio de que la información debe difundirse lo menos posible, declare las variables locales justo antes de que se usen y en el ámbito más interno posible.

Hay un puñado de roles comunes para las variables locales:

• Recopilador: una variable que recopila información para su uso posterior. A menudo, el contenido de los recopiladores se devuelve como el valor de una función. Cuando se devuelva un recopilador, asígnele el nombre resultado o resultados.

• Count: un colector especial que recopila el recuento de algunos otros objetos.

• Explicación: si tiene una expresión complicada, asignar bits de la expresión a variables locales puede ayudar a los lectores a navegar por la complejidad:

  int top = ...;

  int left = ...;

  int altura = ...;

  int bottom = ...;

  volver nuevo rectángulo (arriba, izquierda, altura, ancho);

  Si bien no es computacionalmente necesario, las variables locales explicativas ayudan a lo que de otro modo sería una expresión larga y complicada.