Corregir ortografía, errores de tipeo, etc.

[z.facultad/75.00/informe.git] / source / d.rst

diff --git a/source/d.rst b/source/d.rst
index 2105e796a1b3ec0d02db812c5c554b0775b25ed0..35591d4a2dbbf301ee0acb5653175c9e0e7f0c92 100644 (file)
--- 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.
 .. 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:
 
 
 .. _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
 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:
 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
 
 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::
 
 
    Ejemplo::
 


@@ -237,7 +237,7 @@ Iteración sobre colecciones (``foreach``):
          total += i;
 
 *Templates*:
          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
    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
 
       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
    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::
 
 
    Ejemplo::
 


@@ -265,10 +265,10 @@ Iteración sobre colecciones (``foreach``):
       bloque!(int, float).x = 5;
       float f = bloque!(int, float).foo(7);
 
       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*.
 
    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
 
    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
    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::
    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
 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
 
 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
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 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
 
 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
 
 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
    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
 
    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::
 
    Pre y post condiciones:
       Ejemplo::


@@ -953,10 +953,10 @@ Inicialización garantizada:
 
    Ejemplo::
 
 
    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*):
       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)
       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)
          auto trans = new Transaccion;
          scope (success)

-            trans.commit();                // ejecutado si sale con "return"
+            trans.commit();             // ejecutado si sale con "return"

          scope (failure)
          scope (failure)

-            trans.rollback();             // ejecutado si sale por una excepción
+            trans.rollback();           // ejecutado si sale por una excepción

          if (condicion)
          if (condicion)

-            throw Exception("error"); // ejecuta lock.unlock() y trans.rollback()
+            throw Exception("error");   // lock.unlock() y trans.rollback()

          else if (otra_condicion)
          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
       }
 
    Esta es una nueva forma de poder escribir código *exception-safe*, aunque