P. 1
Exploracion del Lenguaje Script Boo

Exploracion del Lenguaje Script Boo

|Views: 84|Likes:
Publicado porAprender Libre
Boo es un lenguaje de script diseñado para Mono y .NET. Esta extraña mezcla de Python y C# podria ser justo lo que se necesita para comenzar con la plataforma .NET.
Boo es un lenguaje de script diseñado para Mono y .NET. Esta extraña mezcla de Python y C# podria ser justo lo que se necesita para comenzar con la plataforma .NET.

More info:

Published by: Aprender Libre on Jun 30, 2012
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

02/01/2013

pdf

text

original

Boo • DESARROLLO

UNA HISTORIA DE FANTASMAS
Boo es un lenguaje de script diseñado para Mono y .NET. Esta extraña mezcla de Python y C# podría ser justo lo que se necesita para comenzar con la plataforma .NET. POR TIM SCHÜRMANN
odrigo Barreto de Oliveira estaba frustrado; no podía encontrar un lenguaje de programación que fuera adecuado para su próximo proyecto. Python no poseía la clase de comprobación de tipos estáticos que necesitaba y no tenía una buena integración con .NET. C# estaba bien integrado con .NET, pero requería demasiadas comprobaciones de tipos. Estos inconvenientes le llevaron a desarrollar su propio lenguaje de script. Se basaría en Python y dependería de CLI (Common Language Infrastructure) en el marco Dotnet. El resultado lo aliñó con un poco de C# y con los principios de diseño de Ruby, y finalmente obtuvo el lenguaje orientado a objetos Boo [1], disponible para Linux gracias al entorno Mono.

Exploración del Lenguaje de Script Boo

R

Despedida
Como el típico “Hola Mundo” con su línea print(“Hola Mundo”) es tan trivial, el Listado 1 proporciona una variante en GTK#. Boo no encierra simplemente bloques de código continuos entre llaves, sino que utiliza el sangrado, del mismo modo que lo hace Python. De hecho, ni siquiera se permite escribir end para finalizar un bloque. Tampoco utiliza los puntos y comas para finalizar las sentencias, que sólo deberían utilizarse para resolver las ambigüedades. Por otro lado, Boo soporta los dos tipos de comentarios de Python, los que comienzan por # y los típicos de C y C++, /* y //. @ZT:Variables Al contrario que Python, Boo utiliza tipos estáticos; es decir, hay que establecer el tipo de una variable antes de utilizarla por primera vez. Una ventaja de

esta solución es que el compilador detectará las asignaciones incorrectas en tiempo de compilación y se quejará de ello. Para evitar que los programadores se tengan que pelear con los tipos de datos, el compilador inteligente de Boo automáticamente derivará el tipo

Listado 1: Hola GTK#
01 import Gtk 02 03 Application.Init() 04 window = Window(“Hola Mundo”, DefaultWidth: 300, DefaultHeight: 200) 05 06 window.DeleteEvent += def(): 07 Application.Quit () 08 09 window.ShowAll() 10 Application.Run()

WWW.LINUX- MAGAZINE.ES

Número 25

53

DESARROLLO • Boo

o bien utilizar una notación reducida:
a=[1,2,3,4, ‘cinco’] print(a[:3])

Hoy Cerramos
Boo incluso permite la definición de una función dentro de otra:
def outer(): inner = def(): print(“inner ha U sido llamada”) inner() outer()

range() es una función interna que proporciona valores dentro de un rango dado. Como muestra el ejemplo, es posible mezclar tipos dentro de una lista. En Boo, la abreviatura usada en el comando print se denomina operación de troceado; en este caso, devuelve los Figura 1: El sitio web del proyecto Boo proporciona fragmentos tres primeros valores de de código y una introducción muy útil al lenguaje Boo. a. Boo también soporta las expresiones regulacorrecto en un proceso conocido como res, incluyendo el operador de corresinferencia de tipos: pondencia (=~):
a as int // a es un entero a= 3 b=a print b ejemplo= “Esto es un test” if ejemplo=~ @/te.t/: print(“contenido”)

Esta técnica está a un paso de los cierres. De nuevo, Boo toma este concepto de la programación funcional. Un cierre o bloque es una porción de código o el cuerpo de una función donde las variables locales de la función que las encierra son visibles, y por tanto pueden usarse. Boo soporta dos formas sintácticamente diferentes: la sintaxis basada en bloques, como la del ejemplo que acaba-

Compilación
Existen tres opciones para ejecutar los scripts de Boo. Independientemente de la que se elija, antes de comenzar habrá que instalar el entorno Mono y descomprimir el paquete Boo de [1]. En primer lugar, se puede utilizar el compilador booc.exe, para compilar un script: mono bin/booc.exe -out:U hello.exe hello.boo El binario generado a partir del script hello.boo puede ejecutarse con el comando mono hello.exe. La opción -r incluirá cualquier DLL adicional que se necesite: mono bin/booc.exe -r:U gtk-sharp -out:hellogtk.exe U hellogtk.boo Cuando se distribuyan programas como este habrá que incluir la librería Boo.Lang.dll del directorio bin con el paquete de distribución. Además del compilador de Boo, el paquete también incluye el intérprete booi.exe, que puede ejecutar los scripts de Boo directamente, como mono bin/booi.exe hello.boo. Por otro lado, también disponemos de una shell interactiva booish.exe que soporta la entrada directa de comandos en un estilo similar a Python. Por último, se puede utilizar la API de Boo para ejecutar el código Boo. Los objetos Dotnet que proporciona la API incluso permitirán ejecutar un script de Boo dentro de otro (Listado 5).

Está bastante claro que b debe ser un número. De hecho, la primera línea de este ejemplo es redundante, ya que el compilador posee toda la información que necesita a partir del 3. Los programadores sólo tienen que declarar las variables explícitamente cuando la inferencia de tipos no vaya a funcionar. Listas, arrays y tablas hash son fáciles de manejar. Para rellenar una lista, a, con los números del 1 al 5, hay que crear un objeto lista:
a= List(range(1,5))

En este ejemplo se busca la cadena test en la variable ejemplo, donde la s entre la e y la t podría ser cualquier carácter. La expresión regular tiene que ir entre @/.../.

Funciones
Los fans de Python se sentirán como en casa con las definiciones de funciones:
def Hola(nombre as string): return “Tu nombre: ${nombre}” print Hola(“Pepe”)

Listado 2: Sintaxis de Bloque
01 02 03 04 05 06 07 08 09 10 def function(): a = 0 # new variable inc = { a+=1 } show = {return a} return inc, show i,s=function() print(s()) i() print(s())

Boo gestiona las funciones como objetos de primera clase, un concepto que surgió con los lenguajes de programación funcionales. Las funciones soportan cualquier acción que sea soportada por el lenguaje de programación, así se pueden almacenar en variables o pasarse como argumentos a otras funciones. Y, por supuesto, se pueden devolver como resultado:
def function1(item as int): return item // no hace nada def function2(): return function1

54

Número 26

WWW.LINUX- MAGAZINE.ES

Boo • DESARROLLO

Listado 3: Generadores
01 def MyGenerator(): 02 i = 1 03 yield i 04 for x in range(10): 05 i += 2 06 yield i 07 08 print(List(MyGenerator()))

power espera una función cierre que, de hecho, devuelve una nueva función. Sin embargo, la función que produce también espera una entrada. De hecho podría llamarse a este dúo de la siguiente forma:
power(5)(2)

Listado 4: Propiedades
01 class Chair: 02 Color as string: 03 get: 04 return _color 05 set: 06 _color = value 07 08 _color as string 09 10 woodenchair = Chair() 11 woodenchair.Color = ‘Brown’

mos de ver, o la sintaxis basada en llaves, como se muestra en el Listado 2. En este caso, los cierres aparecen entre llaves, y su código utiliza la variable a de la función que la engloba. Incluso se pueden invocar los cierres aunque el entorno, y por ello las variables, hayan dejado de existir.

Un Poco de Picante
Como Boo soporta el concepto de retorno de funciones, son posible expresiones como la siguiente:
power = { x as int | return U { y as int | return x ** y }} U // ** representa una potencia

Como se puede ver, el 5 se pasa primero a la función power, que devuelve una función (la función { y as int | return 5 ** y} para ser precisos). El 2 se pasa luego a la nueva función, que devuelve el resultado. La última línea se entiende como que, en vez de tener una única función con dos argumentos, se tienen dos funciones con un argumento cada una. Los arquitectos de software se refieren a esta técnica como currying.

Generadores
Además de los cierres, Boo también soporta generadores: funciones que producen una serie de resultados. Sin embargo, no simplemente generan y devuelven una lista completa, sino que el siguiente elemento de la lista no se

calcula a menos que sea realmente necesario. Boo se refiere a estas funciones como métodos generadores (Listado 3). El generador MyGenerator se ejecuta hasta el siguiente yield, a continuación extrae el valor de la variable que encuentra allí y se para. Cuando la función que lo ha llamado (List en el ejemplo) necesite el siguiente valor, el generador continuará justo en el punto donde lo dejó. Como el siguiente valor sólo se genera si se necesita, esta solución requiere menos memoria bajo condiciones ideales; después de todo, un único número ocupa

DESARROLLO • Boo

Listado 5: Utilización de la API para ejecutar el código Boo
01 02 03 04 05 06 import Boo.Lang.Compiler import Boo.Lang.Compiler.IO import Boo.Lang.Compiler.Pipelines

Los tipos dinámicos implican la desactivación de la comprobación de tipos estática para las variables y con ello se consigue la potencia para asignar objetos arbitrarios a las variables:
d as pato // d puede ser deU cualquier tipo de aquí en U adelante d = 5 // d es un entero U a partir de aquí... d = “Hola” // ... y una U cadena desde aquí

compiler = BooCompiler() compiler.Parameters.Input.Add(StringInput(“<script>”, “print(‘Hello!’)”)) 07 compiler.Parameters.Pipeline = Run() 08 compiler.Run()

menos espacio que una lista completa. Esto es particularmente aparente en controles de iteración, como en los bucles for. Además de los métodos generadores, Boo también cuenta con expresiones generadoras, que funcionan exactamente como sus homólogas funcionales, pero que comprenden un único bucle for. Esto elimina la necesidad de definir explícitamente una función, proporcionando un soporte útil para definiciones compactas de cantidades como “todos los números impares entre 1 y 10 multiplicados por 2”:
uneventimestwo = i*2 for i U in range(10) if i%2 for x in uneventimestwo : print x

def Calculation(): for x in range(10): longcalculation(x) Calculation.BeginInvoke()

Así que si grazna como un pato, anda como un pato y se parece a un pato, entonces lo trataremos como un pato (pato es la traducción de duck).

Esto hará llorar a más de un programador de C. Nunca ha sido tan fácil la programación multihebra.

Extensible
Boo se ha diseñado como un lenguaje extensible. Por ejemplo, se pueden añadir macros personalizadas. Viene con diversas funciones de ayuda, como assert, que comprueba una condición y lanza una excepción si la condición es falsa:
assert 1>5, “Uno no es mayor que 5”

Atributos y Campos
En un lenguaje orientado a objetos, cada objeto posee sus propios métodos y atributos. Para acceder a los atributos, los programadores normalmente tienen que proporcionar un método para establecer y otro para obtener los valores de los atributos. Esta tarea tan frecuente puede ser un incordio, así que Boo adoptó la idea de las propiedades de C#. Boo distingue entre campos y propiedades, donde los campos son variables que implementan los atributos de un objeto y las propiedades son una alternativa sintáctica interesante para los típicos métodos set y get (Listado 4). El acceso a Color se maneja intuitivamente con una simple asignación. Entre bastidores, este ejemplo realmente llama al método set y almacena el valor pasado en el campo _field. Todo esto sucede de forma transparente al usuario. Para ahorrar escritura, Boo incluso posee una abreviatura:
class Chair: [Property(Color)] _color as string

De nuevo, Boo sólo produce el siguiente número después de comprobar la condición de terminación en el segundo bucle for. Juntando una lista de expresiones generadoras se obtiene un generador de lista, una forma rápida de rellenar una lista con objetos seleccionados:
uneventimestwolist = U [i*2 for i in range(10) if i%2]

Detrás de la macro hay un simple objeto Dotnet que sigue una signatura específica, así que Boo no se preocupa por el lenguaje en el que esté escrita la macro. Pero hay algo más que extensibilidad: el compilador de Boo ha sido diseñado como un cauce modular. Si fuera necesario, se puede acceder al proceso de compilación y realizar las acciones oportunas.

Conclusiones
Boo es un lenguaje de script de aprendizaje sencillo que además produce binarios CLI de forma rápida, lo que lo hace un lenguaje muy adecuado para el desarrollo de prototipos y la integración con Dotnet y Mono. Su proximidad sintáctica a Python también facilita la vida a los programadores que deseen pasarse él. Actualmente se encuentra en proceso el soporte para I Dotnet 2.0.

Clases
Al contrario que C#, Boo puede, si es necesario, funcionar sin clases. Puede utilizarse programación imperativa u optar por funciones, como en C. Sin embargo, sin que el usuario lo aprecie, es un lenguaje completamente orientado a objetos. Cualquier función puede ser considerara como un objeto. La función print(“Hola Mundo”) es lo mismo que print.Invoke(“Hola Mundo”). Y reemplazando .Invoke con .BeginInvoke, se ejecuta el cuerpo de la función en su propio hilo de ejecución:

Boo genera automáticamente los métodos get y set requeridos sin que se vean.

Tipos Dinámicos
Boo toma el concepto de tipos dinámicos de Ruby (duck typing en inglés).

RECURSOS
[1] Sitio web de codehaus.org Boo:

http://boo.

56

Número 26

WWW.LINUX- MAGAZINE.ES

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->