[mamcx]

Existen otros caminos. Try/Except/Finallys es problemático porque altera el flujo del programa y hace difícil tratar situaciones que se salen del tema de los que es *realmente* excepcional.

El truco es no mezclar Error/Excepción/Opción/Alternativa, que es la causa de mucho lío, ya que muchas cosas que son errores se modelan usando algo hecho para tratar los muy poco habituales excepciones.

La alternativa mas común es usar códigos de error, como en C, pero eso también es problemático, ya que se pierde información.

La manera *elegante* de hacerlo es usando un tipo opcional (https://en.wikipedia.org/wiki/Option_type) que lastimosamente no es viable (osea, delphi no tiene pattern matching ni tipos algebraicos) o usar una función que retorne múltiples valores, que es viable:

Código Delphi [-]
program Project1;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  Generics.Defaults;

type
  TOptional = record
    E:Exception;
    IsOk:Boolean;
  end;


procedure LogOption(value:TOptional);
begin
  if not value.IsOk then
  begin
    //Aqui logeas...
  end;
end;

function OptionError(fun: TProc): TOptional;
begin
    try
      fun();

      result.IsOk := True;
    except
      on E:Exception do
      begin
        result.E := E;
      end;
    end;
end;

var
  result: TOptional;


begin
  LogOption(OptionError(
        procedure
        begin
          Writeln('Hello World');
        end
    ));
end.

//P.D: No encontré como hacer una versión genérica usando TFunc en vez de un TProc. Se puede implementando como una clase pero ya no queda tan limpio de usar.

Nota que la idea es encapsular el manejo de las excepciones y usar procedimientos anónimos para quedar con una interface limpia a la vez que se retiene el error/excepción y se usa como se quiere, sin perder la linea de visión.

Esto combina ambos beneficios del método de manejo de errores con "Códigos de retorno" y "Excepciones".

Es una lastima que no veo como hacerlo aun mas limpio, y que en Delphi, a si como en la mayoría de los lenguages que usan excepciones, - con la excepción -!- de objective-c que tiene separado Error de Excepcion- ambas cosas están mezcladas y no hay una forma simple de desgranar las dos cosas. Se puede hacer un API que en vez de Exeption devuelve un Objeto Error, pero eso no es natural en Delphi, asi que creo que esto es lo máximo que se puede sin meter cosas alienigenas.

P.D:

Esto se parece al método que se usa en GO:

http://stackoverflow.com/questions/1...ing-techniques

Aunque en GO se pierde las ventajas de las excepciones. No hay muchos lenguajes donde se pueda diferenciar entre ambas cosas y que ademas no mezclen el asunto de liberar recursos.

D es uno de ellos, maso:

http://dlang.org/exception-safe.html

Ah!, me acorde que Elixir tiene el estilo que busco:

http://elixir-lang.org/getting_started/17.html

Da resultado estar averiguando como hacer un lenguaje de programacion