Io (lenguaje de programación)

Io

Desarrollador(es)
Steve Dekorte, Jonathan Wright, Jeremy Tregunna https://iolanguage.org/
Información general
Paradigma	POO, basada en prototipos
Apareció en	2002
Diseñado por	Steve Dekorte
Sistema de tipos	Tipado duro o fuerte, Estático y dinámico
Implementaciones	Io Io.NET Acute
Dialectos	Europa Metis
Influido por	Smalltalk, NewtonScript, Self, Lua, Lisp
Ha influido a	Ioke, Restricted Io, Fancy, Luna
Licencia	BSD
[editar datos en Wikidata]

Io es un lenguaje de programación del tipo orientada a objetos inspirado en Smalltalk, Self, Lua, Lisp, Act1, y NewtonScript.^[1]

Io usa un paradigma de objetos basada en prototipos tal como lenguajes como Self y NewtonScript, eliminando las diferencias entre clases e instancias.

Tal como Smalltalk, absolutamente todo es un objeto y como en el caso de Lisp, los programas son árboles de datos. Io también usa actores para la concurrencia.

También es destacable que Io corre sobre una ligera y portable Máquina virtual.

YouTube Encyclopedic

1/3
Views:
2 294
6 422
2 010

Transcription

Historia

Este lenguaje fue creado por Steve Dekorte el 7 de marzo de 2002, después de intentar ayudar a un amigo, Dru Nelson, con en lenguaje Cel. Él se encontró con que sabía mucho de como funcionaban los lenguajes y decicio escribir un pequeño lenguaje para entender mejor los problemas.

Filosofía

Io intenta explorar la unificación conceptual y el dinamismo del lenguaje, priorizando la simplicidad y flexibilidad sobre el rendimiento.

Características

Lenguaje basado en objetos puro, del tipo prototipado
Evaluación perezosa de parámetros de funciones
Manejo de excepciones
Expresiones regulares del tipo Perl
Recolector de basura con soporte para referencia débil
Altamente portable
Carga dinámica de DLL y bibliotecas compartidas en la mayoría de las plataformas
introspección, reflexión y metraprogramación
Concurrencia basada en Actores (Informática)
Corrutinas
Máquina virtual ligera
Funciones de orden superior

Sintaxis

En su forma más simple, un programa Io está compuesto por un identificador simple:

 hacerAlgo

Si hacerAlgo es un método, está siendo invocado con cero argumentos, y por ser cero, los paréntesis explícitos no son necesarios.

Si hacerAlgo recibiera argumentos, se vería así:

 hacerAlgo(42)

Io es un lenguaje de paso de mensajes, y como todo en Io es un mensaje (excepto los comentarios), cada mensaje es enviado a un recipiente. El ejemplo de arriba lo demuestra bien, pero no por completo. Para describir este punto mejor, aquí hay otro ejemplo:

 System version

Este ejemplo demuestra el paso de mensajes en Io: el mensaje version es enviado al objeto System.

Los operadores son un caso especial en donde la sintaxis no es "simple y llana" como en los ejemplos anteriores. El parser de Io detecta un conjunto de operadores definidos por el intérprete, y los convierte en invocación de métodos. Por ejemplo:

 1 + 5 * 8 + 1

traduce a:

 1 + (5 *(8)) +(1)

Como se puede observar, hay precedencia de operadores de la que el parser se encarga. Los niveles de precedencia son los mismos que en C.

Los operadores también se convirtieron en invocación de métodos. De hecho, todos los operadores son métodos, el hecho de que no necesitan paréntesis es solo por conveniencia.

Métodos y Bloques

En Io hay dos formas de crear funciones anónimas: métodos y bloques. Son casi idénticos excepto por el contexto en que se ejecutan, los bloques tienen un contexto léxico y los métodos un contexto dinámico.

Ambos, métodos y bloques, son funciones de primera clase.

Ejemplos

El clásico Hola Mundo:

 "Hola Mundo!" println

Nuevos objetos son creados clonando otros objetos. Específicamente en Io, cuando un nuevo objeto vacío se crea, lo único que se guarda en el objeto son sus diferencias con sus padres. Este comportamiento se conoce como herencia diferencial. El siguiente ejemplo demuestra este comportamiento:

 A := Object clone         // crea un nuevo objeto vacío, llamado "A"

Una función factorial simple, no recursiva:

factorial := method(n,
:    if(n == 0, return 1)
:    res := 1
:    Range 1 to(n) foreach(i, res = res * i)
)

Como la última acción es la asignación de res * i a la variable res, la función implícitamente devuelve el valor asignado, de modo que no hace falta un return explícito. Este ejemplo también demuestra el uso de rangos (en vez de usar bucles for, que pueden ser más rápidos).