Scheme para niños

Datos para niños Scheme
?
Información general
Extensiones comunes	scm y ss
Paradigma	multi-paradigma
Apareció en	1975
Diseñado por	Guy L. Steele y Gerald Jay Sussman
Sistema de tipos	Fuerte, dinámico
Implementaciones	Scheme, Scheme 48, Chicken, Gambit, FLUENT, Guile, Bigloo, Chez Scheme, STk, STklos, Larceny, SCM
Dialectos	T
Influido por	Lisp

Scheme es un lenguaje de programación especial. Es un "dialecto" de Lisp, otro lenguaje de programación muy conocido. Scheme fue creado por Guy L. Steele y Gerald Jay Sussman en la década de 1970. Se hizo famoso en el mundo académico gracias a una serie de documentos llamados Lambda Papers.

Scheme se enfoca en la programación funcional. Esto significa que se basa en el uso de funciones para resolver problemas. Su filosofía es ser "minimalista". Esto quiere decir que no busca tener muchísimas funciones. En cambio, ofrece un número pequeño de herramientas básicas. Con ellas, puedes construir todo lo demás de forma sencilla. Por ejemplo, para repetir acciones, Scheme usa principalmente llamadas recursivas.

Scheme fue el primer dialecto de Lisp en usar el "ámbito estático" (o léxico). Esto significa que las variables se entienden según dónde fueron escritas en el código. También fue uno de los primeros lenguajes con "continuaciones explícitas". Estas permiten guardar y usar el estado completo de un programa en un momento dado. Además, Scheme maneja la memoria automáticamente, limpiando lo que ya no se usa.

Las listas son la forma principal de organizar datos en Scheme. También tiene "arrays" (arreglos) entre sus tipos de datos. Como es un lenguaje muy simple, no tiene formas directas de crear estructuras complejas. Sin embargo, muchas versiones de Scheme añaden estas funciones.

Originalmente, Scheme se llamaba "Schemer". Este nombre seguía la tradición de otros lenguajes como Planner. Su nombre actual se debe a que sus creadores usaban un sistema operativo. Este sistema limitaba los nombres de los archivos a solo seis letras.

¿Por qué Scheme es útil?

Scheme, al igual que otros dialectos de Lisp, tiene una forma de escribir código muy sencilla. No necesita reglas complicadas para saber qué operación hacer primero. Esto es porque usa la "notación prefija" para todas las llamadas a funciones. En el mundo de Lisp, estas expresiones se llaman "S-expressions".

¿Cómo ayuda su sintaxis simple?

La fuerza de los lenguajes Lisp está en su sintaxis simple. Se basa en listas anidadas. Esta estructura refleja cómo se organiza el programa internamente. Esto facilita la "metaprogramación" usando "macros". Las macros de Scheme permiten adaptar el lenguaje a nuevas tareas fácilmente. Por ejemplo, puedes añadir soporte para la programación orientada a objetos. Scheme tiene un sistema de macros "higiénico". Esto significa que evita problemas de nombres al expandir las macros.

¿Qué es la programación funcional en Scheme?

Scheme facilita la programación funcional. Aunque permite cambiar valores directamente, usarlo al estilo funcional puro es mejor. Así se evitan problemas con variables globales. También es más seguro cuando el programa hace varias cosas a la vez. Esto hace que sea más fácil verificar que el programa funciona correctamente.

¿Qué son los procedimientos de primera clase?

En Scheme, los procedimientos (o funciones) son "objetos de primera clase". Esto significa que puedes tratarlos como cualquier otro dato. Puedes pasarlos como argumentos a otras funciones. También puedes devolverlos como resultados. Esto permite crear "funciones de orden superior". Estas funciones reciben o devuelven otras funciones. También puedes crear procedimientos sin nombre usando `(lambda (argumentos) (...))`.

¿Por qué su estándar es minimalista?

El estándar de Scheme es muy simple. Esto tiene ventajas y desventajas. Por ejemplo, es más fácil crear un compilador o intérprete de Scheme. También es más sencillo usar Scheme en dispositivos con poca memoria. A los fans de Scheme les gusta decir que su estándar, de solo 50 páginas, es más corto que el índice de un libro sobre otro lenguaje Lisp.

¿Cuáles son los desafíos de Scheme?

El estándar de Scheme es muy minimalista. Esto ha llevado a que existan muchas versiones diferentes del lenguaje. Cada una de ellas añade sus propias funciones y bibliotecas. Esto puede hacer que los programas no funcionen igual en todas las versiones. Los "Scheme Requests for Implementation" (SRFI) buscan solucionar este problema.

Algunas personas ven como una desventaja que los nombres de las funciones y las variables compartan el mismo espacio. Por ejemplo, "list" es el nombre de una función. Por eso, es común usar nombres como "lst" o "xs" para variables.

Como el espacio de nombres es único, no siempre es fácil saber si algo es una macro o una función. Si no conoces la definición, puede ser difícil entender el orden en que se ejecutan las partes de un programa.

Estándares de Scheme

Existen dos estándares principales que definen el lenguaje Scheme:

• El estándar oficial de la IEEE.
• Un estándar muy usado llamado Revised^n-th Report on the Algorithmic Language Scheme, abreviado como RnRS. La última versión es R6RS.

Elementos básicos del lenguaje

¿Cómo se añaden comentarios?

Para añadir un comentario en Scheme, se usa un punto y coma (`;`). Todo lo que va después del punto y coma hasta el final de la línea es un comentario. Los comentarios ayudan a explicar el código.

¿Cómo se usan las variables?

Las variables en Scheme pueden guardar diferentes tipos de datos. Para darles un valor, puedes usar `define` o `let`.

• Las variables definidas con `define` en el nivel principal son globales. Esto significa que son visibles en todo el programa.

  (define mi-variable 10) ; Define una variable global

• Las variables definidas con `let` solo existen dentro de un bloque de código específico.

  (let ((otra-variable 20))
    ; Aquí, otra-variable solo existe dentro de este bloque
    (+ otra-variable 5))

¿Cómo funcionan los procedimientos (funciones)?

Las funciones en Scheme son muy importantes. Se pueden guardar en variables. Por ejemplo, una función que toma dos argumentos se puede definir así:

  (define mi-funcion
    (lambda (arg1 arg2)
      (+ arg1 arg2))) ; Esta función suma dos argumentos

O de una forma más corta:

  (define (mi-funcion arg1 arg2)
   (+ arg1 arg2))

Para usar una función, se escribe su nombre primero, seguido de sus argumentos, todo entre paréntesis:

  (mi-funcion 5 3) ; Llama a mi-funcion con 5 y 3, el resultado es 8

También puedes usar el procedimiento `apply`. Este toma la función y una lista de argumentos:

  (apply mi-funcion (list 5 3)) ; Hace lo mismo que la anterior

Las funciones en Scheme se dividen en dos tipos:

• Procedimientos definidos por el usuario: Son los que tú creas.
• Primitivas: Son funciones que ya vienen en el lenguaje, como `+` (suma), `-` (resta), `*` (multiplicación), `/` (división), `car` y `cdr` (para listas).

¿Qué son las listas?

Scheme usa listas enlazadas para organizar datos. Son muy fáciles de usar en comparación con otros lenguajes.

¿Qué tipos de datos existen?

Scheme maneja varios tipos de datos, como:

• Números enteros (como 1, 2, 3)
• Números racionales (como 1/2, 3/4)
• Números reales (con decimales, como 3.14)
• Números complejos
• símbolos (como 'hola)
• cadenas (texto, como "Hola mundo")
• Puertos (para entrada y salida de datos)
• Listas asociativas
• Tablas hash
• Vectores y arrays
• Estructuras

Scheme también tiene valores booleanos para verdadero y falso: `#t` para verdadero y `#f` para falso. Cualquier valor que no sea `#f` se considera verdadero.

¿Cómo se comparan valores?

Scheme tiene diferentes formas de comparar si dos cosas son iguales.

¿Cómo se controla el flujo del programa?

Evaluación condicional

Para tomar decisiones, Scheme usa `cond` o `if`.

• `cond` evalúa varias pruebas y ejecuta el código de la primera que sea verdadera:

  (cond ((> edad 18) "Es mayor de edad")
        ((< edad 12) "Es un niño")
        (else "Es un adolescente"))

• `if` es más simple, para una sola condición:

  (if (es-par? numero)
      "Es par"
      "Es impar")

Bucles (repeticiones)

En Scheme, los bucles se hacen a menudo con "recursión final". Esto es una forma especial de llamar a una función a sí misma. Es eficiente porque no acumula mucha información en la memoria. Un ejemplo clásico es la función factorial:

(define (factorial n)
  (fact-iter 1 n))

(define (fact-iter product n)
  (if (< n 2)
      product
      (fact-iter (* product n)
                 (- n 1))))

  (factorial 5) ; Calcula 5 * 4 * 3 * 2 * 1 = 120

Otra forma de hacer bucles es con funciones como `map`. Esta aplica una función a cada elemento de una lista.

Entrada y salida de datos

Scheme usa el concepto de "puertos" para leer o escribir datos. Tiene tres puertos predeterminados:

• `current-input-port`: Para leer datos (como desde el teclado).
• `current-output-port`: Para escribir datos (como en la pantalla).
• `current-error-port`: Para mostrar mensajes de error.

Véase también

En inglés: Scheme (programming language) Facts for Kids

• Lisp
• Common Lisp
• Modelo de actor
• Guy L. Steele, Jr.
• Gerald Jay Sussman