información sobre generics

[avmm2004]

Hola a todos .... acabo de ver el siguiente código delphi que permite borrar dentro de un directorio todos los ficheros que coincidan con un tipo:

Procedure Borrar_ficheros(i_directorio, i_tipo : string);
var
  filename : string;
begin
    for filename in Tdirectory.getfiles(i_directorio, i_tipo)
      do Tfile.Delete(filename);
end;

Utiliza system.ioutils ...

La codificación me resulta rara .... al menos para mi ( sintaxis del for ...).

Esto es ¿ generics ? . Donde puedo encontrar información sobre esto. ( a ser posible en español).

Siempre me pasa que salen un montón de temas nuevos pero .... se desaprovechan / no se utilizan / se pierden por falta de news / documentación ... ejemplos.. ¿¿¿¿.... ????


Gracias.

[mamcx]

"Generics" no es lo que muestra el código. Eso es otra cosa:

Código Delphi [-]
for filename in Tdirectory.getfiles()

Dependiendo de, es "syntax sugar" que el compilador RE-ESCRIBE en un ciclo for "normal" o una llamada a un generador o iterador; o una mezcla de los 3.

Un compilador normalmente convierte el FOR en un WHILE (eso se llama "desugar" = eliminar el "sugar" o reescribir) maso asi:

(Con ejemplo en rust, que fue el primero que encontre: https://lliwynd.blogspot.com.co/2016...for-loops.html)

Con "sugar"

Código PHP:

for x in 0..10 {
  println!("{}", x);
} 


Luego de "desugar":

Código PHP:

let mut iter = IntoIterator::into_iter(0..10);
  loop {
    match iter.next() {
      Some(x) => {
        println!("{}", x);
      },
      None => break,
    }
  }
} 


Osea, que los compiladores intentan "normalizar" múltiples formas sintácticas en pocas formas.

Si miras a fondo, te darás cuenta que los WHILE y los FOR; NO EXISTEN, ya que no existen en el assembler. Todo al final se "desugar" en JUMPS (GOTOS!).
---

Un "Generic" es una forma de generalizar sobre el tipo, y la respuesta a la pregunta: Cómo evitar duplicar codigo que solo se diferencia por el tipo, pero no por su semántica/estructura/operación?:

Código Delphi [-]
procedure sum(a,b:Integer):integer
procedure sum(a,b:Float):Float

Como ves, se pueden hacer una cantidad "infinita" de funciones "sum" por tantos tipos como sea posible, pero repetir ese codigo se vuelve infrahumano, así que un "GENERIC" permite generalizar el código a:

Código Delphi [-]
procedure sum(a,b:T):T

Y el compilador DESUGAR:

Código Delphi [-]
procedure sum(a,b:T):T <-EL ve esto

sum(1, 2) <-Luego ve esto y sabe que 1 y 2 son INT, así que genera ESTO:

procedure sum(a,b:T -> INT):T -> INT

Osea, es como una plantilla.

Esto tiene correspondencia con los lenguajes dinámicos, donde se podría argumentar que TODO es "generic"

Como en python:

Código PHP:

def sum(a, b) <- es como
def sum(a:ANY, b:ANY) 


Solo que el "switch" de tipo se determina en runtime y no se genera codigo explicito por cada tipo.

Generic es entonces una forma de lograr un poco de dinamismo dentro de los limites de los lenguajes de tipos estáticos.

[[Al González]]

Mario Montoya merece un punto más de reputación.