[[AgustinOrtu]]

Al, por cierto

... del tipo TEnumProcResult, pero en cuanto tenga que usarlo no dudaré en crearle su extensión, es decir, su ayudante, escribiendo un método como ghStopWhen o algún nombre similar (se aceptan sugerencias de otros posibles identificadores).

En el framework Spring4D, la interfaz genérica IEnumerable< T > que es implementada por todas las colecciones, tal y como se puede ver en la Wiki o en el código, expone dos metodos llamados TakeWhile, declarados asi:

Código Delphi [-]
    ///  < summary >
    ///    Returns elements from a sequence as long as a specified condition is
    ///    true.
    ///  < /summary >
    function TakeWhile(const predicate: TPredicate< T >): IEnumerable< T >; overload;

    ///  < summary >
    ///    Returns elements from a sequence as long as a specified condition is
    ///    true. The element's index is used in the logic of the predicate
    ///    function.
    ///  < /summary >
    function TakeWhile(const predicate: TFunc< T, Integer, Boolean >): IEnumerable< T >; overload;

Quiza sea mas idiomático ya que TakeWhile, el While le podria recordar a cualquier desarrollador a la estructura de control y de ese modo dar una pista bastante certera de cual es su funcionalidad, sin necesidad de leer documentacion o implementacion

Luego hay otro curioso metodo que puede resultar util (ya que estamos), y es el SkipWhile, que basicamente es lo contrario del anterior

Código Delphi [-]
    ///  < summary >
    ///    Bypasses elements in a sequence as long as a specified condition is
    ///    true and then returns the remaining elements.
    ///  < /summary >
    function SkipWhile(const predicate: TPredicate< T >): IEnumerable< T >; overload;

    ///  < summary >
    ///    Bypasses elements in a sequence as long as a specified condition is
    ///    true and then returns the remaining elements. The element's index is
    ///    used in the logic of the predicate function.
    ///  < /summary >
    function SkipWhile(const predicate: TFunc< T, Integer, Boolean >): IEnumerable< T >; overload;

Un saludo

EDITO:

Por cierto Casimiro, no será posible hacer algo con la sintaxis para los genéricos? Cuando se usan las etiquetas de código:

TList<Integer>

Se convierte en:

Código Delphi [-]
  TList