| Limbo | |
|---|---|
| Semántica | programación competitiva |
| clase de idioma | lenguaje de programación |
| Apareció en | 1995 |
| Autor | Sean Dorward, Phil Winterbottom, Rob Pike |
| Desarrollador | laboratorios de campana |
| sistema de tipos | estricto |
| sido influenciado | C , CSP , Alef |
| influenciado | Python sin pilas , Go , Rust |
| Sitio web | vitanuova.com/inferno/li… |
Limbo es un lenguaje de programación para el sistema operativo Inferno creado por los desarrolladores de UNIX .
El lenguaje Limbo está cerca de C y Java , el resultado de la compilación es un código de bytes , lo que garantiza la portabilidad . La portabilidad está en el corazón del propio Inferno OS (el sucesor de Plan 9 ), llevado al estado de una aplicación que se ejecuta sobre el sistema operativo host: Plan 9 , FreeBSD , Irix , Linux , Mac OS X , Solaris , WindowsNT .
Limbo tiene un mecanismo de comunicación entre procesos incorporado llamado "canales".
Entre los tipos incorporados:
Además de los tipos, estructuras y uniones numéricos habituales, Limbo admite cadenas y algunos tipos de datos más específicos: listas, matrices, tuplas y conductos . (También hay un "módulo" de tipo especial, pero desde el punto de vista de las características del lenguaje, no tiene interés). Todos estos tipos de datos son variables de primera clase, es decir, se pueden almacenar en variables, pasar a través de canales, etc.
Los tipos numéricos ordinarios se pueden convertir entre sí, y las cadenas también se pueden convertir en números y viceversa. Pero todas las conversiones deben especificarse explícitamente, no hay conversiones de tipo implícitas.
Las cadenas se pueden convertir en matrices de bytes y viceversa. Además, las cadenas admiten segmentos, es decir, puede hacer referencia a un carácter o secuencia de caracteres específicos, por ejemplo: my_string[5:15].
lista es una secuencia de elementos del mismo tipo, optimizada para operaciones tipo pila (agregar elemento al principio de la lista, obtener el primer elemento de la lista, obtener el resto de la lista (excepto el primer elemento)).
Hay tres operadores para trabajar con listas:
Ejemplo:
l : lista de int ; l = 10 :: 20 :: 30 :: cero ; // crea una lista de 3 elementos l = 5 :: l ; // agrega una i más al principio : = hd l ; // obtiene un int igual a 5, lista sin cambios l2 : = tl l ; // obtener una nueva lista 10 :: 20 :: 30 :: nil l2 = tl l2 ; // elimina el primer elemento de élarray contiene un número fijo de elementos del mismo tipo. El tamaño de una matriz se especifica cuando se crea/inicializa, y no cuando se declara el tipo de variable, es decir, las matrices se pueden crear dinámicamente en cualquier momento (cuando se conoce el tamaño de la matriz requerida). De hecho, en Limbo, solo hay dos formas de asignar memoria dinámicamente: crear una matriz especificando el tamaño requerido a través de una variable y agregar un nuevo elemento al comienzo de la lista. Naturalmente, las matrices también admiten segmentos.
Tupla es una lista de 2 o más elementos de cualquier tipo. Y esto no es solo una lista, sino el mismo tipo de datos que otros: el tipo de la Tupla en sí está determinado por qué tipos de elementos y en qué orden contiene. Ejemplo:
i_s : ( int , cadena ); i_s = ( 5 , "cinco" ); // el tipo i_r_s_s es (int, real, string, string) i_r_s_s : = ( 5 , 0.5 , "cinco" , "comentario" );La tupla se puede descomponer en componentes asignándola a una lista de variables ordinarias:
// crea variables i de tipo int y s de tipo string y // las inicializa a 5 y "cinco" ( i , s ) := i_s ;Intercambiando los valores de dos variables en Limbo:
( yo , j ) = ( j , yo );Los canales (chan) le permiten organizar IPC entre procesos locales al pasar objetos de un tipo determinado de forma atómica. Leer/escribir un canal es una operación de bloqueo.
c : = canal de int ; // crea un canal c <-= 10 ; // enviar al canal i : = <- c ; // recibir del canal int <- c ; // acepta e ignora el valor c = nil ; // destruir el canalLos canales se pueden almacenar en búfer (usted especifica el tamaño del búfer aproximadamente igual al tamaño de la matriz). Las escrituras en los canales con búfer no se bloquean hasta que el búfer está lleno. El búfer funciona como una cola FIFO. Para multiplexar canales en Limbo, existen hasta dos formas: puede leer de una matriz de canales o puede usar el operador alt especial para seleccionar un canal.
alt { yo : = < -pulgadas => sys -> imprimir ( "recibido:%d \n " , i ); outchan <-= "mensaje" => sys -> imprimir ( "mensaje enviado \n " ); }Esta es una matriz que almacena los canales a través de los cuales se pasan las tuplas que consisten en un int y una lista de cadenas. El tamaño de la matriz no se define aquí, se establecerá durante la ejecución, cuando se inicialice la matriz.
Limbo usa UTF8 para E/S y UTF16 para representar cadenas en la memoria. Es decir, por ejemplo, al leer el código fuente de un módulo desde el disco, puede usar UTF8 en comentarios, cadenas y constantes de caracteres. Si hay una matriz de bytes (matriz de bytes) y se convierte en una cadena, los bytes de la matriz se tratan como UTF8 y se convierten en la cadena a UTF16; y al convertir una cadena en una matriz de bytes, se produce la conversión inversa y la matriz es UTF8.
Las funciones se pueden pasar como parámetros a las referencias de función.
En la comprensión habitual del concepto de programación orientada a objetos, no existe. Sin embargo, los tipos de datos abstractos (adt) pueden contener funciones relacionadas como miembros además de los tipos de datos normales.
Para ejecutar una función dada en un subproceso separado, Limbo usa el operador de generación incorporado.
Hay soporte para excepciones, tanto cadenas regulares como tipos personalizados. La mayoría de las funciones del sistema y de la biblioteca utilizan tupla: (código de error, resultado) en lugar de excepciones para devolver errores.
Un programa que imprime " Hola, Mundo ".
implementar Comando; incluir "sys.m"; incluir "dibujar.m"; sistema: sistema; Módulo de mando { init: fn (ctxt: ref Dibujar->Contexto, argv: lista de cadenas); }; init(ctxt: ref Dibujar->Contexto, argv: lista de cadenas) { sys = cargar Sys Sys->PATH; sys->print("hola mundo\n"); para (; argv!=nil; argv = tl argv) sys->print("%s ", hd argv); sys->imprimir("\n"); }
| Lenguajes de programación | |
|---|---|
| |
| Rob Pike | |
|---|---|
| Sistemas operativos | |
| Lenguajes de programación | |
| Software | |
| Publicaciones |
|
| Otro |
|