%BROADCASTMESSAGE%

	TWiki > Main > TyphonLanguage	TWiki webs: %WIKIWEBLIST%
	Main . { Integrantes %SEPB% Proyectos %SEPB% Eventos %SEPB% ACSFDL %SEPB% Índice %SEPB% Cambios }

Contenidos

Qué es Typhon?

Por qué C++?

Bueno, de más está decir que hacer un lenguaje compilado nuevo (sin traducirlo a alguno existente) no sólo es un trabajo excesivamente monstruoso y para el cual, al menos yo (luca) no estoy capacitado, sino que sería un reinventar un poco la rueda.

Por qué Python?

Por último, Python y C++ son parecidos en cuanto a las características que ofrecen, al menos son los únicos 2 lenguajes que conozco que soportan herencia múltiple, por ejemplo.

Qué significa Typhon

Luego investigando el nombre, Typhon resulta ser una criatura de la mitología griega (un hombre/dragon con mil cabezas) al igual que Python (una especie de serpiente gigante); pero hay más aún.

Tanto Typhon como Python fueron monstruos creados por los viejos dioses para evitar que los dioes del Olimpo tomaran control del bajomundo.

Así que nombre más acertado para este lenguaje, difícilmente exista ;)

Alcance del Lenguaje

Sintaxis

Definiciones

• Va a ser un subset de C++, que provea básicamente lo mismo que provee Python. Cualquier cosa más allá de eso tendrá que hacerse en C++.
• Puede verse de la forma inversa, también va a ser un subset de python si lo miramos desde el otro punto de vista (hay cosas como yield o formas lambda que no van a estar).
• No va a hardcodear tipos de datos. Sin embargo sí se va a asumir una interfaz tipo STL. Es decir el foreach se traducirá a iteradores del estilo de la STL. Para hacer un foreach sobre cualquier tipo, este tipo va a tener que cumplir el modelo de Forward Container en el sentido definido por la STL.
• Se va a optimizar para el caso general (2004 (c) Alberto Bertogli :D). Es decir, las cosas que se hacen más frecuentemente deberían ser la que mejor soporte del lenguaje tengan.

Características aún no definidas

Modo de iterar una secuencia

En C++ tendríamos 2 formas básicas de traducir:

for item_t i in seq_t seq:

1. Que i sea una copia al ítem en seq
2. Que i sea una copia constante al ítem de seq
3. Que i sea una referencia al ítem de seq
4. Que i sea una referencia constante al ítem de seq

Probablemente lo más intuitivo (aunque no lo más seguro) sea tener una referencia modificable, y es esto lo que debería usarse por omisión según la premisa optimizar para el caso general . A esto se suma que iterar con una referencia constante sería bastante claro con una construcción como:

for const item_t i in seq_t seq:

En caso de necesitarse una copia (querer modificar i dentro del cuerpo del for sin que los cambios se reflejen en los ítems de seq), siempre se puede hacer una copia explícita:

for item_t i in seq_t seq:
    item_t copia = i
    copia += 2 * seq.size()
    # etc.

Implementación

for item_t i in seq_t seq:

for (seq_t::iterator ___i = seq.begin(); ___i != seq.end(); ++___i)
{
    item_t& i = *___i; // Referencia
    // ...
}

for const item_t i in seq_t seq:

for (seq_t::const_iterator ___i = seq.begin(); ___i != seq.end(); ++___i)
{
    const item_t& i = *___i; // Referencia constante
    // ...
}

Uso de typeof

typeof() es una extensión de GNU para C/C++, para obtener el tipo de una expresión en tiempo de compilación. El uso de esta extensión simplificaría considerablemente la implementación de la deducción de tipos para el for y otras construcciones, pudiéndose llegar a hacer prácticamente cualquier declaración de una variable con tipo implícito (siempre y cuando se la inicialice en la declaración). Manteniendo una tabla de símbolos y forward declarations podría evitarse el uso de typeof, pero los forward declarations pueden convertirse en algo muy tedioso e inecesario. Como siempre, se puede llegar a un balance. La deducción de tipos siempre será opcional (para poder tener mayor control de las variables), por lo que puede agregarse algún tipo de opción al compilador (me refiero al traductor de Typhon a C++) para hacer uso o no de typeof. Si no se usa typeof el código tendrá que ser inevitablemente más redundante (tendrán que especificarse los tipos de más variables explícitamente y usar forward declarations) pero permitirá generar código ISO C++ que es una alta prioridad en Typhon.

Implementación

for i in seq:

for (typeof(seq.begin()) ___i = seq.begin(); ___i != seq.end(); ++___i)
{
    typeof(*___i)& i = *___i;
    // ...
}

Esto podría llevarse más lejos y usar tipos implícitos:

int f(): return 5
int main():
    n = f() # n es una declaración implícita, con el tipo de f(), en este caso int
    return 0

int f()
{
    return 5;
}
int main()
{
    typeof(f()) n = f(); // n tiene el tipo devuelto por f(), gracias al uso de typeof
    return 0;
}

Palabra reservada auto

int f(): return 5
int main():
    auto n = f() # n es declarada con tipo implícito, obtenido de f(), en este caso int
    return 0

Un ejemplo con más sentido sería el caso en que se queira iterar un contenedor obteniendo una copia de cada ítem:

for i in seq:
    auto copia = i
    copia += 2 * seq.size()
    # etc.

Literales de strings

Aún no sabemos que vamos a hacer con los strings largos y strings cortos de Python.

Shortstrings

En principio los strings cortos deberían poder escribirse sólo con " (comillas dobles) porque las ' (comillas simples) deberían usarse para expresar literales char como en C/C++.

Longstrings

Con respecto a los string largos no sé si valga la pena traducirlos de alguna forma o directamente no soportarlo, aunque creo que soportarlos no traería grandes complicaciones y en ciertas circunstancias pueden ser convenientes.

Prefijos

También hay que definir si se soportan los prefijos (como r para strings raw, u para unicode, etc). Tener en cuenta que traducirlos podría romper la compatibilidad en ciertos ámbitos.

Strings traducibles

También podría incluirse el prefijo _ introducido por D para marcars strings traducibles. Esto podría integrarse con gettext u otros sistemas de internacionalización. Lo bueno es que la forma de trabajar quedaría en manos del lenguaje y en caso de cambiar de implementación, sólo habría que cambiar el compilador. De hecho podría tener soporte para varios sistemas de internacionalización.

Por otro lado, siguien la hipótesis de optimizar para el caso general, podría tomarse por omisión a todos los strings como traducibles, excepto a los que lleven el prefijo _, ya que por lo general, la mayor parte de los strings en un programa son traducibles.

Todo esto podría manejarse con opciones de línea de comandos a la hora de compilar, por lo que sin ningún problema, y de forma transparente, podría generase código sin ningún tipo de dependencia de un sistema de internacionalización incluso cuando el código esté escrito para ser internacionalizable.

Palabra reservada block

Serviría para hacer un bloque de código arbitrario. Es útil para técnicas de programación como sentries.

Ejemplo:

include ifstream, string
import ifstream, string, getline from std
void f():
    # Hago cosas ...
    # Quiero obtener en una variable el contenido de un archivo
    string contenido
    block:
        ifstream f("archivo")
        string buffer
        while getline(f, buffer):
            contenido += buffer
    # Listo, acá se destruye tanto f (se cierra el archivo) como buffer
    # Usamos el contenido como más nos guste

Workarround

if 1:
    # código del bloque acá

Comentarios

Comentarios multilínea

A Python le falta comentarios multilínea, cosa que me resulta bastante molesto.

Comentarios multilínea anidados

D tiene comentarios anidados, cosa muy conveniente para comentar un bloque de código grande que a su vez pueda tener comentarios adentro. Me parecería piola que Typhon tenga algo similar.

Compilación condicional

Meter cosas del precompilador en Typhon me parece poco conveniente, pero hay cosas necesarias como la compilación condicional. D lo soluciona con palabras clave version, que es básicamente lo mismo que un #ifdef ... #endif del precompilador. Creo que Typhon podría proveer algo similar. Por ejemplo:

version DEBUG:
    void debug(string msg):
        cerr << "debug: " << msg << "\n"

int main():
    version DEBUG:
        debug("entrando al main\n");
    # Mas cosas
    version LINUX:
         # algo específico de Linux.

class C:
    C(): cout << "Constructor de C\n"
    int hacer_algo(double i) const: return i/2
    ~C(): cout << "Destructor de C\n"

struct C
{
    C();
    virtual int hacer_algo(double i) const;
    virtual ~C();
};
C::C()
{
    cout << "Constructor de C\n";
}
int C::hacer_algo(double i) const
{
    return i/2;
}
C::~C()
{
    cout << "Destructor de C\n";
}

struct C:
    C(): cout << "Constructor de C\n"
    int hacer_algo(double i) const: return i/2
    ~C(): cout << "Destructor de C\n"

struct C
{
    C();
    int hacer_algo(double i) const;
    ~C();
};
// ídem anterior