Racket (lenguaje de programación)

La principal característica de Racket es la capacidad de crear y extender nuevos lenguajes. Esto es posible gracias a una serie de componentes:

• Un sistema de módulos capaz de enlazar código y manejar espacios de nombres
• Un sistema de macros que permite la creación de nuevas formas sintácticas
• Un sistema de tiempo de ejecución que ofrece muchas opciones a los nuevos lenguajes
• Formas de especificar e implementar analizadores sintácticos para dichos lenguajes.

El primer punto, el sistema de módulos, es el encargado de hacer posible muchas de estas características, permite el uso de una gran cantidad de módulos conjuntamente, donde cada uno de ellos puede estar escrito en un lenguaje distinto.

Implementar un nuevo lenguaje en Racket es tan sencillo que muchos de ellos tienen muy pocos usos, ya que fueron concebidos con un objetivo muy concreto.

Typed Racket, definido por la etiqueta #lang typed/racket es una variante de Racket con tipado estático, lo que permite a los programas madurar, ya que el tipado estático puede ayudar en el mantenimiento de una aplicación de gran tamaño. Entre los objetivos de este dialecto se encuentra el permitir la escritura de código más expresivo. Otra característica es la inclusión de código tipado en programas no tipados, lo que permitiría llamar a módulos escritos en Typed Racket.

El siguiente fragmento de código define una lista cuyos elementos son del tipo Str-or-Num (definido previamente).

#lang typed/racket

(define-type Str-or-Num (U String Number))
 
(: tog ((Listof Str-or-Num) -> String))
(define (tog l)
  (apply string-append (filter string? l)))
 
(tog (list 5 "hello " 1/2 "world" (sqrt -1)))

Otro ejemplo de las posibilidades que ofrece Racket es la implementación de evaluación perezosa (del inglés lazy evaluation), no estando esta característica en el núcleo principal del lenguaje. El siguiente ejemplo muestra como se definiría una lista de Fibonacci infinita cuyos elementos solo son calculados cuando es necesario.[8]

#lang lazy
;; Definimos la lista
(define fibs
  (list* 1 1 (map + fibs (cdr fibs))))
 
;; Accedemos al elemento numero 1000
(print (list-ref fibs 1000))

Scribble es la familia de dialectos de Racket usados para escribir prosa. Su principal eso es el de actuar como sistema de documentación de Racket, pero puede ser usado para mucho más, como la escritura de libros o artículos. Cada uno de los dialectos es usado para diferentes propósitos.[9]

El lenguaje trabaja en modo texto por defecto (todo lo que escribamos formará parte del fichero final), y utiliza el carácter @ para hacer llamadas a las distintas funciones ofrecidas. En el siguiente ejemplo podemos ver el uso de la función title, así como una muestra del uso del modo texto. Si guardamos el archivo como raton.scrbl y ejecutamos scribble --pdf raton.scrbl generaremos un fichero pdf con los contenidos especificados.

#lang scribble/base
 
@title{Sobre los hábitos de un ratón}
 
Si le das una galletita a un ratón, te pedirá un vaso de leche.

Racket ofrece una variedad de características orientadas a la mejora del rendimiento en tiempo de ejecución.

Racket puede ser usado con tres recolectores de basura distintos:

• Boehm, un recolector de basura conservador, fue el primero en ser utilizado. Puede presentar problemas para programas que son ejecutados durante de forma continua, como los servidores web, ya que las pequeñas fugas de memoria se pueden ir acumulando con el tiempo.
• SenoraGC, una alternativa, también en la familia de los recolectores conservadores, usada principalmente para depurar programas y encontrar fugas de memoria.
• El gestor de memoria en movimiento (también conocido como "3m", del inglés moving memory manager), que ha sido el recolector por defecto desde el 2007. Se trata de un recolector preciso, por lo que no presenta algunos de los problemas de las alternativas.

Racket posee una interfaz de sistema con entrada salida asíncrona no bloqueante, hilos de ejecución verdes, canales de sincronización, semáforos, subprocesos, y sockets TCP. Esto nos permite realizar todo tipo de accesos a las funciones ofrecidas por el sistema operativo. Por ejemplo, en el siguiente ejemplo lanzamos un proceso que maneja conexiones entrantes en el puerto 12345:

#lang racket
 
(define listener (tcp-listen 12345))
 
(let echo-server ()
  ;; Creamos el servidor
  (define-values (in out) (tcp-accept listener))
  ;; Lanzamos un nuevo hilo por cada conexión entrante
  (thread (λ () (copy-port in out) (close-output-port out)))
  ;; Y volvemos a lanzar el servidor, a la espera de una nueva conexión
  (echo-server))

Gracias a la extensibilidad de Racket encontramos que cierto tipo de tareas resultan extremadamente sencillas. Por ejemplo, el siguiente programa hace uso del dialecto web-server/insta para crear un servidor web en solo dos líneas:

#lang web-server/insta
 
(define (start request)
  (response/xexpr '(html (body "¡Hola Mundo!"))))

Además, Racket incluye todas las funciones necesarias para crear scrapers o arañas web. El siguiente ejemplo obtiene los resultados de Google dada una cadena de búsqueda:

#lang racket
 
(require net/url net/uri-codec)
 
(define (let-me-google-that-for-you str)
  (let* ([g "http://www.google.com/search?q="]
         [u (string-append g (uri-encode str))]
         [rx #rx"(?<=<h3 class=\"r\">).*?(?=</h3>)"])
    (regexp-match* rx (get-pure-port (string->url u)))))

En Racket las imágenes son variables, al igual que los son los números o las cadenas de texto, por lo que podemos crear programas que generen imágenes, y el editor nos las mostrará. Para hacer esto posible tenemos una variedad de librerías gráficas en Racket que nos permiten generar imágenes a través de las funciones que nos ofrece. Por ejemplo, la librería 2htdp/image nos permite generar imágenes sin mucha complicación, por lo que es usada en entornos educativos. El siguiente ejemplo genera un Triángulo de Sierpinski de nivel 8:

#lang racket
 
(require 2htdp/image)
 
(let sierpinski ([n 8])
  (if (zero? n)
    (triangle 2 'solid 'red)
    (let ([t (sierpinski (- n 1))])
      (freeze (above t (beside t t))))))

Si enfocamos hacia el mundo académico, podemos encontrar la librería plot, que nos permite generar gráficas. Esta librería nos permite exportar nuestros resultados como archivos PNG, PDF, PostScript y SVG además de mostrarlos en el editor.

Una de las librerías ofrecidas por Racket nos permite la creación de interfaces gráficas, ya sea a mano posicionando línea a línea los elementos, o mediante el uso de editores presentes en PLaneT. La librería está implementada mediante el uso de llamadas a la API nativa en Windows, con Cocoa en Mac OS X, y con Gtk en Linux. El siguiente ejemplo genera una ventana con una serie de botones con números, y el programa nos hace adivinar cual de ellos es el correcto:

#lang racket/gui
 
(define secret (random 5))
 
(define f (new frame% [label "Adivina el número"])) ; Ventana principal
(define t (new message% [parent f]
               [label "¿Puedes adivinar el numero que estoy pensando?"]))
(define p (new horizontal-pane% [parent f]))    ; Contenedor horizontal
 
(define ((make-check i) btn evt)
  (message-box "." (cond [(< i secret) "Demasiado pequeño"]
                         [(> i secret) "Demasiado grande"]
                         [else         "¡Exacto!"]))
  (when (= i secret) (send f show #f)))         ; Se ha adivinado, por lo que cerramos la ventana
 
(for ([i (in-range 10)])                        ; Creamos los botones
  (make-object button% (format "~a" i) p (make-check i)))
 
(send f show #t) ; Mostramos la ventana, comenzando la aplicación