X-Git-Url: https://git.llucax.com/z.facultad/75.00/informe.git/blobdiff_plain/22cb44a8463f90a10ca59340382c1d104b2cda74..4dec75812c56a0e0c6fb8d305349d32a09df10b0:/source/d.rst

diff --git a/source/d.rst b/source/d.rst
index 2105e79..35591d4 100644
--- a/source/d.rst
+++ b/source/d.rst
@@ -2,7 +2,7 @@
 .. Introducción y breve reseña del lenguaje de programación D. También
    se presentan las necesidades particulares de D con respecto al
    recolector de basura y su estado actual.
-   ESTADO: TERMINADO
+   ESTADO: TERMINADO, CORREGIDO
 
 
 .. _d_lang:
@@ -138,7 +138,7 @@ por C++, pudiendo extraer de él los mejores conceptos pero evitando sus
 mayores problemas también.
 
 Otra gran diferencia con C++ es la facilidad para ser analizado
-gramaticalmente (*parsing*), ya fue especialmente diseñado para ser sencillo
+sintácticamente (*parsing*), ya fue especialmente diseñado para ser sencillo
 y a diferencia de C y C++ su gramática es independiente del contexto
 (*context-free grammar*). Esto permite que D pueda ser compilado en pequeños
 pasos bien separados:
@@ -204,7 +204,7 @@ y meta-programación:
 
 Inferencia de tipos básica implícita y explícita (mediante ``typeof``):
    si no se especifica un tipo al declarar una variable, se infiere del tipo
-   de su inicializador.
+   de su valor de inicialización.
 
    Ejemplo::
 
@@ -237,7 +237,7 @@ Iteración sobre colecciones (``foreach``):
          total += i;
 
 *Templates*:
-   clases y funciones pueden ser parametrizadas. Esto permite desarrollar
+   clases y funciones pueden ser generalizadas. Esto permite desarrollar
    algoritmos genéricos sin importar el tipo de los datos de entrada, siempre
    y cuando todos los tipos tengan una *interfaz* común.   Esto también es
    conocido como *polimorfismo en tiempo de compilación*, y es la forma más
@@ -249,11 +249,11 @@ Iteración sobre colecciones (``foreach``):
       auto i = sumar!(int)(5, 6);    // i == 11
       auto f = sumar!(float)(5, 6); // j == 11.0f
 
-   Además se pueden definir bloques de declaraciones parametrizados (esto no
+   Además se pueden definir bloques de declaraciones generalizadas (esto no
    es posible en C++), permitiendo instanciar dicho bloque con parámetros
    particulares. Esto sirve como un mecanismo para la reutilización de código,
    ya que puede incluirse un mismo bloque en distintos lugares (por ejemplo
-   clases). Un bloque parametrizado puede verse como una especie de módulo.
+   clases). Un bloque generalizado puede verse como una especie de módulo.
 
    Ejemplo::
 
@@ -265,10 +265,10 @@ Iteración sobre colecciones (``foreach``):
       bloque!(int, float).x = 5;
       float f = bloque!(int, float).foo(7);
 
-   La utilidad más prominente de los bloques parametrizados se da al
+   La utilidad más prominente de los bloques generalizados se da al
    acompañarse de *mixins*.
 
-Instanciación implícita de funciones parametrizadas:
+Instanciación implícita de funciones generalizadas:
    el lenguaje es capaz de deducir los parámetros siempre que no hayan
    ambigüedades
 
@@ -334,8 +334,8 @@ Cantidad de parámetros variables para *templates*:
    si una función cumple ciertas reglas básicas (como por ejemplo no tener
    efectos colaterales) puede ser ejecutada en tiempo de compilación en vez de
    tiempo de ejecución. Esto permite hacer algunos cálculos que no cambian de
-   ejecución en ejecución al momento de compilar, mejorando la performance
-   o permitiendo formas avanzadas de metaprogramación. Esta característica se
+   ejecución en ejecución al momento de compilar, mejorando el rendimiento
+   o permitiendo formas avanzadas de meta-programación. Esta característica se
    vuelve particularmente útil al combinarse con *string mixins*.
 
    Ejemplo::
@@ -491,7 +491,7 @@ Objetos y arreglos *livianos*:
 Rendimiento:
    la :ref:`d_generic` permite realizar muchas optimizaciones ya que se
    resuelve en tiempo de compilación y por lo tanto aumentando la
-   *performance* en la ejecución.
+   rendimiento en la ejecución.
 
 Número de punto flotante de 80 bits:
    El tipo ``real`` de D_ tiene precisión de 80 bits si la plataforma lo
@@ -517,11 +517,11 @@ Control de alineación de miembros de una estructura:
 Programación de alto nivel
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Programa de alto nivel se refiere a construcciones más avanzadas que un loop.
-Expresiones semánticamente más ricas que permiten mayor expresividad al
-programador o le permiten focalizarse de mejora manera en los algoritmos
-independizándose del *hardware* o de como funciona una computadora. Es
-exactamente el opuesto a :ref:`d_low_level`.
+Programación de alto nivel se refiere a construcciones más avanzadas que una
+sentencia para iterar; expresiones con una semántica más ricas que permiten
+mayor expresividad al programador o le permiten focalizarse de mejora manera
+en los algoritmos independizándose del *hardware* o de como funciona una
+computadora. Es exactamente el opuesto a :ref:`d_low_level`.
 
 En general estas características tiene como efecto secundario una mejora de la
 productividad de los programadores. D_ adopta herramientas de muchos lenguajes
@@ -695,7 +695,7 @@ características más salientes se encuentran:
 
 Objetos *pesados*:
    objetos polimórficos como los de cualquier lenguaje con orientación real
-   a objetos. Estos objetos poseen una tabla virtual para *dispatch* dinámico,
+   a objetos. Estos objetos poseen una tabla virtual para despacho dinámico,
    todos los métodos son virtuales a menos que se indique lo contrario
    y tienen semántica de referencia [#drefsem]_. Estos objetos tienen un
    *overhead* comparados a los objetos *livianos* pero aseguran una semántica
@@ -879,7 +879,7 @@ Diseño por contrato:
 
    D_ implementa las siguientes formas de diseño por contrato (todas se
    ejecutan siempre y cuando no se compile en modo *release*, de manera de no
-   sacrificar *performance* cuando es necesario):
+   sacrificar rendimiento cuando es necesario):
 
    Pre y post condiciones:
       Ejemplo::
@@ -953,10 +953,10 @@ Inicialización garantizada:
 
    Ejemplo::
 
-      double d;         // inicializado a NaN
-      int x;             // inicializado a 0
-      Fecha f;          // inicializado a null
-      byte[5] a;       // inicializados todos los valores a 0
+      double d;      // inicializado a NaN
+      int x;         // inicializado a 0
+      Fecha f;       // inicializado a null
+      byte[5] a;     // inicializados todos los valores a 0
       long l = void; // NO inicializado (explícitamente)
 
 *RAII* (*Resource Adquisition Is Initialization*):
@@ -995,17 +995,17 @@ Guardias de bloque (*scope guards*):
       int f(Lock lock) {
          lock.lock();
          scope (exit)
-            lock.unlock();                  // ejecutado siempre que salga de f()
+            lock.unlock();              // ejecutado siempre que salga de f()
          auto trans = new Transaccion;
          scope (success)
-            trans.commit();                // ejecutado si sale con "return"
+            trans.commit();             // ejecutado si sale con "return"
          scope (failure)
-            trans.rollback();             // ejecutado si sale por una excepción
+            trans.rollback();           // ejecutado si sale por una excepción
          if (condicion)
-            throw Exception("error"); // ejecuta lock.unlock() y trans.rollback()
+            throw Exception("error");   // lock.unlock() y trans.rollback()
          else if (otra_condicion)
-            return 5;                         // ejecuta lock.unlock() y trans.commit()
-         return 0;                            // ejecuta lock.unlock() y trans.commit()
+            return 5;                   // lock.unlock() y trans.commit()
+         return 0;                      // lock.unlock() y trans.commit()
       }
 
    Esta es una nueva forma de poder escribir código *exception-safe*, aunque