| Esquema | |
|---|---|
| Semántica | funcional |
| clase de idioma | lenguaje de programación , lenguaje de programación multiparadigma , lenguaje de programación funcional , lenguaje de programación procedimental y lenguaje de metaprogramación [d] |
| tipo de ejecución | intérprete o compilador |
| Apareció en | 1975 |
| Autor | Guy Steele y Gerald Sussman |
| extensión de archivo | .scm, .ss |
| Liberar |
|
| sistema de tipos | fuerte, dinámico |
| Implementaciones principales | Esquema PLT , Esquema MIT , Scheme48 , Guile , JScheme |
| Dialectos | T |
| sido influenciado | Ceceo , ALGOL |
| influenciado | Common Lisp , JavaScript , R , Ruby , Dylan , Lua , Hop, raqueta |
| Sitio web | esquema-reports.org _ |
| Archivos multimedia en Wikimedia Commons | |
Scheme [ skiːm ] es un lenguaje de programación funcional , uno de los tres dialectos Lisp más populares (junto con Common Lisp y Clojure ). Creado a mediados de la década de 1970 por los investigadores del MIT Guy L. Steele y Gerald Jay Sussman .
Tiene un diseño minimalista, contiene un mínimo de estructuras primitivas y te permite expresar todo lo que necesitas construyendo sobre ellas. Por ejemplo, utiliza solo dos mecanismos de bucle: recursión de cola y un enfoque iterativo (que utiliza variables temporales para almacenar un resultado intermedio).
El lenguaje comenzó como un intento de implementar el modelo de actor de Carl Hewitt , para el cual Steele y Sussman escribieron "un pequeño intérprete de Lisp" y luego "añadieron un mecanismo para crear actores y enviar mensajes". Scheme fue el primer dialecto de Lisp en usar exclusivamente el alcance variable estático (en lugar de dinámico) , lo que garantizaba la optimización de la recursión de cola y proporcionaba soporte de tipo booleano ( #ty #fen lugar del tradicional Ty NIL). También se convirtió en uno de los primeros lenguajes en admitir continuaciones . A partir de la especificación R⁵RS, el lenguaje adquirió una facilidad para escribir macros basadas en patrones de transformación sintáctica con " macro higiénica " . Se proporciona " recolección de basura " (liberación automática de memoria de objetos que ya no se utilizan).
El lenguaje utiliza listas y matrices unidimensionales ("vectores") como estructuras de datos básicas. De acuerdo con el minimalismo declarado, no existe (todavía) una sintaxis estándar para las estructuras de soporte con campos con nombre, así como las facilidades OOP ; todo esto puede ser implementado por el programador según sus preferencias, aunque la mayoría de las implementaciones del lenguaje ofrecen mecanismos listos para usar.
El nombre original del idioma, Schemer, se cambió debido a la limitación en la longitud de los nombres de archivo en ITS ; ( Inglés intrigante - "aventurero", "combinador"; aparentemente, una pista de otros lenguajes similares a ceceo que salieron del MIT - Planner (en uno de los significados - "proyector") y Conniver ("conspirador "). El libro " La estructura e interpretación de los programas informáticos " de Abelson y Sussman , que se utilizó durante mucho tiempo como libro de texto básico de programación en el Instituto Tecnológico de Massachusetts, hizo una contribución significativa a la popularización del lenguaje .
Operaciones matemáticas simples:
( + 2 ( * 2 2 )) > 6 ( + 1 2 3 4 ) > 10La llamada a cada operación (o función) está representada por una lista en la que el símbolo de la operación (que es esencialmente el nombre de la función) siempre ocupa la posición inicial.
Escriba predicados:
( ¿número? 5 ) ( ¿número? "foo" ) ( cadena? "foo" )Por convención, todos los nombres de predicados terminan en ?.
Comprobaciones de igualdad:
( igual? "foo" "barra" ) ( eqv? 5 ( + 2 3 )) ( eq? 'a 'A )Definición de macros para operaciones push y pop tradicionales:
( define-syntax push! ( syntax-rules () (( push! x l ) ( set! l ( contras x l ))))) ( define-syntax pop! ( reglas-syntax () (( pop! l ) ( let (( x ( car l ))) ( set! l ( cdr l )) x ))))Definiciones de funciones:
;; factorial en estilo recursivo (ineficiente) ( define ( fact x ) ( if ( < x 2 ) 1 ( * ( fact ( - x 1 )) x ))) ;; Función de Fibonacci: requiere recursividad paralela ( define ( fib n ) ( cond (( = n 0 ) 0 ) (( = n 1 ) 1 ) ( else ( + ( fib ( - n 1 )) ( fib ( - n 2 )) )))) ;; la suma de los elementos de la lista en un estilo típico de Scheme ;; (la función auxiliar de bucle expresa un bucle con ;; recursividad final y una variable acumuladora) ( define ( sum-list x ) ( let loop (( x x ) ( n 0 )) ( if ( null? x ) n ( bucle ( cdr x ) ( + ( coche x ) n ))))) ( hecho 14 ) ( fib 10 ) ( suma-lista ' ( 6 8 100 )) ( suma-lista ( mapa fib ' ( 1 2 3 4 )))La definición de la función debe ajustarse al siguiente prototipo:
( definir el nombre de la función ( lambda ( argumentos ) ( implementación de la función )))aunque en la práctica se suele utilizar la forma abreviada:
( define ( argumentos de nombre de función ) ( implementación de función ))El esquema utiliza el tipo de puerto para entrada y salida ( port, R5RS sec 6.6) [1] . R5RS define dos puertos estándar, disponibles como current-input-porty current-output-port, correspondientes a flujos de E/S de Unix estándar. La mayoría de las implementaciones también proporcionan current-error-port. La redirección de E/S se admite en el estándar a través de los procedimientos with-input-from-filey with-output-to-file. Las implementaciones también tienen puertos de cadena a través de los cuales se pueden realizar muchas operaciones de E/S en un búfer de cadena en lugar de un archivo, usando procedimientos de SRFI 6 [2] . El estándar R6RS define procedimientos más complejos para tratar con puertos y muchos tipos nuevos de puertos.
Los siguientes ejemplos están escritos en R5RS Scheme.
( escribir ( + ( leer ) ( leer )))Salida al puerto predeterminado (puerto de salida actual):
( let (( hola0 ( lambda () ( mostrar "Hola mundo" ) ( nueva línea )))) ( hola0 ))Pasar un puerto como argumento:
( let (( hola1 ( lambda ( p ) ( mostrar "Hola mundo" p ) ( nueva línea p )))) ( hola1 ( puerto de salida actual )))Redirigir la salida a un archivo:
( let (( hola0 ( lambda () ( mostrar "Hola mundo" ) ( nueva línea )))) ( con salida a archivo "archivo de salida" hola0 ))Abriendo explícitamente un archivo y cerrando un puerto:
( let (( hola1 ( lambda ( p ) ( mostrar "Hola mundo" p ) ( nueva línea p ))) ( puerto de salida ( abrir archivo de salida " archivo de salida " ))) ( hola1 puerto de salida ) ( cerrar salida -puerto puerto-salida ) )llamada-con-archivo-de-salida:
( let (( hola1 ( lambda ( p ) ( mostrar "Hola mundo" p ) ( nueva línea p )))) ( llamada con archivo de salida "archivo de salida" hola1 ))Existen procedimientos similares para la entrada. R5RS Scheme proporciona predicados input-port?y output-port?. Para la entrada y salida de caracteres , existen write-char, y . Los procedimientos y se utilizan para leer y escribir expresiones de Scheme . Si el puerto ha llegado al final del archivo en una operación de lectura, se devuelve un objeto eof que puede reconocer el predicado . read-charpeek-charchar-ready?readwriteeof-object?
Debido al minimalismo del lenguaje, muchos procedimientos y formas sintácticas comunes no están definidos en el estándar. Para mantener pequeño el núcleo del lenguaje y promover la estandarización de las extensiones, la comunidad de Scheme ha adoptado un proceso de "Solicitud de Scheme para implementación" mediante el cual se analizan cuidadosamente las extensiones propuestas. Esto contribuye a la portabilidad del código. Muchos SRFI son compatibles con todas o la mayoría de las implementaciones del Esquema.
Los siguientes SRFI [3] son ampliamente compatibles con las implementaciones :
GNU Guile , el lenguaje de extensión del Proyecto GNU , es un intérprete de Scheme implementado como una biblioteca que permite que las aplicaciones creen un intérprete de Scheme interno.
El lenguaje Racket fue originalmente una implementación de Scheme (originalmente llamado PLT Scheme).
MIT Scheme es una implementación gratuita ( GPL ) para la plataforma x86 bajo Linux , FreeBSD , IBM OS/2 y Win32 . Chicken Scheme es un intérprete que admite la traducción de C. JScheme es un intérprete escrito en Java ; Kawa es un compilador de bytecode de Scheme a JVM . El compilador Chez Scheme se ha suministrado como un producto comercial durante mucho tiempo, desde 2016 se ha distribuido libremente ( Apache ).
En total, existe una gran cantidad de implementaciones de lenguaje para diferentes plataformas, en particular, existe un intérprete Armpit Scheme para microcontroladores basado en la arquitectura ARM [4] .
| Ceceo | |||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Características |
| ||||||||||||||
| Implementaciones |
| ||||||||||||||
| Hardware |
| ||||||||||||||
| Comunidad |
| ||||||||||||||
| |||||||||||||||
| Lenguajes de programación | |
|---|---|
| |