AjIo: Intérprete tipo Io en C#

El año pasado, descubrí el lenguaje de programación Io:

http://www.iolanguage.com/

overview

Io is a prototype-based programming language inspired by Smalltalk (all values are objects, all messages are dynamic), Self (prototype-based), NewtonScript (differential inheritance), Act1 (actors and futures for concurrency), LISP (code is a runtime inspectable/modifiable tree) and Lua (small, embeddable).

Tiene una sintaxis simple, sus características están basadas en lenguajes funcionales, Smalltalk, Self y otros. Como de costumbre, quiero escribir mi propia versión, con un cambio: soporte de objetos nativos. Esto es, para implementar un intérprete sobre una máquina virtual con librería de clases. Las actuales opciones son Java y .NET.

Dos semanas atrás, el bueno de @MartinSalias me comentó sobre el lenguaje Io, y apareció de nuevo en mi radar. Entonces, el pasado domingo, comencé mi propia implementación, basado solamente en lo que leí en el sitio. No será el mismo lenguaje, veré que quedará o no adentro de esta implementación. Es trabajo en progreso.

El código está en mi proyecto de Google AjCodeKata:

http://code.google.com/p/ajcodekatas/

En el trunk, en el directorio AjIo. Hay una solución .NET, con tres proyectos:

La librería de clases es el núcleo, el programa de consola puede ser usado para interactuar con el intérprete, y el proyecto de test tiene las pruebas automáticas que escribí durante el proceso de diseño/codificación.

He escrito el lexer, el parser, y los principales objetos del lenguaje usando Test-Driven Development, como acostumbro.

En una de las primeras pruebas del intérprete, podemos escribir:

Hace unos días, implementé los operadores de asignación ::=, :=, = (arreglos de sintaxis adornando los métodos setSlot, newSlot, updateSlot):

Un tiempo més tarde (pueden consultar el History.txt dentro del repositorio), agregué soporte de objectos nativos .NET:

Próximos pasos:

- Escribir más operadores de comparación (sólo escribí ==)
- Números nativos (ahora, sólo son reconocidos por el lexer los enteros, pero pueden manejarse otros tipos, probar 1 / 6, retorna un double)
- Precedencia en operatdores aritméticos (ahora 2 + 2 * 3 retorna 12, en vez 8)
- for, foreach, range, y más (ahora hay sólo if())
- block() (Tengo implementado method())
- include()
- Comenzar a escribir parte de los objetos de la librería original de Io

Sobre este últimos punto: debo decidir cóomo implemento cosas como:

List clone

Posibles opciones:

- List como un objecto derivado de Object (obtenido de(Object clone) con sus propios slots, como wrapper sobre una lista nativa
- List clone retornando objectos ArrayList nativos, teniendo el tipo ArrayList sus slots asociados
- No implementar List, y usar directamente objetos nativos

Como en AjSharp, el Io original tiene agentes y coroutines. Quiero agregar las características de AjSharp (agentes, goroutines, channels, queue channels, futures) en AjIo. Io implementa agentes en “threads” de máquina virtual: esto es, no usa los threads del sistema operativo, sino que la máquina virtual va ejecutando parte de un agente, parte del otro, pasado de un código a otro durante la ejecución  (eso es lo que imagino, no he visto el código de implementación). No tomaré esa aproximación, no por ahora.

Este artículo, en Anglish:

http://ajlopez.wordpress.com/2010/04/30/working-in-ajio-io-like-interpreter-in-c/

Como ven, me he divertido escribiendo todo esto!

Nos leemos!

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

This entry was posted in 12677, 13671, 1389, 5374, 8870, 8871. Bookmark the permalink.

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>