Dylan (limba)

De la Wikipedia, enciclopedia liberă.
Salt la navigare Salt la căutare
Dylan
limbaj de programare
Autor Apple , Arlequin, Universitatea Carnegie Mellon
Data de origine 1990
Ultima versiune 2014.1 (31 decembrie 2014 )
Utilizare Scop general
Paradigme funcțional , orientat spre obiect
Tastare Puternic
Influențată de CLOS , C ++ , ALGOL , Scheme
A influențat Goo , Lasso, Python , Ruby
Implementare referință
Sistem de operare multiplataforma
Site-ul web opendylan.org

Limbajul de programare Dylan , ( [ˈdɪlən] , ca și numele de familie al lui Bob Dylan ), este funcțional , orientat obiect , reflectiv și dinamic . A fost inventat la începutul anilor nouăzeci de un grup Apple Computer .

Dylan este în primul rând o versiune curată și simplificată a CLOS , un sistem de programare orientat pe obiecte bazat pe Common Lisp . În Dylan, practic toate entitățile (inclusiv tipurile de date primitive, metodele și clasele) sunt obiecte de primă clasă. Programele pot fi scrise cu o gamă de la utilizarea doar a tipurilor de date dinamice până la tipurile de date statice, permițând o proiectare rapidă, dar lăsând loc pentru optimizarea viitoare. Dylan acceptă moștenirea multiplă, polimorfismul, dispeceratele multiple, argumentele cuvintelor cheie, introspecția obiectelor, macro-urile și multe alte caracteristici avansate.

Scopul principal al lui Dylan este de a fi un limbaj dinamic adecvat pentru dezvoltarea de programe comerciale. Dylan încearcă să rezolve problemele de performanță introducând limite „naturale” la flexibilitatea deplină a sistemelor Lisp, astfel încât să permită compilatorului să recunoască în mod clar unitățile de compilare (cum ar fi bibliotecile). Primele versiuni ale lui Dylan erau foarte asemănătoare cu sistemele CLOS existente, dar în 1993 limbajul a revenit la dezvoltare, datorită feedback-ului dezvoltatorilor, pentru a veni cu o sintaxă mai clară.

Istorie

Dylan a fost inventat la începutul anilor 1990 de o echipă Apple Computer . S-a gândit, în timpul dezvoltării sale, să îl folosească pe computerele Apple Newton , dar implementarea lui Dylan nu a atins suficientă maturitate în timp și Newton a folosit o combinație de C și NewtonScript dezvoltată de Walter Smith. Apple a încetat să-și dezvolte implementarea Dylan în 1995 , când a lansat o „versiune tehnologică” („Apple Dylan TR1”) care include un IDE avansat.

Alte două grupuri au contribuit la definirea limbajului și la dezvoltarea implementărilor: Harlequin a produs un IDE comercial pentru Microsoft Windows și Universitatea Carnegie Mellon a produs un compilator open source pentru sistemele de operare Unix . Ambele implementări sunt acum open source și sunt susținute de un grup de voluntari, Gwydion Maintainers .

Limba Dylan a fost denumită în cod Ralph. James Joaquin a ales numele Dylan din „DYnamic LANguage”. (limbaj dinamic).

Sintaxă

La început, Dylan a folosit sintaxa Lisp, care se bazează pe expresii s :

 (legare ((raza 5)
       (circumferință (* 2 $ pi rază)))
  (dacă (> circumferința 42)
      (formatați „Bună ziua cercului mare! c este% =” circumferință)
      (formatați "Bună ziua cerc! c este% =" circumferință))))

Limbajul a fost modificat ulterior pentru a utiliza o sintaxă în stil ALGOL , proiectată de Mike Kahl. Acest lucru ar fi trebuit să fie mai familiar programatorilor C:

 începe
 lasa raza = 5;
 lasa circumferinta = 2 * $ pi * raza;
 dacă (circumferință> 42)
    format-out ("Bună ziua, cerc mare! c =% =", circumferință);
 altceva
    format-out ("Bună ziua, cerc! c este% =", circumferință);
 incheie daca
Sfârșit

La fel ca alte limbaje de programare funcționale, ultimul pas al unei funcții este valoarea returnată. Aceasta înseamnă că următorul cod este o funcție validă care returnează una din cele două valori posibile funcției de apelare:

 definiți metoda a_number (isTen :: <șir>)
  if (isTen = "10")
    10;
  altceva
    11;
  incheie daca;
metoda finală;

Comparație între module și spații de nume

În majoritatea limbajelor orientate obiect, clasa este sistemul principal de încapsulare ; limba este în general înțeleasă ca „o modalitate de a construi clase”. Limbajele moderne orientate pe obiecte includ, de obicei, și un construct la nivel înalt cunoscut sub numele de spațiu de nume , care este necesar pentru a aduna clase similare. În plus, sistemul de spațiu de nume / clasă în multe limbi definește o singură unitate care trebuie utilizată în întregime: de exemplu, dacă doriți să utilizați funcția String.concat, va trebui să o importați și să o compilați pe toate șirurile sau pe spațiul de nume care le include.

În Dylan, conceptele de unități de compilare și import sunt separate, iar clasele nu au nimic în comun cu ele. Un modul definește obiecte care ar trebui să fie compilate și tratate împreună, în timp ce o „interfață” definește spațiul de nume. Clasele pot fi puse împreună cu modulele sau în opoziție cu acestea, în funcție de preferințele programatorului. De obicei, definiția completă a unei clase nu este inclusă într-un singur modul, ci este răspândită pe mai multe module care pot fi grupate. Diferite programe pot avea definiții diferite ale aceleiași clase, inclusiv doar ceea ce au nevoie.

Care este diferența? Să luăm în considerare o bibliotecă pentru suportul expresiei regulate pe șiruri. În limbile tradiționale, pentru a include funcționalitatea în șiruri, trebuie adăugată la spațiul de nume String. Pe măsură ce faceți acest lucru, clasa String devine mai grea și oamenii care nu au nevoie de expresii regulate sunt penalizați de această creștere. Din acest motiv, aceste adăugiri sunt de obicei plasate în spațiul de nume și în obiectele personale. Dezavantajul acestei abordări este că noua funcționalitate nu mai face parte din String; în schimb, este izolat în propriul său set de funcții care trebuie apelate separat. În loc de myString.parseWith(myPattern) , sintaxă care urmează conceptele clasice de programare myString.parseWith(myPattern) obiect, este forțat să folosească așa ceva: myPattern.parseString(myString) care răstoarnă ordinea naturală.

În plus, mai multe interfețe pot fi definite în Dylan pentru același cod. De exemplu, String.concat ar putea fi plasat atât pe interfața String, cât și pe interfața „concat” care reunește toate funcțiile de concatenare ale diferitelor clase. Această funcționalitate este adesea utilizată în bibliotecile matematice, unde funcțiile sunt adesea aplicate unor tipuri foarte diferite de obiecte.

O utilizare mai practică a interfețelor este de a construi o versiune publică și privată a unui modul, ceva ce alte limbi includ ca o caracteristică „bolt on” care inevitabil provoacă probleme și adaugă sintaxă. În Dylan, programatorul poate pur și simplu introduce orice funcție în interfața „Privat” sau „Dezvoltare” și poate introduce funcțiile pe care dorește să fie accesibile publicului în „Public”. În Java sau C ++ vizibilitatea unui obiect este definită în cod, în sensul că pentru a face o astfel de modificare programatorul ar fi obligat să rescrie definițiile complet și nu ar putea avea două versiuni disponibile în același timp.

Clase

Clasele din Dylan descriu categorii (sloturi: membri de date, câmpuri, ivari etc.) de obiecte într-un mod similar cu majoritatea limbajelor OO. Tot accesul la categorii se face prin metode (o caracteristică a limbajelor cele mai dinamice ). Metodele standard pentru preluarea sau setarea datelor sunt generate automat pe baza numelui categoriei. Spre deosebire de multe alte limbi OO, celelalte metode utilizabile din clasă sunt adesea definite în afara acestei clase. De fapt, definițiile claselor din Dylan includ adesea doar definiția stocării datelor. De exemplu:

 definiți clasa <fereastră> (<vizualizare>)
   slot title :: <string> = "untitled", init-keyword: title:;
   slot poziție :: <punct>, required-init-keyword: poziție:;
 clasa finală;

În acest exemplu, este construită clasa " <window> ". Sintaxa <nume de clasă> este doar o convenție utilă pentru ao face vizibilă: parantezele unghiulare fac, de fapt, parte din numele clasei. Ca și în alte limbi, este obișnuit să începeți numele clasei cu o literă mare, sau cu un „c” sau un „T” (de exemplu), așa că în Dylan numele este inclus între paranteze unghiulare. <window> derivă dintr-o singură clasă: <view> și conține două sloturi: title , care conține un șir pentru numele ferestrei și position , care conține distanțele carteziene de la colțul din stânga sus al ferestrei. În acest exemplu specific, titlul are numele implicit , în timp ce poziția nu are nimic. Codul opțional „init-cuvânt cheie” permite programatorului să specifice valoarea inițială a slotului atunci când creează instanțe ale clasei.

În limbi precum C ++ sau Java, clasa ar trebui să-și definească interfața. În acest caz, codul nu are instrucțiuni despre acesta, așa că în aceste limbi accesul la sloturi și metode ar fi în modul de protect , ceea ce înseamnă că acestea pot fi utilizate numai de către subclase. Pentru a permite codului extern să utilizeze instanțe de <fereastră>, ar trebui să declarați clasa ca fiind public .

În Dylan, aceste reguli de vizibilitate nu sunt considerate doar parte a codului în sine, ci și din modulul / sistemul de interfață. Acest lucru duce la o flexibilitate considerabilă: de exemplu, o interfață utilizată în primele etape de dezvoltare ar putea declara orice ca fiind public, în timp ce ulterior ar putea trece la protejat. Cu C ++ sau Java, aceste modificări ar necesita modificări de cod, în timp ce în Dylan este un concept complet separat.

Deși acest exemplu nu îl folosește, Dylan acceptă și moștenirea multiplă .

Metode și funcții generice

În Dylan, metodele nu sunt asociate strict cu o anumită clasă, dar pot fi considerate ca și cum ar exista în afara lor. La fel ca CLOS, Dylan se bazează pe multimetode , unde metoda specifică de apelat este aleasă luând în considerare tipurile tuturor argumentelor sale. Metoda nu trebuie neapărat să fie cunoscută în momentul compilării , cunoștințele se referă la funcționalitatea necesară sau nu, pe baza preferințelor utilizatorului.

În Java, aceleași metode ar fi izolate unei anumite clase. Pentru a utiliza această funcționalitate, programatorul ar trebui să importe această clasă și să se refere explicit la aceasta pentru a apela metoda. Dacă această clasă nu este disponibilă sau este necunoscută la compilare, programul nu va compila.

În Dylan, codul este izolat de „funcții”. Multe clase au metode care își numesc propriile funcții și arată ca majoritatea celorlalte limbi OO. Cu toate acestea, codul poate fi conținut și în funcții generice , în sensul că nu sunt legate de o anumită clasă și pot fi apelate nativ de oricine. Legarea unei funcții generice la o metodă dintr-o clasă se face după cum urmează:

 definiți metoda turn-blue (w :: <window>)
   w.color: = $ albastru;
 metoda finală;

Această definiție este similară cu cele din alte limbi și ar putea fi plasată în clasa <window> . Observați apelul: = care este zahăr sintactic pentru color-setter($blue, w) .

Utilitatea metodelor generice devine evidentă atunci când se iau în considerare exemple mai generale. De exemplu, o funcție obișnuită în multe limbi este to-string , care returnează ceva care poate fi citit uman de obiect. Cu aceasta, o fereastră își poate întoarce titlul și poziția între paranteze, în timp ce un șir se va întoarce singur. În Dylan, aceste metode ar putea fi reunite într-un singur modul numit „ to-string ”, eliminând astfel acest cod din definiția clasei în sine. Dacă un anumit obiect nu a putut fi analizat de to-string , acesta ar putea fi adăugat în modulul to-string .

Extensibilitate

Această parte poate părea foarte ciudată pentru unii cititori. Codul de gestionat to-string pentru o fereastră nu este definit în <window> ? Acest lucru ar putea să nu aibă sens dacă nu luați în considerare modul în care Dylan gestionează apelul la to-string . În majoritatea limbilor, atunci când programul este compilat, to-string este căutat <window> și înlocuit cu un pointer (mai mult sau mai puțin) la o metodă. În Dylan, acest lucru se întâmplă atunci când rulați programul pentru prima dată: cu această ocazie, runtime construiește un tabel de nume-metode / parametri și caută metode dinamic prin acest tabel. Aceasta înseamnă că o funcție pentru o anumită metodă poate fi localizată oriunde, nu doar în unitatea de timp de compilare. În cele din urmă, programatorul are posibilitatea de a insera codul aproape acolo unde preferă, inserându-l între liniile unei clase atunci când consideră că este adecvat și în liniile funcționale când crede că nu este.

Aceasta înseamnă că un programator poate adăuga funcționalitate la o clasă existentă construind funcții într-un fișier separat. De exemplu, s-ar putea să doriți să adăugați verificarea gramaticii la toate <string> care, în multe limbi, ar necesita acces la codul sursă al clasei de șiruri -, dar aceste clase de bază uneori nu o au disponibilă. În Dylan (și alte „limbaje extensibile”) metoda de verificare a gramaticii poate fi adăugată în modulul de spell-check cu definirea tuturor claselor la care poate fi aplicată, prin construcția define method . În acest fel, funcționalitatea reală poate fi definită într-o singură declarație generică, care ia un șir și returnează erori. Când modulul de spell-check este compilat într-un program, toate șirurile (și alte obiecte) vor avea funcționalitatea adăugată.

Acest lucru s-ar putea să nu pară încă atât de evident, dar în realitate este o problemă comună aproape tuturor limbajelor OO; nu totul într-o construcție de clasă: unele probleme se aplică „tuturor” obiectelor din sistem, dar nu există o modalitate naturală de a gestiona această situație.

Apple Dylan

Apple Dylan a fost denumit în cod „ Leibniz ”, în onoarea inventatorului de calcul . A fost inițial dezvoltat ca o cutie de instrumente și un limbaj de aplicații pentru mașina Apple Newton .

Mediu de dezvoltare

Partea UI a mediului de dezvoltare Apple Dylan (adică neglijarea compilatorului, a linkerului și a bibliotecilor de execuție) a fost denumită în cod „Hula”. A fost un mediu de dezvoltare multiplataforma inspirat de Smalltalk , Macintosh Common Lisp și Think C. Include:

  • „Binder”: un instrument pentru configurarea componentelor IDE
  • o bază de date sursă
  • o bază de date cu definiții
  • un compilator incremental
  • un depanator de cod sursă pe mai multe platforme
  • instrumente de profilare
  • un instrument pentru construirea de interfețe

Fereastra principală din Hula este Binder. O fereastră Binder este formată din panouri interconectate. Fiecare panou poate avea propria sa intrare, aspect și stil. O intrare de panou este un panou separat; un panou afișează informații despre obiectele selectate. Aspectul este o proprietate a intrării, cum ar fi codul sursă, conținut, apeluri, citiri, scrieri, referințe sau avertismente de construire. Aceste informații pot fi reprezentate ca o diagramă sau un grafic. Intrările, aparențele și stilurile pot fi utilizate pentru a construi replici ale browserului sursă al Smalltalk sau grafice statice sau afișaje specifice, cum ar fi cele necesare pentru a afișa apelurile citite la variabilele scrise de o funcție. Toate vizualizările sunt live: de exemplu, recompilarea unei funcții face ca toate afișajele care conțin informații despre aceasta să fie actualizate.

Vizualizarea schemei include o serie de indicatori care avertizează dacă sursa a fost salvată, compilată sau a dat avertismente.

Cadru pentru proiectarea interfețelor utilizator

Apple Dylan conține un cadru pentru construirea interfețelor utilizator scrise în Dylan de Mike Lockwood. Cadrul este strâns integrat cu un constructor de interfețe WYSIWYG numit Meccano, scris de Robin Mair. Prin conectarea constructorului de interfețe la un program, puteți comuta între modurile Edit și Run în timp ce aplicația rulează. Obiectele care controlează aliniamentele și decorațiunile de margine au fost reprezentate ca obiecte grafice care ar putea fi trase într-un obiect „interfață utilizator” pentru a-și schimba comportamentul sau aspectul.

Implementare

Apple Dylan a fost implementat în Macintosh Common Lisp (MCL). Sediul Apple Cambridge s-a născut odată cu achiziția Coral Software, dezvoltatorii Macintosh Common Lisp.

Când Dylan a fost mutat de la ARM la desktop, partea din spate a fost modificată pentru a fi utilizată cu APPLEX, un asamblator portabil construit de grupul Wayne Loufborrow de la Apple Cupertino.

Dezvoltatori

Compiler și Runtime:

  • David Moon
  • Kim Barrett
  • Bob Cassels
  • Gail Zacharias
  • Glen Burke
  • John Hotchkiss
  • Kálmán Réti
  • Mark Preece
  • Jeff Piazza
  • Steve Strassmann
  • Derek White
  • Robert Stockton

Definiția limbajului:

  • Andrew Shalit
  • Orca Starbuck

Hula:

  • Oliver Steele
  • Paige Parsons
  • Bill St. Clair
  • Jeremy Jones
  • John Hotchkiss
  • Neil Mayle
  • Steve Strassmann

MCL:

  • Alice Hartley
  • Bill St. Clair
  • Gary Byers

(Aceste liste sunt incomplete)

Elemente conexe

linkuri externe

  • (RO) Noțiuni introductive despre Dylan , pe opendylan.org. Adus la 9 septembrie 2006 (arhivat din original la 5 octombrie 2006) .
  • ( EN ) Gwydion Dylan - gazdă a două compilatoare Dylan optimizate care vizează Unix / linux, Mac OS X și Microsoft Windows
  • ( EN ) Interpretul Marlais Dylan , pe cis.ufl.edu . Adus la 9 septembrie 2006 (arhivat din original la 29 august 2006) .
  • ( EN ) DylanSource.com - O excelentă compilare a instrumentelor Dylan disponibile și a resurselor de învățare
  • ( EN ) Limbajul de programare Dylan , pe double.co.nz . Adus la 9 septembrie 2006 (arhivat din original la 24 septembrie 2006) .
  • ( EN ) Dylan Language Wiki , la wiki.opendylan.org . Adus la 9 septembrie 2006 (arhivat din original la 29 august 2006) .
Controlul autorității LCCN ( EN ) sh96003058
Informatică Portal IT : accesați intrările Wikipedia care se ocupă cu IT