diff options
| -rw-r--r-- | ro-ro/haskell-ro.html.markdown | 453 | ||||
| -rw-r--r-- | ro-ro/latex-ro.html.markdown (renamed from ro-ro/latex.html.markdown) | 60 |
2 files changed, 482 insertions, 31 deletions
diff --git a/ro-ro/haskell-ro.html.markdown b/ro-ro/haskell-ro.html.markdown new file mode 100644 index 00000000..98751538 --- /dev/null +++ b/ro-ro/haskell-ro.html.markdown @@ -0,0 +1,453 @@ +--- +language: Haskell +contributors: + - ["Adit Bhargava", "http://adit.io"] +translators: + - ["Petru Dimitriu", "http://petru-dimitriu.github.io"] +--- + +Haskell este un limbaj de programare practic, pur funcțional. + +```haskell +-- Comentariile pe o singura linie incep cu 2 cratime. +{- Comentariile multilinie + se scriu astfel. +-} + +---------------------------------------------------- +-- 1. Tipuri de date primitive si operatori +---------------------------------------------------- + +-- Exista numere +3 -- 3 + +-- Matematica functioneaza ca de obicei +1 + 1 -- 2 +8 - 1 -- 7 +10 * 2 -- 20 +35 / 5 -- 7.0 + +-- Impartirea este cu virgula +35 / 4 -- 8.75 + +-- Impartirea cu rest +35 `div` 4 -- 8 + +-- Valorile booleene sunt primitive +True +False + +-- Operatii logice +not True -- False +not False -- True +1 == 1 -- True +1 /= 1 -- False +1 < 10 -- True + +-- In exemplele de mai sus, `not` este o functie ce primeste o valoare. +-- In Haskell nu se pun paranteze pentru apelurile de functie. Toate +-- argumentele sunt insirate dupa numele functiei. Sablonul general este: +-- func arg1 arg2 arg3 +-- Vedeti sectiunea despre functii pentru a afla cum sa scrieti propria functie. + +-- Caractere si siruri de caractere +"Acesta este un sir de caractere" +'a' -- un caracter +'Nu se pot folosi apostroafe pentru siruri.' -- eroare! + +-- Sirurile pot fi concatenate +"Hello " ++ "world!" -- "Hello world!" + +-- Un string e de fapt o lista de caractere +['H', 'e', 'l', 'l', 'o'] -- "Hello" +"Acesta este un string" !! 0 -- 'A' + + +---------------------------------------------------- +-- Liste si tupli +---------------------------------------------------- + +-- Fiecare element dintr-o lista trebuie sa aiba acelasi tip. +-- Urmatoarele liste sunt identice. +[1, 2, 3, 4, 5] +[1..5] + +-- Intervalele sunt versatile. +['A'..'F'] -- "ABCDEF" + +-- Se poate specifica un pas pentru intervale. +[0,2..10] -- [0, 2, 4, 6, 8, 10] +[5..1] -- Aceasta nu functioneaza deoarece pasul implicit este incrementarea. +[5,4..1] -- [5, 4, 3, 2, 1] + +-- indexarea intr-o lista este de la zero +[1..10] !! 3 -- se obtine 4 + +-- Se pot crea liste infinite +[1..] -- lista tuturor numerelor naturale + +-- Listele infinite functioneaza pentru ca Haskell foloseste "evaluare lenesa" +-- adica evalueaza lucrurile doar cand este nevoie de ele. Deci se poate +-- cere al 1000-lea element din lista infinita a numerelor naturale astfel: + +[1..] !! 999 -- rezulta 1000 + +-- Haskell a evaluat elementele 1 - 1000 din lista... dar restul elementelor +-- acestei liste "infinite" nu exista inca! Haskell nu le va evalua pana +-- nu va fi nevoie de ele. + +-- concatenarea a doua liste +[1..5] ++ [6..10] + +-- alipirea la capul listei +0:[1..5] -- [0, 1, 2, 3, 4, 5] + +-- operatii cu liste +head [1..5] -- 1 +tail [1..5] -- [2, 3, 4, 5] +init [1..5] -- [1, 2, 3, 4] +last [1..5] -- 5 + +-- intelegerea listelor +[x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10] + +-- folosind o conditie +[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10] + +-- Fiecare element dintr-un tuplu poate fi de un tip diferit +-- dar un tuplu are lungime fixa +-- Un tuplu: +("haskell", 1) + +-- accesarea elementelor unui tuplu pereche +fst ("haskell", 1) -- "haskell" (first) +snd ("haskell", 1) -- 1 (second) + +---------------------------------------------------- +-- 3. Functii +---------------------------------------------------- +-- O functie simpla ce sumeaza doua variabile +add a b = a + b + +-- Aveti in vedere ca daca folositi ghci (interpretorul Haskell) +-- trebuie sa scrieti in fata si `let`, adica +-- let add a b = a + b + +-- Apelarea functiei +add 1 2 -- rezulta 3 + +-- Numele functiei se poate pune si intre argumente +-- folosind apostrof intors: +1 `add` 2 -- 3 + +-- Se pot defini functii fara litere in denumire! Astfel se pot +-- defini noi operatori! De exemplu, iata un operator care realizeaza +-- impartirea intreaga +(//) a b = a `div` b +35 // 4 -- rezulta 8 + +-- Guards: o metoda usoara de a crea ramuri de executie +fib x + | x < 2 = 1 + | otherwise = fib (x - 1) + fib (x - 2) + +-- Potrivirea sirurilor se face similar. Aici am definit 3 definitii +-- pentru fib. Haskell o va alege automat pe prima care se potriveste +-- cu sablonul valorii. +fib 1 = 1 +fib 2 = 2 +fib x = fib (x - 1) + fib (x - 2) + +-- Potrivirea in tupli: +foo (x, y) = (x + 1, y + 2) + +-- Potrivirea in liste. Aici `x` este primul element al listei, +-- iar `xs` este restul litei. Putem scrie propria functie +-- de mapare +myMap func [] = [] +myMap func (x:xs) = func x:(myMap func xs) + +-- Functiile anonime sunt create folosind un backslash urmat +-- de toate argumentele. +myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7] + +-- utilizarea fold (denumit `inject` in alte limbaje) cu o functie +-- anonima. foldl1 inseamna pliere la stanga, folosind prima valoare +-- din lista drept valoarea initiala pentru acumulator +foldl1 (\acc x -> acc + x) [1..5] -- 15 + +---------------------------------------------------- +-- 4. Mai multe functii +---------------------------------------------------- + +-- aplicare partiala; daca nu se introduc toate argumentele unei functii, +-- este "aplicata partial", adica returneaza o noua functie ce primeste +-- restul argumentelor, avand deja setate argumentele introduse + +add a b = a + b +foo = add 10 -- foo este o functie ce primeste un numar si ii aduna 10 +foo 5 -- 15 + +-- alta maniera de a scrie acelasi lucru +foo = (10+) +foo 5 -- 15 + +-- compunerea functiilor +-- operatorul `.` inlantuieste functiile. +-- De exeplu, aici foo este o functie care aduna 10 unui numar, il inmul +-- teste cu 4 si returneaza rezultatul calcului +foo = (4*) . (10+) + +-- 4*(10 + 5) = 60 +foo 5 -- 60 + +-- alterarea precedentei +-- Haskell detine un operator numit `$`. Acest operator aplica o functie +-- unui parametru dat. Fata de aplicarea standard a functiilor, care +-- foloseste prioritatea maxim posibila 10 si este asociativa la stanga, +-- operatorul `$` are prioritatea 0 si este asociativ la dreapta. +-- Aceasta inseamna ca expresia de la dreapta este aplicata ca parametru +-- functiei din stanga + +-- inainte +even (fib 7) -- false + +-- echivalent +even $ fib 7 -- false + +-- compunerea functiilor +even . fib $ 7 -- false + + +---------------------------------------------------- +-- 5. Type signatures +---------------------------------------------------- + +-- Haskell are un sistem de tipuri de date foarte puternic; fiecare expresie +-- valida are un tip. + +-- Cateva tipuri de baza: +5 :: Integer +"hello" :: String +True :: Bool + +-- Functiile au tipuri de asemenea. +-- `not` primeste un boolean si returneaza un boolean. +-- not :: Bool -> Bool + +-- Iata o functie ce primeste doi intregi +-- add :: Integer -> Integer -> Integer + +-- Cand se defineste o valoare, este bine sa se precizeze tipul ei deasupra. +double :: Integer -> Integer +double x = x * 2 + +--------------------------------------------------------- +-- 6. Controlul executiei si instructiunile conditionale +--------------------------------------------------------- + +-- expresia conditionala if +haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome" + +-- cand expresiile sunt pe mai multe linii, este importanta indentarea +haskell = if 1 == 1 + then "awesome" + else "awful" + +-- expresiile de tip case; iata cum se verifica argumentele programului +case args of + "help" -> printHelp + "start" -> startProgram + _ -> putStrLn "bad args" + + +-- Haskell nu foloseste cicluri, ci recursie +-- map aplica o functie fiecarui element dintr-o lista + +map (*2) [1..5] -- [2, 4, 6, 8, 10] + +-- se poate face o functie for folosind map +for array func = map func array + +-- si apoi se poate folosi astfel: +for [0..5] $ \i -> show i + +-- se poate scrie si asa: +for [0..5] show + +-- Se poate folosi foldl sau foldr pentru a reduce o lista +-- foldl <fn> <valoare initiala> <lista> +foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43 + +-- Acelasi lucru ca a scrie +(2 * (2 * (2 * 4 + 1) + 2) + 3) + +-- foldl functioneaza spre stanga, foldr spre dreapta +foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16 + +-- Acealsi lucru ca: +(2 * 1 + (2 * 2 + (2 * 3 + 4))) + +---------------------------------------------------- +-- 7. Tipuri de date +---------------------------------------------------- + +-- Iata cum se creeaza un tip de date in Haskell + +data Culoare = Rosu | Albastru | Verde + +-- Acum poate fi folosit in functii + + +spune :: Culoare -> String +spune Rosu = "Esti Rosu!" +spune Albastru = "Esti Albastru!" +spune Verde = "Esti Verde!" + +-- Tipul de date poate avea si parametri. + +data Maybe a = Nothing | Just a + +-- Toate acestea sunt de tipul Maybe +Just "hello" -- de tipul `Maybe String` +Just 1 -- de tipul `Maybe Int` +Nothing -- de tipul `Maybe a` pentru oricare `a` + +---------------------------------------------------- +-- 8. IO in Haskell +---------------------------------------------------- + +-- Desi IO nu se poate explica intru totul fara a explica monadele, +-- nu este atat de greu de explicat pentru o idee de baza. + +-- Cand se executa un program Haskell, se apeleaza `main`. +-- Trebuie sa returneze o valoare de tio `IO a` pentru un anumit tip `a`. +-- De exemplu: + +main :: IO () +main = putStrLn $ "Hello, sky! " ++ (say Blue) +-- putStrLn are tipul String -> IO () + +-- Cel mai usor se lucreaza cu IO daca se implementeaza programul +-- ca o functie de la String la String. Functia +-- interact :: (String -> String) -> IO () +-- citeste un text, executa o functie asupra ei, apoi afiseaza +-- iesirea. + +countLines :: String -> String +countLines = show . length . lines + +main' = interact countLines + +-- O valoare de tipul `IO ()` poate fi privita ca reprezentand +-- o secventa de actiuni pe care care computerul sa le execute, +-- similar cu felul in care un program este scris intr-un limbaj +-- imperativ. Putem folosi notatia `do` pentru a inlantui actiunile. +-- De exemplu: + +sayHello :: IO () +sayHello = do + putStrLn "What is your name?" + name <- getLine -- citeste o linie + putStrLn $ "Hello, " ++ name + +-- Exercise: Scrieti propria functie `interact` care citeste +-- o singura linie de la intrare. + + +-- Codul din `sayHello` nu va fi niciodata executat. Singura actiunile +-- care este executata este valoarea lui `main`. +-- Pentru a rula `sayHello.`, eliminati definitia de mai sus a `main`. +-- si inlocuiti-o cu +-- main = sayHello + +-- Sa intelegem mai bine cum functioneaza functia `getLine`. +-- Tipul ei este: +-- getLine :: IO String +-- Pueti privi o valoare de tipul `IO a` ca fiind un program +-- de computer care va genera o valoare de tipul `a` cand +-- este executata (pe langa orice altceva face). O putem denumi +-- si refolosi utilizand `<-`. De asemenea putem face propriile +-- actiuni te tipul `IO String`: + +action :: IO String +action = do + putStrLn "Aceasta e o linie." + input1 <- getLine + input2 <- getLine + --Tipul instructiunii `do` este cel de pe ultima sa linie. + -- `return` nu este un cuvant cheie, ci o functie + return (input1 ++ "\n" ++ input2) -- return :: String -> IO String + +-- Putem folosi aceasta exact cum am folosit `getLine`: + +main'' = do + putStrLn "I will echo two lines!" + result <- action + putStrLn result + putStrLn "This was all, folks!" + +-- Tipul `IO` este un exemplu de "monada". Felul in care Haskell foloseste +-- o monada pentru a realiza opeartii de intrare si iesire il face un limbaj +-- pur functional. Orice functie care interactioneaza cu exteriorul (adica +-- realieaza IO) este marcata ca `IO` in semnatura ei. Aceasta ne permite +-- sa spunem ce functii sunt "pure", adica nu interactioneaza cu exteriorul. + +-- Aceasta este o facilitate foarte puternica, deoarece este usor sa +-- se ruleze functii pure concurent; asadar, concurenta in Haskell se face usor + +---------------------------------------------------- +-- 9. REPL in Haskell +---------------------------------------------------- + +-- Se porneste introducand `ghci`. +-- Dupa aceasta, se poate introduce cod Haskell. +-- Toate valorile noi trebuie precedate de `let`. + +let foo = 5 + +-- Puteti vedea tipul oricarei valori sau expresii cu `:t`. + +> :t foo +foo :: Integer + +-- Operatorii, precum `+`, `:` si `$` sunt functii. +-- Tipul lor poate fi observat punand operatorii intre paranteze. + +> :t (:) +(:) :: a -> [a] -> [a] + +-- Se pot obtine informatii despre fiecare nume folosind `:i` + +> :i (+) +class Num a where + (+) :: a -> a -> a + ... + -- Defined in ‘GHC.Num’ +infixl 6 + + +--De asemenea se poate executa orice actiune de tipul `IO ()` + +> sayHello +What is your name? +Friend! +Hello, Friend! + +``` +Mai sunt multe de spus despre Haskell, printre care typclasses și monade. +Acestea sunt marile idei care fac programarea în Haskell atât de interesantă. +Vă las un exemplu final în Haskell: o variantă de implementare a sortării rapide +(quicksort) în Haskell: + +```haskell +qsort [] = [] +qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater + where lesser = filter (< p) xs + greater = filter (>= p) xs +``` + +Există două maniere populare de a instala Haskell: prin [instalarea bazată pe Cabal](http://www.haskell.org/platform/), și prin mai noul [proces bazat pe Stack](https://www.stackage.org/install). + +Se poate găsi o introducere în Haskell mult mai blândă la adresele +[Learn you a Haskell](http://learnyouahaskell.com/) sau +[Real World Haskell](http://book.realworldhaskell.org/). diff --git a/ro-ro/latex.html.markdown b/ro-ro/latex-ro.html.markdown index 35651e28..f661db0a 100644 --- a/ro-ro/latex.html.markdown +++ b/ro-ro/latex-ro.html.markdown @@ -7,7 +7,6 @@ contributors: - ["Ramanan Balakrishnan", "https://github.com/ramananbalakrishnan"] translators: - ["Petru Dimitriu", "http://petru-dimitriu.github.io"] -filename: brainfuck-ro.clj filename: learn-latex-ro.tex lang: ro-ro --- @@ -43,19 +42,18 @@ lang: ro-ro \usepackage[utf8]{inputenc} % De asemenea, putem defini și alte proprietăți pentru documente. -% We can define some other document properties too! \author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu \\ Traducere de Petru Dimitriu} \date{\today} \title{Învățați LaTeX în Y minute!} % Suntem gata să începem documentul. % Tot ce se află înaintea acestei linii se numește "Preambul" -\begin{document} +\begin{document} % dacă am setat autorul, data și titlul, putem cere LaTeX să % creeze o pagină de titlu \maketitle -% Cele mai multe documente științifice au un abstract; puteți folosi comenzile +% Cele mai multe documente științifice au un rezumat; puteți folosi comenzile % predefinite pentru acesta. Acesta ar trebui să apară, așa cum ar fi logic, % după titlu, dar înainte de secțiunile principale ale corpului. % Această comandă este disponibilă în clasele de document article și report. @@ -71,7 +69,7 @@ Salut, mă numesc Petru. Astăzi vom învăța împreună LaTeX! \section{Altă secțiune} Acesta este textul pentru altă secțiune. Vom face o subsecțiune. -\subsection{Aceasta este o subsecțiune} % Subsecțiunile sunt și ele intuitive. +\subsection{Aceasta este o subsecțiune} Și încă una. \subsubsection{Pitagora} @@ -80,7 +78,7 @@ Mult mai bine. % Folosind asteriscul putem suprima numărătoarea automată a LaTeX. % Aceasta funcționează și pentru alte comenzi LaTeX. -\section*{Secțiune fără numerotare} +\section*{Secțiune fără numerotare} Totuși nu toate secțiunile trebuie să fie nenumerotate! \section{Note despre text} @@ -89,7 +87,7 @@ nevoie \\ să \\ fie \\ întreruptă, puteți adăuga două caractere backslash la codul sursă. \section{Liste} -Listele sunt printre cel mai simplu de făcut lucruri în LaTeX! Mâine merg la +Listele sunt printre cel mai simplu de făcut lucruri în LaTeX! Mâine merg la cumpărături așa că fac o listă: \begin{enumerate} % Aceasta creează un mediu "enumerate" % \item spune mediului "enumerate" să incrementeze @@ -101,20 +99,20 @@ cumpărături așa că fac o listă: Nu este un element din listă, dar încă face parte din "enumerate". -\end{enumerate} % All environments must have an end. +\end{enumerate} % Toate mediile trebuie să aibă o instrucțiune de încheiere. \section{Matematică} Una dintre principalele întrebuințări ale LaTeX este realizarea -articolelor academice sau a foilor tehnice, de obicei aflate în +articolelor academice sau a fișelor tehnice, de obicei aflate în universul matematicii și științelor exacte. Astfel, trebuie să putem -adăuga simboluri speciale în documentului nostru! \\ +adăuga simboluri speciale în documentul nostru! \\ Matematica are multe simboluri, mult mai multe decât se găsesc pe o tastatură - printre ele, simboluri pentru mulțimi și relații, săgeți, operatori și litere grecești.\\ -Mulțimile și relațiile sunt de bază în lucrările științifce matematice. +Mulțimile și relațiile sunt esențiale în lucrările științifce matematice. Iată cum se scrie: toți y aparținând lui X.\\ $\forall$ x $\in$ X. \\ @@ -127,13 +125,13 @@ $\forall$ x $\in$ X. \\ \[a^2 + b^2 = c^2 \] -Litera mea grecească este $\xi$. De asemenea îmi plac $\beta$, $\gamma$ și +Îmi place litera $\xi$. De asemenea îmi plac $\beta$, $\gamma$ și $\sigma$. Nu există nicio literă grecească necunoscută pentru LaTeX! -Operatorii sunt exențiali într-un document matematic! -funcțiile trigonometrice ($\sin$, $\cos$, $\tan$), -logaritmii și exponențialele ($\log$, $\exp$), -limitele ($\lim$), etc. +Operatorii sunt esențiali într-un document matematic! +funcțiile trigonometrice ($\sin$, $\cos$, $\tan$), +logaritmii și exponențialele ($\log$, $\exp$), +limitele ($\lim$), etc. au comenzi definite în LaTeX pentru fiecare. Să vedem cum scriem o ecuație: \\ @@ -156,20 +154,20 @@ Putem insera ecuații și într-un "mediu pentru ecuații". \end{equation} % toate instrucțiunile cu \begin trebuie să fie cuplate cu o instrucțiune cu \end -Putem referenția noua nosatră ecuație! +Putem referenția noua noastră ecuație! ~\ref{eq:pitagora} este cunoscută și ca Teorema lui Pitagora, despre care vorbim și la Sec.~\ref{subsec:pitagora}. Multe lucruri prot fi etichetate: figuri, ecuații, secțiuni, etc. Sumele discrete și integralele se scriu cu comenzile sum și int. -% Unele compilatoare LaTeX nu acceptă să există linii goala +% Unele compilatoare LaTeX nu acceptă să existe linii goale % într-un mediu pentru ecuații. -\begin{equation} +\begin{equation} \sum_{i=0}^{5} f_{i} -\end{equation} -\begin{equation} +\end{equation} +\begin{equation} \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x -\end{equation} +\end{equation} \section{Figuri} @@ -179,7 +177,7 @@ Eu trebuie să mă uit peste opțiunile de așezare de fiecare dată. \begin{figure}[H] % H denumește opțiunle de așezare \centering % centrează figura pe pagină % Inserează o figură scalată la 0.8 din lățimea paginii. - %\includegraphics[width=0.8\linewidth]{right-triangle.png} + %\includegraphics[width=0.8\linewidth]{right-triangle.png} % Comentat pentru a nu împiedica fișierul să compileze. \caption{Triunghi dreptunghic cu laturile $a$, $b$, $c$} \label{fig:right-triangle} @@ -191,7 +189,7 @@ Putem insera tabele la fel cum inserăm figuri. \begin{table}[H] \caption{Descriere pentru tabel} % argumentele {} controlează cum vor fi afișate coloanele - \begin{tabular}{c|cc} + \begin{tabular}{c|cc} Număr & Nume & Prenume \\ % Numele coloanelor sunt separate prin $ \hline % a linie orizonală 1 & Popescu & Ion \\ @@ -208,27 +206,27 @@ ci doar să îl redea în document. Vom face asta cu un mediu verbatim. % Există și alte pachete (i.e. minty, lstlisting, etc.) % dar verbatim este pachetul cel mai simplu. -\begin{verbatim} +\begin{verbatim} print("Salut lume!") a%b; % hei! putem folosi % în verbatim - random = 4; + random = 4; \end{verbatim} -\section{Compilarea} +\section{Compilarea} Acum vă întrebați cum se compilează acest document minunat și să vă -minunați de rezultatul, un PDF LaTeX. (da, documentul acesta chiar +minunați de rezultat, un PDF LaTeX. (da, documentul acesta chiar compilează). \\ Realizarea documentului cu LaTeX va parcurge următorii pași: \begin{enumerate} \item Se scrie documentul în text simplu. (codul sursă) \item Se compilează documentul pentru a produce un PDF. Compilarea arată cam așa în Linux:\\ - \begin{verbatim} - $pdflatex learn-latex.tex learn-latex.pdf + \begin{verbatim} + $pdflatex learn-latex.tex learn-latex.pdf \end{verbatim} \end{enumerate} -Anumiți editor pentru LaTeX combină pașii 1 și 2 în același produs software. +Anumite editoare pentru LaTeX combină pașii 1 și 2 în același produs software. Așadar, dacă vreți să vedeți realizați pasul 1 dar nu și pasul 2, el se poate realiza "în spate". |