Campaña para corregir el uso de 'With' en Object Pascal

[[AgustinOrtu]]

Result y Self son pseudovariables

Al, podrías publicar un pequeño fragmento de código, mas o menos "real" (pensando por ej en el uso del absolute en el tweet del otro día) en donde un with es una buena herramienta y no un problema? Me da mucha curiosidad. Quizá mi ingenio aún no sea capaz de encontrar el yang dentro del with

En realidad he decidido que la postura de sacarlo es algo caprichosa. Es mas fácil para mí pensar que no existe y no usarlo, como un montón de gustos que son particulares de cada uno. Si en algún momento me tocase consumir código que está implementado con withs, mientras funcione como se espera que funcione, podre soportarlo

Roman, con lo de Marco Cantu, que fue un ejemplo, simplemente quería decir que quedaría muy feo desde el punto de vista comercial que Embarcadero o un vocero aparezca un día diciendo que algo nuevo que agregaron no es una práctica muy recomendable.

[Neftali [Germán.Estévez]]

Entiendo que la única utilidad del with dentro del lenguaje es eliminar determinadas "palabras" de forma reiterativa en un bloque de código.
Si resulta que para poder usar el with ahora vamos a introducir la necesidad de usar una nueva palabra, ¿no será mejor no utilizarlo?
Es decir, creo que usar el with (que creo que es lo que proponéis) usando un identificador (it o idem) es lo mismo (o es peor) que usar una variable y declararla del tipo correcto.

Me explico:

Ahora tenemos esto:

Código Delphi [-]
var
  John, Sarah : TCustomer;
begin
  // Set up the John's customer details
  with John do
  begin
    firstName := 'John';
    lastName  := 'Smith';
    address1  := '7 Park Drive';
    address2  := 'Branston';
    address3  := 'Grimworth';
    city      := 'Banmore';
    postCode  := 'BNM 1AB';
  end;

Para solventarlo, proponemos crear una directiva condicional y obligar a escribir esto:

Código Delphi [-]
var
  John, Sarah : TCustomer;
begin
  // Set up the John's customer details
  with John do
  begin
    idem.firstName := 'John';
    idem.lastName  := 'Smith';
    idem.address1  := '7 Park Drive';
    idem.address2  := 'Branston';
    idem.address3  := 'Grimworth';
    idem.city      := 'Banmore';
    idem.postCode  := 'BNM 1AB';
  end;

Creo que en comparación con esto, estamos liando las cosas...
Porque resulta que al final, para poder utilizar el with (cuya ventaja creo que es eliminar determinadas palabra repetitivas), estamos obligando al usuario a escribir más código con otra palabra que se repite (y menos entendible) que si escribiéramos el código natural.

Código Delphi [-]
var
  John, Sarah : TCustomer;
begin
  // Set up the John's customer details
  John.firstName := 'John';
  John.lastName  := 'Smith';
  John.address1  := '7 Park Drive';
  John.address2  := 'Branston';
  John.address3  := 'Grimworth';
  John.city      := 'Banmore';
  John.postCode  := 'BNM 1AB';

O no lo entiendo o no lo veo.

NOTA: El código de ejemplo está extraído de la explicación del WITH de DelphiBasics.

[Neftali [Germán.Estévez]]

Y que conste que hay ejemplos en los que WITH puede tener sentido (y creo que es para lo que se pensó) como puede ser algo así (donde la parte a eliminar es muy grande):

Código Delphi [-]
  dmClientesMain.objCliente.QueryClientes.FieldByName('ID').AsString := ID;
  dmClientesMain.objCliente.QueryClientes.FieldByName('Nombre').AsInteger := 'Nombre';
  dmClientesMain.objCliente.QueryClientes.FieldByName('Desc').AsString := 'Descripcion';
  dmClientesMain.objCliente.QueryClientes.FieldByName('Telefono').AsString := '123456789';
  ...

Pero es que para estos casos, creo que esto:

Código Delphi [-]
var
  q:TQuery;
begin
  q := dmClientesMain.objCliente.QueryClientes;
  q.FieldByName('ID').AsString := ID;
  q.FieldByName('Nombre').AsInteger := 'Nombre';
  q.FieldByName('Desc').AsString := 'Descripcion';
  q.FieldByName('Telefono').AsString := '123456789';
  ...

Es más claro que esto, ya sea usando it o idem:

Código Delphi [-]
  with dmClientesMain.objCliente.QueryClientes do 
  begin
  it.FieldByName('ID').AsString := ID;
  it.FieldByName('Nombre').AsInteger := 'Nombre';
  it.FieldByName('Desc').AsString := 'Descripcion';
  it.FieldByName('Telefono').AsString := '123456789';
  end;
  ...

Entre otras cosas porque <it> o <idem> me dan un significado "genérico", <q> en este caso, para mi tiene un significado (de query) que además me hace más claro entender el código.
Al igual que si uso frm (para un TForm), f (para un TField), ds (para un TDataSet),...

[jhonny]

Empezado por Neftali

Entiendo que la única utilidad del with dentro del lenguaje es eliminar determinadas "palabras" de forma reiterativa en un bloque de código.
Si resulta que para poder usar el with ahora vamos a introducir la necesidad de usar una nueva palabra, ¿no será mejor no utilizarlo?
Es decir, creo que usar el with (que creo que es lo que proponéis) usando un identificador (it o idem) es lo mismo (o es peor) que usar una variable y declararla del tipo correcto.

Me explico:

Ahora tenemos esto:

Código Delphi [-]
var
  John, Sarah : TCustomer;
begin
  // Set up the John's customer details
  with John do
  begin
    firstName := 'John';
    lastName  := 'Smith';
    address1  := '7 Park Drive';
    address2  := 'Branston';
    address3  := 'Grimworth';
    city      := 'Banmore';
    postCode  := 'BNM 1AB';
  end;

Para solventarlo, proponemos crear una directiva condicional y obligar a escribir esto:

Código Delphi [-]
var
  John, Sarah : TCustomer;
begin
  // Set up the John's customer details
  with John do
  begin
    idem.firstName := 'John';
    idem.lastName  := 'Smith';
    idem.address1  := '7 Park Drive';
    idem.address2  := 'Branston';
    idem.address3  := 'Grimworth';
    idem.city      := 'Banmore';
    idem.postCode  := 'BNM 1AB';
  end;

Creo que en comparación con esto, estamos liando las cosas...
Porque resulta que al final, para poder utilizar el with (cuya ventaja creo que es eliminar determinadas palabra repetitivas), estamos obligando al usuario a escribir más código con otra palabra que se repite (y menos entendible) que si escribiéramos el código natural.

Código Delphi [-]
var
  John, Sarah : TCustomer;
begin
  // Set up the John's customer details
  John.firstName := 'John';
  John.lastName  := 'Smith';
  John.address1  := '7 Park Drive';
  John.address2  := 'Branston';
  John.address3  := 'Grimworth';
  John.city      := 'Banmore';
  John.postCode  := 'BNM 1AB';

O no lo entiendo o no lo veo.

NOTA: El código de ejemplo está extraído de la explicación del WITH de DelphiBasics.

¡Caramba!, creo que lo que dije antes, ha quedado mucho mejor explicado y reflejado por Neftali en este post. Así que me uno a este comentario y al otro que escribió después de ese.

[Casimiro Notevi]

Empezado por jhonny

¡Caramba!, creo que lo que dije antes, ha quedado mucho mejor explicado y reflejado por Neftali en este post. Así que me uno a este comentario y al otro que escribió después de ese.

+1 .

[roman]

De hecho, creo que el debate debió comenzar con una exposición de motivos, precisamente para dar mayor claridad: cuáles son exactamente las supuestas falencias y virtudes de la cláusula.

Por ejemplo, ¿quién no ha usado el típico

Código Delphi [-]
with TAlgunFormulario.Create do
begin
  // ...
  ShowModal;
  // ..
end;

para mostrar un cuadro de diálogo?

Claro que podemos usar una variable pero resulta muy cómodo ahorrárnosla si el formulario se desecha una vez cerrado.

O bien, ¿han considerado que además de ahorrar escritura, el with puede ahorrar llamadas a métodos? Por ejemplo en:

Código Delphi [-]
Persona.Domicilio.Calle := 'Av. Principal';
Persona.Domicilio.Numero := 1;

si Domicilio es una propiedad de la clase TPersona a la que se accede mediante un getter, éste se llamará dos veces. El uso con with:

Código Delphi [-]
with Persona.Domicilio do
begin
  Calle := 'Av. Principal';
  Numero := 1;
end;

reduce a una sóla llamada.

Igual que el caso anterior, se puede usar una variable para evitar el doble acceso, pero resulta mucho más cómodo así.

LineComment Saludos

[[Al González]]

¡Menudos ejemplos, Germán! Por supuesto que no tendría sentido usar el nuevo With en casos así.

Pero hay otros donde sí, como el de la imagen del primer mensaje (que parece que salió borrosa). Consideremos la siguiente comparativa:

Sin With:

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
var
  LForm :TForm2;
begin
  LForm := TForm2.Create(Self);

  try
    AppLogger.LogForm(LForm);  // Llamada a un método externo usando el formulario creado como parámetro
    LForm.ShowModal;
  finally
    LForm.Free;
  end;
end;

Con el nuevo With:

Código Delphi [-]
procedure TForm1.Button1Click(Sender: TObject);
begin
  with TForm2.Create(Self) do
    try
      AppLogger.LogForm(It);  // Llamada a un método externo usando el formulario creado como parámetro
      It.ShowModal;
    finally
      It.Free;
    end;
end;

No es que busquemos ahorrar palabras. No es así de simple. Sino que los recursos que permitan simplificar código fuente de una manera elegante siempre debieran ser bienvenidos, salvo que no sean seguros. Como el riesgo es la desventaja del With actual, se propone hacerlo seguro conservando su elegancia. Incluso se añade una ventaja más: la de poder hacer referencia al objeto mismo dentro del bloque With (algo que la actual sintaxis no posee).

Saludos aclaratorios.

Al González.

P.D. Se agradece el anterior mensaje, de Román, que ahora veo y suscribo.

[[AgustinOrtu]]

Sigo sin verle mucho sentido. En lugar de escribir var it: TForm2 tengo que escribir with. No son muchos caracteres que se ahorran, y se debe agregar un nivel de sangría adicional. Combinado con un bloque de protección de recursos (try-finally) y un bloque de manejo de excepciones (try-except) se tendrían 3 niveles de sangría. A mi ya dos me parece mucho

[roman]

Empezado por AgustinOrtu

Roman, con lo de Marco Cantu, que fue un ejemplo, simplemente quería decir que quedaría muy feo desde el punto de vista comercial que Embarcadero o un vocero aparezca un día diciendo que algo nuevo que agregaron no es una práctica muy recomendable.

Claro. Sólo que el with es muy, pero muy anteror a Marco Cantú, no es nada nuevo que agregar.

Esto, desde luego, sin quitar el hecho de que a algunos nos parece útil el with y pensamos que la confusión, como tantas otras cosas, depende mucho de cómo se use. Hay quienes gustan de anidar innecesariamente bloques try-except y no por eso los vamos a quitar o modificar.

Ahora, como dice Neftali, el with se usa para reducir la escritura. Cualquier otra palabra o símbolo, sólo generaría confusión y sería muy artificioso. Excepto, quizá, el punto, porque éste, a fin de cuentas, es lo mismo que escribiríamos si no usamos el with, esto es, usar el punto significaría simplemente que omitimos un poquito menos, pero no añadimos nada más. Además, el punto, como sucede en Visual Basic, da la oportunidad al IDE de autocompletar, que, dicho sea de paso, es realmente lo que extraño al usar el with.

Además del punto, la variante del as como un alias, es la que me parece más práctica. Claro que podemos usar una variable en lugar del alias, pero la idea sería que con el alias nos evitamos declarar algo extra.

LineComment Saludos