| Limbo | |
|---|---|
| Semantik | Konkurrencedygtig programmering |
| Sprog klasse | programmeringssprog |
| Dukkede op i | 1995 |
| Forfatter | Sean Dorward, Phil Winterbottom, Rob Pike |
| Udvikler | Bell Labs |
| Type system | streng |
| Blev påvirket | C , CSP , Alef |
| påvirket | Stackless Python , Go , Rust |
| Internet side | vitanuova.com/inferno/li… |
Limbo er et programmeringssprog til Inferno - operativsystemet skabt af UNIX -udviklerne .
Limbo-sproget er tæt på C og Java , resultatet af kompileringen er bytecode , som sikrer portabilitet . Portabilitet er kernen i selve Inferno OS (efterfølgeren til Plan 9 ), bragt til tilstanden af et program, der kører oven på værtsoperativsystemet: Plan 9 , FreeBSD , Irix , Linux , Mac OS X , Solaris , Windows NT .
Limbo har en indbygget inter-proces kommunikationsmekanisme kaldet "kanaler".
Blandt de indbyggede typer:
Ud over de sædvanlige numeriske typer, strukturer og fagforeninger, understøtter Limbo strenge og et par mere specifikke datatyper: lister, arrays, tuples og pipes . (Der er også en speciel type "modul", men ud fra et sprogfunktionssynspunkt er det uden interesse.) Alle disse datatyper er førsteklasses variable, dvs. de kan gemmes i variabler, sendes gennem kanaler og så videre.
Almindelige numeriske typer kan konverteres til hinanden, og strenge kan også konverteres til tal og omvendt. Men alle konverteringer skal specificeres eksplicit, der er ingen implicitte typekonverteringer.
Strenge kan konverteres til byte-arrays og omvendt. Derudover understøtter strenge skiver, dvs. du kan henvise til et bestemt tegn eller en sekvens af tegn, for eksempel: min_streng[5:15].
list er en sekvens af elementer af samme type, optimeret til stack-lignende operationer (tilføj element til begyndelsen af listen, hent det første element af listen, hent resten af listen (undtagen det første element)).
Der er tre operatører til at arbejde med lister:
Eksempel:
l : liste over int ; l = 10 :: 20 :: 30 :: nul ; // opret en liste med 3 elementer l = 5 :: l ; // tilføje en mere i til begyndelsen : = hd l ; // få int lig med 5, liste uændret l2 : = tl l ; // få en ny liste 10 :: 20 :: 30 :: nul l2 = tl l2 ; // fjern det første element fra detarray indeholder et fast antal elementer af samme type. Størrelsen af et array er angivet når det oprettes/initialiseres, og ikke når variabeltypen er deklareret - dvs. arrays kan oprettes dynamisk til enhver tid (når den nødvendige arraystørrelse er kendt). Faktisk er der i Limbo kun to måder til dynamisk at allokere hukommelse: Opret et array ved at angive den nødvendige størrelse gennem en variabel og tilføje et nyt element til begyndelsen af listen. Naturligvis understøtter arrays også skiver.
Tuple er en liste over 2 eller flere elementer af enhver type. Og dette er ikke bare en liste, men den samme datatype som andre - selve typen af Tuple er faktisk bestemt af hvilke typer elementer og i hvilken rækkefølge den indeholder. Eksempel:
i_s : ( int , streng ); i_s = ( 5 , "fem" ); // i_r_s_s type er (int, real, string, string) i_r_s_s : = ( 5 , 0.5 , "fem" , "kommentar" );Tuple kan dekomponeres i komponenter ved at tildele den til en liste over almindelige variable:
// opretter variabler i af typen int og s af typen streng og // initialiserer dem til 5 og "fem" ( i , s ) := i_s ;Udskiftning af værdierne af to variable på Limbo:
( i , j ) = ( j , i );Kanaler (chan) giver dig mulighed for at organisere IPC mellem lokale processer ved at sende objekter af en given type atomisk. At læse/skrive en kanal er en blokerende operation.
c : = chan af int ; // opretter en kanal c <-= 10 ; // send til kanal i : = <- c ; // modtage fra kanal int <- c ; // accepter og ignorer værdien c = nul ; // ødelægge kanalenKanaler kan bufres (du angiver størrelsen af bufferen omtrent den samme som størrelsen af arrayet). Skrivninger til bufferkanaler blokeres ikke, før bufferen er fuld. Bufferen fungerer som en FIFO-kø. For at multiplekse kanaler i Limbo er der så mange som to måder - du kan læse fra en række kanaler, eller du kan bruge den specielle alt-operator til at vælge en kanal.
alt { i : = < -inchan => sys -> print ( "modtaget:%d \n " , i ); outchan <-= "besked" => sys -> print ( "besked sendt \n " ); }Dette er et array, der gemmer de kanaler, hvorigennem tuples bestående af en int og en liste over strenge sendes. Størrelsen af arrayet er ikke defineret her, det vil blive indstillet under udførelsen, når arrayet initialiseres.
Limbo bruger UTF8 til I/O og UTF16 til at repræsentere strenge i hukommelsen. Det vil sige, for eksempel, når man læser kildekoden til et modul fra disk, kan det bruge UTF8 i kommentarer, strenge og tegnkonstanter. Hvis der er et array af bytes (array af byte), og det konverteres til en streng, så behandles bytes fra arrayet som UTF8 og konverteres i strengen til UTF16; og når en streng konverteres til et array af bytes, sker den omvendte konvertering, og arrayet er UTF8.
Funktioner kan overføres som parametre til funktionsreferencer.
I den sædvanlige forståelse af begrebet OOP er der ingen. Abstrakte datatyper (adt) kan dog indeholde relaterede funktioner som medlemmer ud over almindelige datatyper.
For at køre en given funktion på en separat tråd, bruger Limbo den indbyggede spawn-operator.
Der er understøttelse af undtagelser, både almindelig streng og brugerdefinerede typer. De fleste system- og biblioteksfunktioner bruger tuple: (errcode, result) i stedet for undtagelser for at returnere fejl.
Et program, der udskriver " Hej, verden ".
implementere kommando; inkludere "sys.m"; inkludere "draw.m"; sys: sys; Kommando:modul { init: fn (ctxt: ref Draw->Context, argv: liste over streng); }; init(ctxt: ref Draw->Context, argv: liste over streng) { sys = indlæs Sys Sys->PATH; sys->print("hej verden\n"); for (; argv!=nul; argv = tl argv) sys->print("%s", hd argv); sys->print("\n"); }
| Programmeringssprog | |
|---|---|
| |
| Rob Pike | |
|---|---|
| Operativsystemer | |
| Programmeringssprog | |
| Software | |
| Publikationer |
|
| Andet |
|