--- /dev/null
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<BASE HREF="http://wiki.lugmen.org.ar/twiki/view/Main/TyphonLanguage"><table border=1 width=100%><tr><td><table border=1 bgcolor=#ffffff cellpadding=10 cellspacing=0 width=100% color=#ffffff><tr><td><font face=arial,sans-serif color=black size=-1>Ésta es la versión <b><font color=#0039b6>G</font> <font color=#c41200>o</font> <font color=#f3c518>o</font> <font color=#0039b6>g</font> <font color=#30a72f>l</font> <font color=#c41200>e</font></b> <a href="http://www.google.com/intl/es/help/features.html#cached"><font color=blue>guardada en el caché</font></a> de la <A HREF="http://wiki.lugmen.org.ar/twiki/view/Main/TyphonLanguage"><font color=blue>http://wiki.lugmen.org.ar/twiki/view/Main/TyphonLanguage</font></a> obtenida el 28 Ago 2005 07:43:43 GMT.<br>
+La caché de <b><font color=#0039b6>G</font> <font color=#c41200>o</font> <font color=#f3c518>o</font> <font color=#0039b6>g</font> <font color=#30a72f>l</font> <font color=#c41200>e</font></b> es la instantánea de la página que tomamos cuando exploramos la Web en forma automática.<br>
+Es posible que la página haya cambiado desde entonces. Haga clic aquí para ver la <A HREF="http://wiki.lugmen.org.ar/twiki/view/Main/TyphonLanguage"><font color=blue>página actual</font></a> sin resaltar.<br>
+Esta página guardada en el caché puede hacer referencia a imágenes que ya no están disponibles. Haga clic aquí para obtener únicamente el <A HREF="http://66.102.7.104/search?q=cache:UudIjxQfm7IJ:wiki.lugmen.org.ar/twiki/view/Main/TyphonLanguage+typhonlanguage&hl=es&lr=&strip=1"><font color=blue>texto guardado en el caché</font></a>.<br>Para vincularse a esta página o para marcarla, utilice el siguiente url: <code>http://www.google.com/search?q=cache:UudIjxQfm7IJ:wiki.lugmen.org.ar/twiki/view/Main/TyphonLanguage+typhonlanguage&hl=es</code></font><br><br><center><font size=-2><i>Google no tiene relación con los autores de esta página ni es responsable de su contenido.</i></font></center></td></tr>
+<tr><td>
+<table border=0 cellpadding=0 cellspacing=0><tr><td><font face=arial,sans-serif color=black size=-1>Se han resaltado estos términos de búsqueda: </font></td><td bgcolor=#ffff66><B><font face=arial,sans-serif color=black size=-1>typhonlanguage </font></B></td></tr></table>
+</td></tr></table></td></tr></table>
+<hr>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="es-ar" lang="es-ar">
+<head>
+ <title> TyphonLanguage < Main < TWiki</title>
+ <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" /> %HTTP_EQUIV_ON_VIEW%
+ <base href="http://wiki.lugmen.org.ar/twiki/view/Main/TyphonLanguage" />
+
+</head>
+<body bgcolor="#ffffff">
+<a name="PageTop"></a>
+<form name="main" action="/twiki/view/Main/TyphonLanguage"> %BROADCASTMESSAGE%
+<table width="100%" border="0" cellpadding="3" cellspacing="0">
+ <tr>
+ <td bgcolor="#FFFFC0" rowspan="2" valign="top" width="1%">
+ <a href="%WIKILOGOURL%"><img src="%WIKILOGOIMG%" border="0" alt="%WIKILOGOALT%" /></a>
+ </td><td>
+ <a href="http://wiki.lugmen.org.ar/twiki/view/Main/WebHome">TWiki</a>
+ > <a href="http://wiki.lugmen.org.ar/twiki/view/Main/WebHome">Main</a>
+ >
+ <font size="+1"><b><B style="color:black;background-color:#ffff66">TyphonLanguage</B></b> </font>
+ </td><td align="right">
+ <font size="-2">TWiki webs: <br />
+ %WIKIWEBLIST% </font>
+ </td>
+ </tr>
+ <tr bgcolor="#FFFFC0">
+ <td colspan="2">
+ Main . { <a class="twikiLink" href="/twiki/view/Main/TWikiUsers">Integrantes</a> %SEPB% <a class="twikiLink" href="/twiki/view/Main/ProyectosLugmen">Proyectos</a> %SEPB% <a class="twikiLink" href="/twiki/view/Main/EventosLugmen">Eventos</a> %SEPB% <a class="twikiLink" href="/twiki/view/Main/AsoCSFDL">ACSFDL</a> %SEPB% <a class="twikiLink" href="/twiki/view/Main/WebIndex">Índice</a> %SEPB% <a class="twikiLink" href="/twiki/view/Main/WebChanges">Cambios</a> }
+ </td>
+ </tr>
+</table>
+</form>
+<h1><a name="Contenidos"> </a> Contenidos </h1>
+<p />
+<div class="twikiToc">
+<ul>
+<li> <a href="#Contenidos">Contenidos</a>
+</li>
+<li> <a href="#Qué_es_Typhon">Qué es Typhon?</a>
+<ul>
+<li> <a href="#Por_qué_C">Por qué C++?</a>
+</li>
+<li> <a href="#Por_qué_Python">Por qué Python?</a>
+</li>
+</ul>
+</li>
+<li> <a href="#Qué_significa_Typhon">Qué significa Typhon</a>
+</li>
+<li> <a href="#Alcance_del_Lenguaje">Alcance del Lenguaje</a>
+<ul>
+<li> <a href="#Sintaxis">Sintaxis</a>
+</li>
+<li> <a href="#Definiciones">Definiciones</a>
+</li>
+<li> <a href="#Características_aún_no_definidas">Características aún no definidas</a>
+<ul>
+<li> <a href="#Modo_de_iterar_una_secuencia">Modo de iterar una secuencia</a>
+</li>
+<li> <a href="#Uso_de_typeof">Uso de typeof</a>
+</li>
+<li> <a href="#Literales_de_strings">Literales de strings</a>
+</li>
+<li> <a href="#Palabra_reservada_block">Palabra reservada block</a>
+</li>
+<li> <a href="#Comentarios">Comentarios</a>
+</li>
+<li> <a href="#Compilación_condicional">Compilación condicional</a>
+</li>
+<li> <a href="#class_vs_struct">class vs. struct</a>
+</li>
+</ul>
+</li>
+</ul>
+</li>
+<li> <a href="#Ejemplos">Ejemplos</a>
+</li>
+<li> <a href="#Links">Links</a>
+</li>
+</ul>
+</div>
+<p />
+<h1><a name="Qué_es_Typhon"> </a><a name="Qué_es_Typhon_"> </a> Qué es Typhon? </h1>
+Typhon es (o será) un lenguaje de programación basado en C++ y Python.
+Typhon tendrá sintaxis al estilo Python y será traducido a C++ de forma lo
+más directa posible.
+<p />
+<h2><a name="Por_qué_C"> </a><a name="Por_qué_C_"> </a> Por qué C++? </h2>
+Porque es un lenguaje compilado eficiente y estándar, que provee una biblioteca
+lo suficientemente completa como para no necesitar mucho más para escribir
+cualquier programa. Porque dicha biblioteca estándar define ''interfaces'' que,
+a pesar de no tener soporte en el lenguaje (por eso surge Typhon también), hace
+que puedan usarse de forma consistente. Porque es extremadamente flexible y
+poderoso, porque es compatible con C, con todo lo que eso significa (que no es
+para nada poco).
+<p />
+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.
+<p />
+<h2><a name="Por_qué_Python"> </a><a name="Por_qué_Python_"> </a> Por qué Python? </h2>
+Python es uno de los mejores lenguajes de alto nivel y su sintaxis simple
+y clara es una de las principales razones. Python se puede leer de una forma
+muy natural y aún así, no es para nada tedioso de escribir, de hecho es uno
+de los lenguajes que más rápido puede tipearse. Python además obliga a
+producir código legible, al hacer checheo de identación, otra característica
+bastante deseable.
+<p />
+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.
+<p />
+<h1><a name="Qué_significa_Typhon"> </a> Qué significa Typhon </h1>
+Luca un día se despertó cruzado (creo que después de alguna discusión sobre Mono
+con gazer :) y se preguntó por qué catso no hay ningún lenguaje compilado de
+relativo alto nivel. Entre otras cosas estuvo jugando con Pyrex (un lenguaje
+<em>python-like</em> para hacer <em>wrappers</em> de C para Python); entre idas y venidas, se
+pensó en hacer que Python se traduzca a una serie de clases predefinidas y usar
+conteo de referencias para el manejo de memoria, etc; todo como para poder compilar
+Python casi igual a como lo conocemos ahora traduciéndolo a C++. Entre esas ideas,
+en algún momento alberto dijo "Python con tipos" y de ahí pensé en Typed Python y
+vi la T y la Y muy cerca y pensé que empezando con Ty (de Typed) podría armar un
+anagrama de Python. Lo obvio resultó <strong>Typhon</strong>.
+<p />
+Luego investigando el nombre, Typhon resulta ser una criatura de la
+<a href="http://www.classicsunveiled.com/mythnet/html/creature.html" target="_top">mitología griega</a>
+(un hombre/dragon con mil cabezas) al igual que Python (una especie de serpiente
+gigante); pero hay más aún.
+<p />
+Tanto Typhon como Python fueron <em>monstruos</em> creados por los viejos dioses para
+evitar que los dioes del Olimpo tomaran control del <em>bajomundo</em>.
+<p />
+Así que nombre más acertado para este lenguaje, difícilmente exista ;)
+<p />
+<h1><a name="Alcance_del_Lenguaje"> </a> Alcance del Lenguaje </h1>
+El lengueaje pretende dar acceso a un <em>subset</em> de C++ a través de sintaxis Python.
+Es decir, la traducción a C++ será lo más directa posible evitando así cualquier
+tipo de necesidad de traducción (<em>bindings</em>) para usar bibliotecas escritas tanto
+en C como en C++. Sólo se asumen cosas en cuanto a <em>interfaces</em> provistas por la
+<a href="http://www.sgi.com/tech/stl/" target="_top">STL</a>, como
+<a href="http://www.sgi.com/tech/stl/ForwardContainer.html" target="_top">Forward Containers</a>,
+<a href="http://www.sgi.com/tech/stl/Iterators.html" target="_top">Iterators</a>, etc. Para sacar
+todo el jugo a Typhon los tipos de datos más complejos deben estar escritos
+siguiendo el estilo de la STL (cosa que ya está pasando actualmente, las mejores
+bibliotecas en C++ como <a href="http://www.gtkmm.org/" target="_top">gtkmm</a>,
+<a href="http://libxmlplusplus.sourceforge.net/" target="_top">libxml2++</a>,
+<a href="http://www.gnu.org/software/cgicc/cgicc.html" target="_top">cgicc</a>, etc interaccionan bien
+con la STL y proveen interfaces similares).
+<p />
+<h2><a name="Sintaxis"> </a> Sintaxis </h2>
+En <span class="twikiNewLink" style='background : #FFFFCE;'><font color="#0000FF">TyphonSyntax</font><a href="/twiki/edit/Main/TyphonSyntax?topicparent=Main.TyphonLanguage"><sup>?</sup></a></span> está especificada la sintaxis del lenguaje, en notación
+<a href="http://www.garshol.priv.no/download/text/bnf.html" target="_top">EBNF</a> (o algo parecido,
+está basado en la especificación de Python).
+<p />
+<h2><a name="Definiciones"> </a> Definiciones </h2>
+Acá vamos a ir agregando cosas que definamos en cuanto al lenguaje:
+<ul>
+<li> 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++.
+</li>
+<li> 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 <code>yield</code> o formas
+ <code>lambda</code> que no van a estar).
+</li>
+<li> No va a <em>hardcodear</em> tipos de datos. Sin embargo <strong>sí</strong> se va a asumir una
+ <em>interfaz</em> tipo STL. Es decir el <em>foreach</em> se traducirá a iteradores del
+ estilo de la STL. Para hacer un <em>foreach</em> sobre cualquier tipo, este tipo
+ va a tener que cumplir el modelo de
+ <a href="http://www.sgi.com/tech/stl/ForwardContainer.html" target="_top">Forward Container</a>
+ en el sentido definido por la STL.
+</li>
+<li> Se va a <em>optimizar para el caso general</em> (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.
+</li>
+</ul>
+<p />
+<h2><a name="Características_aún_no_definidas"> </a> Características aún no definidas </h2>
+<h3><a name="Modo_de_iterar_una_secuencia"> </a> Modo de iterar una secuencia </h3>
+<strong>Prioridad:</strong> Alta
+<p />
+En C++ tendríamos 2 formas básicas de traducir:
+<hr />
+<pre>
+for item_t i in seq_t seq:
+</pre>
+<hr />
+por copia y por referencia. A su vez, cada una de estas formas puede ser
+constante o no, lo que nos da 4 posibilidades:
+<ol>
+<li> Que <code>i</code> sea una copia al ítem en <code>seq</code>
+</li>
+<li> Que <code>i</code> sea una copia constante al ítem de <code>seq</code>
+</li>
+<li> Que <code>i</code> sea una referencia al ítem de <code>seq</code>
+</li>
+<li> Que <code>i</code> sea una referencia constante al ítem de <code>seq</code>
+</li>
+</ol>
+Hacer una copia sería costoso en varios casos (de hecho en todo tipo de dato
+que ocupe más de lo que ocupa un puntero) y una copia constante sería demasiado
+raro que tenga alguna utilidad práctica. Por lo que nos queda decidir entre
+referencia o const referencia.
+<p />
+Probablemente lo más intuitivo (aunque <strong>no</strong> lo más seguro) sea tener una
+referencia modificable, y es esto lo que debería usarse por omisión según la
+premisa <em>optimizar para el caso general</em> . A esto se suma que iterar con una
+referencia constante sería bastante claro con una construcción como:
+<hr />
+<pre>
+for const item_t i in seq_t seq:
+</pre>
+<hr />
+En el caso inverso no hay ninguna palabra reservada lo suficientemente clara y
+realmente sería menos intuitivo (aunque menos suceptible a errores, al menos yo
+tengo la teoría de que todo debería ser constante a menos que se pueda demostrar
+que <strong>necesita</strong> ser variable :).
+<p />
+En caso de necesitarse una copia (querer modificar <code>i</code> dentro del cuerpo del
+<code><b>for</b></code> sin que los cambios se reflejen en los ítems de <code>seq</code>), siempre se puede
+hacer una copia explícita:
+<hr />
+<pre>
+for item_t i in seq_t seq:
+ item_t copia = i
+ copia += 2 * seq.size()
+ # etc.
+</pre>
+<hr />
+<p />
+<h4><a name="Implementación"> </a> Implementación </h4>
+<hr />
+<pre>
+for item_t i in seq_t seq:
+</pre>
+<hr />
+se traduciría:
+<hr />
+<pre>
+for (seq_t::iterator ___i = seq.begin(); ___i != seq.end(); ++___i)
+{
+ item_t& i = *___i; // Referencia
+ // ...
+}
+</pre>
+<hr />
+Mientras que:
+<hr />
+<pre>
+for const item_t i in seq_t seq:
+</pre>
+<hr />
+se traduciría:
+<hr />
+<pre>
+for (seq_t::const_iterator ___i = seq.begin(); ___i != seq.end(); ++___i)
+{
+ const item_t& i = *___i; // Referencia constante
+ // ...
+}
+</pre>
+<hr />
+<p />
+<h3><a name="Uso_de_typeof"> </a> Uso de typeof </h3>
+<strong>Prioridad:</strong> Media
+<p />
+<a href="http://gcc.gnu.org/onlinedocs/gcc-3.4.2/gcc/Typeof.html#Typeof" target="_top">typeof()</a>
+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 <code><b>for</b></code> 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 <em>forward declarations</em> podría evitarse el uso de
+<code><b>typeof</b></code>, pero los <em>forward declarations</em> 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 <em>compilador</em> (me refiero al traductor
+de Typhon a C++) para hacer uso o no de <code><b>typeof</b></code>. Si no se usa <code><b>typeof</b></code> el
+código tendrá que ser inevitablemente más redundante (tendrán que especificarse
+los tipos de más variables explícitamente y usar <em>forward declarations</em>) pero
+permitirá generar código ISO C++ que es una alta prioridad en Typhon.
+<p />
+<h4><a name="Implementación"> </a> Implementación </h4>
+El principal uso sería en un bloque <code><b>for</b></code>:
+<hr />
+<pre>
+for i in seq:
+</pre>
+<hr />
+se puede traducir a:
+<hr />
+<pre>
+for (typeof(seq.begin()) ___i = seq.begin(); ___i != seq.end(); ++___i)
+{
+ typeof(*___i)& i = *___i;
+ // ...
+}
+</pre>
+<hr />
+Sin tener absolutamente ninguna información sobre <code>seq</code>, ni sobre el tipo de elemento
+que contiene.
+<p />
+Esto podría llevarse más lejos y usar <em>tipos implícitos</em>:
+<hr />
+<pre>
+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
+</pre>
+<hr />
+esto se traduciría a:
+<hr />
+<pre>
+int f()
+{
+ return 5;
+}
+int main()
+{
+ typeof(f()) n = f(); // n tiene el tipo devuelto por f(), gracias al uso de typeof
+ return 0;
+}
+</pre>
+<hr />
+De nuevo, a pesar de que pueda ser conveniente, me parece muy suceptible
+a errores, ya que cualquier asignación se convertiría en una declaración
+implícita, haciendo que un <em>typo</em> en el nombre de una variable sea un <em>bug</em>
+muy difícil de encontrar (problema actual de la mayoría de los lenguajes
+interpretados).
+<p />
+<h4><a name="Palabra_reservada_auto"> </a> Palabra reservada auto </h4>
+Una posible solución a esto, que mantendría un buen equilibrio entre
+conveniencia y seguridad, sería agregar una palabra reservada como <code><b>auto</b></code>
+para <strong>declarar</strong> una variable con tipo implícito (de hecho se propuso en
+comp.lang.c++). El ejemplo anterior en Typhon sería:
+<hr />
+<pre>
+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
+</pre>
+<hr />
+De esta manera se puede distinguir claramente una declaración, pero dejamos
+en manos del <em>compilador</em> la deducción del tipo. De manera que si alguien
+tipea mal una variable en una asignación, no se crearía un símbolo nuevo y se
+convertiría en un error de compilación.
+<p />
+Un ejemplo con más sentido sería el caso en que se queira iterar un contenedor
+obteniendo una copia de cada ítem:
+<hr />
+<pre>
+for i in seq:
+ auto copia = i
+ copia += 2 * seq.size()
+ # etc.
+</pre>
+<hr />
+Por supuesto la declaración de una variable de tipo implícito deberá estar
+acompañada siempre de su inicialización, de otra manera no se puede deducir
+el tipo. Por lo tanto la expresión <code>auto mi_var</code> (sin una asignación) es un
+error de compilación.
+<p />
+<h3><a name="Literales_de_strings"> </a> Literales de strings </h3>
+<strong>Prioridad:</strong> Media/Alta
+<p />
+Aún no sabemos que vamos a hacer con los <em>strings largos</em> y <em>strings cortos</em>
+de Python.
+<p />
+<h4><a name="Shortstrings"> </a> <em>Shortstrings</em> </h4>
+<strong>Prioridad:</strong> Alta
+<p />
+En principio los strings cortos deberían poder escribirse sólo con <code>"</code>
+(comillas dobles) porque las <code>'</code> (comillas simples) deberían usarse para
+expresar literales <code><b>char</b></code> como en C/C++.
+<p />
+<h4><a name="Longstrings"> </a> <em>Longstrings</em> </h4>
+<strong>Prioridad:</strong> Media
+<p />
+Con respecto a los <em>string largos</em> 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.
+<p />
+<h4><a name="Prefijos"> </a> Prefijos </h4>
+<strong>Prioridad:</strong> Media/Alta
+<p />
+También hay que definir si se soportan los prefijos (como <code>r</code> para strings
+<em>raw</em>, <code>u</code> para <em>unicode</em>, etc). Tener en cuenta que traducirlos podría
+romper la compatibilidad en ciertos ámbitos.
+<p />
+<h5><a name="Strings_traducibles"> </a> Strings traducibles </h5>
+<strong>Prioridad:</strong> Media
+<p />
+También podría incluirse el prefijo <code>_</code> 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 <em>compilador</em>. De hecho podría tener soporte para varios sistemas
+de internacionalización.
+<p />
+Por otro lado, siguien la hipótesis de <em>optimizar para el caso general</em>,
+podría tomarse por omisión a todos los strings como traducibles, excepto a
+los que lleven el prefijo <code>_</code>, ya que por lo general, la mayor parte de los
+strings en un programa son traducibles.
+<p />
+Todo esto podría manejarse con opciones de línea de comandos a la hora de
+<em>compilar</em>, 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.
+<p />
+<h3><a name="Palabra_reservada_block"> </a> Palabra reservada block </h3>
+<strong>Prioridad:</strong> Baja
+<p />
+Serviría para hacer un bloque de código arbitrario. Es útil para técnicas
+de programación como <em>sentries</em>.
+<p />
+<h4><a name="Ejemplo"> </a><a name="Ejemplo_"> </a> Ejemplo: </h4>
+<hr />
+<pre>
+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
+</pre>
+<hr />
+<p />
+<h4><a name="Workarround"> </a> Workarround </h4>
+Esto podría emularse con:
+<hr />
+<pre>
+if 1:
+ # código del bloque acá
+</pre>
+<hr />
+<p />
+<h3><a name="Comentarios"> </a> Comentarios </h3>
+<strong>Prioridad:</strong> Media
+<p />
+<h4><a name="Comentarios_multilínea"> </a> Comentarios multilínea </h4>
+<strong>Prioridad:</strong> Media
+<p />
+A Python le falta comentarios multilínea, cosa que me resulta bastante
+molesto.
+<p />
+<h4><a name="Comentarios_multilínea_anidados"> </a> Comentarios multilínea anidados </h4>
+<strong>Prioridad:</strong> Media
+<p />
+D tiene comentarios anidados, cosa muy conveniente para <em>comentar</em> un
+bloque de código grande que a su vez pueda tener comentarios adentro.
+Me parecería piola que Typhon tenga algo similar.
+<p />
+<h3><a name="Compilación_condicional"> </a> Compilación condicional </h3>
+<strong>Prioridad:</strong> Media
+<p />
+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 <code>version</code>, que es básicamente lo mismo
+que un <code>#ifdef ... #endif</code> del precompilador. Creo que Typhon podría
+proveer algo similar. Por ejemplo:
+<hr />
+<pre>
+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.
+</pre>
+<hr />
+Luego para <em>compilar</em> podría haber un flag:
+<verbatim> tyc -V DEBUG archivo.ty <verbatim>
+<p />
+Podrían definirse versiones <em>estándar</em> como en D, como <code>LINUX</code>, <code>WIN32</code>,
+<code>MACOS</code>, etc que se activen automáticamente dependiendo de la plataforma
+en la que corra el <em>compilador</em>.
+<p />
+Todo esto puede traducirse de forma bastante inmediata y sin mayores
+inconvenientes a directivas del precompilador.
+<p />
+<h3><a name="class_vs_struct"> </a> class vs. struct </h3>
+<strong>Prioridad:</strong> Alta
+<p />
+En C++ una clase y una estructura son exactamente igual, sólo que la clase
+tiene visibilidad privada por omisión y el struct pública. Ninguna de las
+dos hace virtuales sus métodos a menos que sea especificado explícitamente.
+<p />
+Las clases en la mayoría de los lenguajes de alto nivel son completamente
+virtuales, sin posibilidad siquiera de que sea de otra forma. Incluso en
+C++ el struct suele utilizarse para tipos de datos más simples y
+concretos, que muy difícilmente tengan algún método virtual (aunque no hay
+ninguna razón técnica que lo impida).
+<p />
+Siguendo esta línea y la premisa de <em>optimizar para el caso general</em>
+probablemente sea una buena idea que las clases tengan todos sus métodos
+virtuales por omisión y las estructuras no.
+<p />
+El problema de esto es que debería haber alguna palabra clave para hacer un
+método no virtual, para tener una mayor flexibilidad y no tener que caer en
+un struct con muchos métodos virtuales declarados explícitamente porque se
+necesita que un método particular no sea virtual.
+<p />
+<h4><a name="Visibilidad"> </a> Visibilidad </h4>
+Con respecto a la visibilidad por omisión, creo que es indiscutible que las
+estructuras deben tener visibilidad pública, pero con las clases no es tan
+claro. En los lenguajes interpretados, las clases suelen tener visibilidad
+pública por omisión y los lenguajes más <em>serios</em> suelen tener visibilidad
+privada. Que tenga visibilidad privada no tiene muchas más ventajas que dejar
+contento a los abanderados de la orientación a objetos estricta (al menos
+para mí :), por lo que probablemente lo más conveniente es que tanto las
+clases como estructuras tengan visibilidad pública por omisión.
+<p />
+Lo mismo para la visibilidad en la herencia, en este caso creo que es mucho
+más claro que lo más natural es que la herencia sea pública por omisión.
+<p />
+<h4><a name="Herencia_virtual"> </a> Herencia virtual </h4>
+Es un caso muy poco frecuente y no creo que haya una mejor manera de
+manejarlo que la de C++, así que creo que debería mantenerse la herencia
+como no virtual por omisión pero permitir que lo sea si se lo especifica
+explícitamente.
+<p />
+<h4><a name="Ejemplo"> </a> Ejemplo </h4>
+<hr />
+<pre>
+class C:
+ C(): cout << "Constructor de C\n"
+ int hacer_algo(double i) const: return i/2
+ ~C(): cout << "Destructor de C\n"
+</pre>
+<hr />
+Se traduciría como:
+<hr />
+<pre>
+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";
+}
+</pre>
+<hr />
+Mientras que:
+<hr />
+<pre>
+struct C:
+ C(): cout << "Constructor de C\n"
+ int hacer_algo(double i) const: return i/2
+ ~C(): cout << "Destructor de C\n"
+</pre>
+<hr />
+Se traduciría como:
+<hr />
+<pre>
+struct C
+{
+ C();
+ int hacer_algo(double i) const;
+ ~C();
+};
+// ídem anterior
+</pre>
+<hr />
+<strong><em>Nota:</em></strong> La declaración de C++ estaría en un <code>.h</code> y la definición en un <code>.cpp</code>.
+<p />
+<h1><a name="Ejemplos"> </a> Ejemplos </h1>
+Los ejemplos se mudaron a <a class="twikiLink" href="/twiki/view/Main/TyphonExamples">TyphonExamples</a> porque eran demasiado extensos.
+<p />
+<h1><a name="Links"> </a> Links </h1>
+<ul>
+<li> <a href="http://www.research.att.com/~bs/3rd.html" target="_top">The C++ Programming Language</a> -
+ Lenguaje de programación compilado al cual se traducirá Typhon.
+</li>
+<li> <a href="http://www.python.org/" target="_top">Python</a> - Lenguaje interpretado en el cual
+ Typhon va a basar su sintaxis.
+</li>
+<li> <a href="http://www.sgi.com/tech/stl/" target="_top">Standard Template Library</a> -
+ Biblioteca estándar de C++, Typhon va a usar sus características e
+ interfaces para traducir secuencias y cosas similares.
+</li>
+<li> <a href="http://www.digitalmars.com/d/" target="_top">The D Programming Language</a> -
+ Lenguaje compilado parecido a C++ pero con algunas caracteristicas de más
+ alto nivel y otras cosas muy interesantes, de las cuales tal vez podrían
+ agregarse un par a Typhon.
+</li>
+<li> <a href="http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex/" target="_top">Pyrex</a> - Un
+ lenguaje que es prácticamente una extensión a python para mezclarlo con C,
+ diseñado específicamente para hacer bindings de C para Python. Fue una de
+ las fuentes de inspiración para Typhon.
+</li>
+</ul>
+<p />
+<p />
+<br clear="all" />
+<table width="100%" border="0" cellpadding="3" cellspacing="0">
+ <tr bgcolor="#FFFFC0">
+ <td valign="top">
+ Topic <b><B style="color:black;background-color:#ffff66">TyphonLanguage</B></b> . { <a href="/twiki/edit/Main/TyphonLanguage?t=1125215253"><b>Edit</b></a>
+ | <a href="/twiki/attach/Main/TyphonLanguage">Attach</a>
+ | <a href="/twiki/search/Main/SearchResult?scope=text&regex=on&excludetopic=TyphonLanguage&search=Typhon%20*Language%5B%5EA-Za-z0-9%5D">Ref-By</a>
+ | <a href="/twiki/view/Main/TyphonLanguage?skin=print">Printable</a>
+ | <a href="/twiki/rdiff/Main/TyphonLanguage">Diffs</a> | r1.2 | <a href="/twiki/rdiff/Main/TyphonLanguage?rev1=1.2&rev2=1.1">></a> | <a href="/twiki/view/Main/TyphonLanguage?rev=1.1">r1.1</a>
+ | <a href="/twiki/oops/Main/TyphonLanguage?template=oopsmore&param1=1.2&param2=1.2">More</a>
+ }
+ </td>
+ </tr>
+</table>
+<table width="100%" border="0" cellpadding="3" cellspacing="0">
+ <tr>
+ <td>
+<div class="TWikiFooterNote">
+ Revision r1.2 - 08 Oct 2004 - 02:33 - <a class="twikiLink" href="/twiki/view/Main/LeandroLucarella">LeandroLucarella</a>
+<p />
+ </div>
+<p />
+ </td>
+ <td width="50%">
+ <div class="TWikiCopyright">
+<font size="-2">%WEBCOPYRIGHT%</font>
+</div>
+ </td>
+ </tr>
+</table>
+<a name="PageBottom"></a>
+</body>
+</html>
\ No newline at end of file
--- /dev/null
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<BASE HREF="https://wiki.lugmen.org.ar/twiki/view/Main/TyphonExamples?skin=print"><table border=1 width=100%><tr><td><table border=1 bgcolor=#ffffff cellpadding=10 cellspacing=0 width=100% color=#ffffff><tr><td><font face=arial,sans-serif color=black size=-1>Ésta es la versión <b><font color=#0039b6>G</font> <font color=#c41200>o</font> <font color=#f3c518>o</font> <font color=#0039b6>g</font> <font color=#30a72f>l</font> <font color=#c41200>e</font></b> <a href="http://www.google.com/intl/es/help/features.html#cached"><font color=blue>guardada en el caché</font></a> de la <A HREF="https://wiki.lugmen.org.ar/twiki/view/Main/TyphonExamples?skin=print"><font color=blue>https://wiki.lugmen.org.ar/twiki/view/Main/TyphonExamples?skin=print</font></a> obtenida el 1 Dic 2004 15:35:29 GMT.<br>
+La caché de <b><font color=#0039b6>G</font> <font color=#c41200>o</font> <font color=#f3c518>o</font> <font color=#0039b6>g</font> <font color=#30a72f>l</font> <font color=#c41200>e</font></b> es la instantánea de la página que tomamos cuando exploramos la Web en forma automática.<br>
+Es posible que la página haya cambiado desde entonces. Haga clic aquí para ver la <A HREF="https://wiki.lugmen.org.ar/twiki/view/Main/TyphonExamples?skin=print"><font color=blue>página actual</font></a> sin resaltar.<br>
+Esta página guardada en el caché puede hacer referencia a imágenes que ya no están disponibles. Haga clic aquí para obtener únicamente el <A HREF="http://66.102.7.104/search?q=cache:hVONU0SZ6CIJ:https://wiki.lugmen.org.ar/twiki/view/Main/TyphonExamples%3Fskin%3Dprint+typhonexamples&hl=es&lr=&strip=1"><font color=blue>texto guardado en el caché</font></a>.<br>Para vincularse a esta página o para marcarla, utilice el siguiente url: <code>http://www.google.com/search?q=cache:hVONU0SZ6CIJ:https://wiki.lugmen.org.ar/twiki/view/Main/TyphonExamples%3Fskin%3Dprint+typhonexamples&hl=es</code></font><br><br><center><font size=-2><i>Google no tiene relación con los autores de esta página ni es responsable de su contenido.</i></font></center></td></tr>
+<tr><td>
+<table border=0 cellpadding=0 cellspacing=0><tr><td><font face=arial,sans-serif color=black size=-1>Se han resaltado estos términos de búsqueda: </font></td><td bgcolor=#ffff66><B><font face=arial,sans-serif color=black size=-1>typhonexamples </font></B></td></tr></table>
+</td></tr></table></td></tr></table>
+<hr>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+ <title> TWiki . Main . TyphonExamples</title>
+ <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+ <base href="https://wiki.lugmen.org.ar/twiki/view/Main/TyphonExamples" />
+</head>
+<body bgcolor="#ffffff">
+<a name="PageTop"></a>
+<table width="100%" border="0" cellpadding="3" cellspacing="0">
+ <tr bgcolor="#FFFFC0">
+ <td>
+ <b>TWiki . Main . </b><font size="+2"><b><B style="color:black;background-color:#ffff66">TyphonExamples</B></b></font>
+ </td>
+ </tr>
+</table>
+<p />
+<h1><a name="Ejemplos_de_TyphonLanguage"> </a> Ejemplos de <a href="/twiki/view/Main/TyphonLanguage">TyphonLanguage</a> </h1>
+<p />
+<p />
+<ul>
+<li> <a href="/twiki/view/Main/TyphonExamples#Ejemplos_de_TyphonLanguage">Ejemplos de TyphonLanguage</a>
+</li>
+<li> <a href="/twiki/view/Main/TyphonExamples#Hello_world">Hello world</a>
+</li>
+<li> <a href="/twiki/view/Main/TyphonExamples#Lista_argumentos_de_l_nea_de_com">Lista argumentos de línea de comandos</a>
+</li>
+<li> <a href="/twiki/view/Main/TyphonExamples#Word_Count_wc_">Word Count (wc)</a>
+</li>
+</ul>
+<p />
+<h1><a name="Hello_world"> Hello world </a></h1>
+<h2><a name="Typhon"> Typhon </a></h2>
+<hr />
+<pre>
+include stdio.h
+int main():
+ printf("Hola mundo!")
+ return 0
+</pre>
+<hr />
+<p />
+<h2><a name="C_"> C++ </a></h2>
+<hr />
+<pre>
+#include <stdio.h>
+int main()
+{
+ printf("Hola mundo!");
+ return 0;
+}
+</pre>
+<hr />
+<p />
+<h1><a name="Lista_argumentos_de_l_nea_de_com"> Lista argumentos de línea de comandos </a></h1>
+Las líneas separan bloques de código para ver como Typhon traduciría a C++.
+<p />
+<h2><a name="Typhon"> Typhon </a></h2>
+<hr />
+<pre>
+include vector, string, iostream
+import vector, string, cout from std
+int main(vector<string> args):
+ for const string& s in vector<string> args:
+ cout << s << "\n"
+ return 0
+</pre>
+<hr />
+<p />
+<h2><a name="C_"> C++ </a></h2>
+<hr />
+<pre>
+// include vector, string, iostream
+#include <vector>
+#include <string>
+#include <iostream>
+// import vector, string, cout from std
+using std::vector;
+using std::string;
+using std::cout;
+// int main(vector<string> args):
+int main(int ___argc, char* ___argv[]):
+ vector<string> args(___argc);
+ for (int i = 0; i < ___argc; ++i)
+ args.push_back(___argv[i]);
+ // for const string& s in vector<string> args:
+ for (vector<string>::const_iterator ___s = args.begin();
+ ___s != args.end();
+ ++___s)
+ {
+ const std::string& s = *___s;
+ // cout << s << "\n"
+ cout << s << "\n";
+ // for const string& s in vector<string> args:
+ }
+ // return 0
+ return 0;
+// int main(vector<string> args):
+}
+</pre>
+<hr />
+<p />
+<h1><a name="Word_Count_wc_"> Word Count (wc) </a></h1>
+<h2><a name="D"> D </a></h2>
+Extraído de los ejemplos del compilador dmd para linux. Sólo para comparar la
+complejidad sintáctica y la cantidad de código que se necesita escribir en un
+lenguaje que podría acercarse de algún modo a donde <a href="/twiki/view/Main/TyphonLanguage">TyphonLanguage</a> apunta.
+<hr />
+<pre>
+import std.file;
+
+int main (char[][] args)
+{
+ int w_total, l_total, c_total;
+ printf (" lines words bytes file\n");
+ foreach (char[] arg; args[1 .. args.length])
+ {
+ int w_cnt, l_cnt, c_cnt;
+ bool inword;
+ char[] input = cast(char[])std.file.read(arg);
+ foreach (char c; input)
+ {
+ if (c == '\n')
+ ++l_cnt;
+ if (c != ' ')
+ {
+ if (!inword)
+ {
+ inword = 1;
+ ++w_cnt;
+ }
+ }
+ else
+ inword = 0;
+ ++c_cnt;
+ }
+ printf ("%8lu%8lu%8lu %.*s\n", l_cnt, w_cnt, c_cnt, arg);
+ l_total += l_cnt;
+ w_total += w_cnt;
+ c_total += c_cnt;
+ }
+ if (args.length > 2)
+ {
+ printf ("--------------------------------------\n%8lu%8lu%8lu total",
+ l_total, w_total, c_total);
+ }
+ return 0;
+}
+</pre>
+<hr />
+<p />
+<h2><a name="Typhon"> Typhon </a></h2>
+Escrito lo más parecido posible (por más ineficiente y feo que sea :) al ejemplo
+de D (sacado de los ejemplos del compilador de <span style='background : #FFFFCE;'><font color="#0000FF">DigitalMars</font></span><a href="/twiki/edit/Main/DigitalMars?topicparent=Main.TyphonExamples">?</a>).
+<hr />
+<pre>
+include fstream, iostream, vector, string, iomanip
+
+import cout, vector, string, ifstream, getline, setw from std
+
+int main (vector<string> args):
+ int w_total = 0, l_total = 0, c_total = 0
+ cout << " lines words bytes file\n"
+ for string arg in args[1:]:
+ int w_cnt = 0, l_cnt = 0, c_cnt = 0
+ bool inword = false
+ string contenido
+ block:
+ ifstream f(arg)
+ string buff
+ while getline(f, buff):
+ contenido += buff
+ for char c in contenido:
+ if c == '\n':
+ ++l_cnt
+ if c != ' ':
+ if not inword:
+ inword = true
+ ++w_cnt
+ else:
+ inword = false
+ ++c_cnt
+ cout << width(8) << l_cnt << width(8) << w_cnt << width(8) << c_cnt << " " << arg << "\n"
+ l_total += l_cnt
+ w_total += w_cnt
+ c_total += c_cnt
+ if args.size() > 2:
+ cout << "--------------------------------------\n"
+ cout << width(8) << l_total << width(8) << w_total << width(8) << c_total << " total.\n"
+ return 0
+</pre>
+<hr />
+<p />
+<h2><a name="C_"> C++ </a></h2>
+Tener en cuenta que este sería el código generado automáticamente por Typon.
+Obviamente no es la forma más compacta ni la más clara de escribir el programa
+en C++.
+<p />
+Este programa, por supuesto, compila y anda.
+<hr />
+<pre>
+#include <fstream>
+#include <iostream>
+#include <vector>
+#include <string>
+#include <iomanip>
+
+using std::cout;
+using std::vector;
+using std::string;
+using std::ifstream;
+using std::getline;
+using std::setw;
+
+int main(int ___argc, char* ___argv[])
+{
+ vector<string> args;
+ args.reserve(___argc);
+ for (int i = 0; i < ___argc; ++i)
+ args.push_back(___argv[i]);
+ int w_total = 0, l_total = 0, c_total = 0;
+ cout << " lines words bytes file\n";
+ for (vector<string>::iterator ___arg = args.begin()+1;
+ ___arg != args.end();
+ ++___arg)
+ {
+ string arg = *___arg;
+ int w_cnt = 0, l_cnt = 0, c_cnt = 0;
+ bool inword = false;
+ string contenido;
+ {
+ ifstream f(arg.c_str());
+ string buff;
+ while (getline(f, buff))
+ {
+ contenido += buff;
+ }
+ }
+ for (string::iterator ___c = contenido.begin();
+ ___c != contenido.end();
+ ++___c)
+ {
+ char c = *___c;
+ if (c == '\n')
+ {
+ ++l_cnt;
+ }
+ if( c != ' ')
+ {
+ if (not inword)
+ {
+ inword = true;
+ ++w_cnt;
+ }
+ }
+ else
+ {
+ inword = false;
+ }
+ ++c_cnt;
+ }
+ cout << setw(8) << l_cnt << setw(8) << w_cnt << setw(8) << c_cnt << " " << arg << "\n";
+ l_total += l_cnt;
+ w_total += w_cnt;
+ c_total += c_cnt;
+ }
+ if (args.size() > 2)
+ {
+ cout << "--------------------------------------\n";
+ cout << setw(8) << l_total << setw(8) << w_total << setw(8) << c_total << " total.\n";
+ }
+ return 0;
+}
+</pre>
+<hr />
+<p />
+<p />
+<p />
+<table width="100%" border="0" cellpadding="3" cellspacing="0">
+ <tr bgcolor="#FFFFC0">
+ <td valign="top">
+ <code>-----</code> Revision r1.1 - 07 Oct 2004 - 19:43 GMT - <a href="/twiki/view/Main/LeandroLucarella">LeandroLucarella</a>
+ </td>
+ </tr>
+</table>
+Copyright © 2000-2004 por los autores contribuyentes
+<a name="PageBottom"></a>
+</body>
+</html>
\ No newline at end of file
projects / personal / typhon.git / commitdiff