Miranda (limbaj de programare)

Miranda
Paradigmă	lazy, funcțională, declarativă
Apărut în	1985  (1985)
Proiectat de	David Turner
Dezvoltator	Research Software Ltd
Ultima versiune	2.066
Tipare	strong, static
Implementări majore	Miranda
Influențat de	KRC, ML, SASL, Hope
Influențe	Clean, Haskell
Prezență online	miranda.org.uk

Miranda este un limbaj de programare leneș, pur funcțional, proiectat de David Turner ca succesor al limbajelor de programare anterioare SASL și KRC, folosind câteva concepte din ML și Hope. A fost produs de Research Software Ltd. din Anglia (care deține o marcă comercială pe numele Miranda) și a fost primul limbaj pur funcțional care trebuie susținut comercial.

Miranda a fost lansată pentru prima dată în 1985, interpretată rapid în C pentru sistemele de operare în Unix, cu lansări ulterioare în 1987 și 1989. Miranda a avut o influență puternică asupra limbajului de programare Haskell ulterior.

Prezentare generală

Miranda este un limbaj de programare leneș, pur funcțional. Aceasta înseamnă că nu are efecte secundare și caracteristici imperative de programare. Un program Miranda (numit script) este un set de ecuații care definesc diferite funcții matematice și tipuri de date algebrice. Setul de cuvinte este important aici: ordinea ecuațiilor este în general, irelevantă și nu este nevoie să se definească o entitate înainte de a fi utilizată.

Deoarece algoritmul de parsare utilizează inteligent aspectul (indentare), este rareori nevoie de instrucțiuni de bracketing și nu sunt necesare terminatoare de instrucțiuni. Această caracteristică, inspirată de ISWIM, este de asemenea folosită în occam și Haskell și a fost ulterior popularizată de Python.

Comentariul este introdus în scripturi obișnuite de caracterele || și continuați până la sfârșitul aceleiași linii. O convenție alternativă de comentare afectează un întreg fișier de cod sursă, cunoscut sub numele de "scenariu literat", în care fiecare linie este considerată un comentariu dacă nu începe cu un semn >.

Tipurile de date de bază ale lui Miranda sunt char, num și bool. Un șir de caractere este pur și simplu o listă de caractere char, în timp ce num este convertit în tăcere între două forme subiacente: numerele de precizie arbitrară (a.k.a.bignums) implicit și valorile punctului de flotare obișnuite, după cum este necesar.

Tupele sunt secvențe de elemente de tipuri mixte potențiale, similare cu înregistrările din limbile asemănătoare cu Pascal și sunt scrise cu paranteze:

  this_employee = ("Folland, Mary", 10560, False, 35)

În schimb, lista este cea mai frecvent utilizată structură de date din Miranda. Este scrisă delimitată de paranteze pătrate și elemente separate prin virgulă, toate acestea trebuie să fie de același tip:

  week_days = ["Mon","Tue","Wed","Thur","Fri"]

Listă de concatenare este ++, scăderea este --, construcția este :, dimensionarea este # și indexarea este! , Deci:

  days = week_days ++ ["Sat","Sun"]
  days = "Nil":days
  days!0
 ⇒ "Nil"
  days = days -- ["Nil"]
  #days
 ⇒ 7

Există mai multe comenzi rapide pentru crearea listelor: .. este folosit pentru liste ale căror elemente formează o serie aritmetică, cu posibilitatea de a specifica un increment diferit de 1:

  fac n   = product [1..n]
  odd_sum = sum [1,3..100]

Mai multe facilități generale și puternice de construire a listelor sunt furnizate prin "înțelegeri în liste" (anterior cunoscute sub numele de "expresii ZF"), care se găsesc în două forme principale: o expresie aplicată unei serii de termeni, de exemplu:

  squares = [ n * n | n <- [1..] ]

(care este citit: lista cu n pătrat unde n este luat din lista tuturor întregurilor pozitive) și o serie în care fiecare termen este o funcție a celui anterior, de exemplu:

  powers_of_2 = [ n | n <- 1, 2*n .. ]

Așa cum aceste două exemple implică, Miranda permite liste cu un număr infinit de elemente, dintre care cea mai simplă este lista tuturor întregurilor pozitive: [1..]

Notația pentru aplicarea funcției este pur si simplu juxtapunere, ca în sin x.

În Miranda, ca în majoritatea limbajelor pur funcționale, funcțiile sunt de primă clasă, adică pot fi trecute ca parametri pentru alte funcții, returnate ca rezultate sau incluse ca elemente ale structurilor de date. În plus, o funcție care necesită doi sau mai mulți parametri poate fi parțial parametrizată sau curată, furnizând mai puțin decât numărul complet de parametri. Aceasta oferă o altă funcție care, având în vedere parametrii rămași, va întoarce un rezultat. De exemplu:

  add a b = a + b
  increment = add 1

Orice funcție care ia doi parametri poate fi transformată într-un operator infixat (de exemplu, având în vedere definiția funcției de add de mai sus, termenul $add este în orice mod echivalent cu operatorul +) și fiecare operator infix care ia doi parametri poate fi transformat în o funcție corespunzătoare. Prin urmare:

  increment = (+) 1

este cea mai scurtă modalitate de a crea o funcție care adaugă una la argumentul său. În mod similar, în

  half = (/ 2)
  reciprocal = (1 /)

se generează două funcții cu un singur parametru. Interpretorul înțelege în fiecare caz care dintre cei doi parametri ai operatorului de împărțire este furnizat, oferind funcții care împarte un număr cu doi și returnează inversul (reciproca).

Deși Miranda este un limbaj de programare puternic tipizat, nu insistă asupra declarațiilor de tip explicit. Dacă un tip de funcție nu este declarat explicit, interpretul îl deduce din tipul parametrilor și din modul în care sunt utilizați în cadrul funcției. În plus față de tipurile de bază (char, num, bool), acesta include un tip "orice" unde tipul de parametru nu contează, ca în funcția de inversare a listei:

  rev [] = []
  rev (a:x) = rev x ++ [a]

care poate fi aplicată unei liste de orice tip de date, pentru care declarația de tip explicită a funcției ar fi:

  rev :: [*] -> [*]

În sfârșit, dispune de mecanisme pentru crearea și gestionarea modulelor de program ale căror funcții interne sunt invizibile pentru programele care apelează la aceste module.

Cod simplu

Următorul script Miranda determină setul tuturor subseturilor dintr-un set de numere

 subsets []     = [[]]
 subsets (x:xs) = [[x] ++ y | y <- ys] ++ ys
                  where ys = subsets xs

și acesta este un script alfabetic pentru o funcție primes care oferă lista tuturor numerelor prime

> || The infinite list of all prime numbers.

The list of potential prime numbers starts as all integers from 2 onwards;
as each prime is returned, all the following numbers that can exactly be
divided by it are filtered out of the list of candidates.

> primes = sieve [2..]
> sieve (p:x) = p : sieve [n | n <- x; n mod p ~= 0]

Aici, avem mai multe exemple

max2 :: num -> num -> num
max2 a b = a, if a>b
         = b, otherwise

max3 :: num -> num -> num -> num
max3 a b c = max2 (max2 a b) (max2 a c)

multiply :: num -> num -> num
multiply 0 b = 0
multiply a b = a + (multiply (a-1) b)

fak :: num -> num
fak 0 = 1
fak 1 = 1
fak n = n * (fak n-1)



itemnumber::[*]->num
itemnumber [] = 0
itemnumber (a:x) = 1 + itemnumber x

weekday::= Mo|Tu|We|Th|Fr|Sa|Su

isWorkDay :: weekday -> bool
isWorkDay Sa = False
isWorkDay Su = False
isWorkDay anyday = True


tree * ::= E| N (tree *) * (tree *)

nodecount :: tree * -> num
nodecount E = 0
nodecount (N l w r) = nodecount l + 1 + nodecount r

emptycount :: tree * -> num
emptycount E = 1
emptycount (N l w r) = emptycount l + emptycount r



treeExample = N ( N (N E 1 E) 3 (N E 4 E)) 5 (N (N E 6 E) 8 (N E 9 E))
weekdayTree = N ( N (N E Mo E) Tu (N E We E)) Th (N (N E Fr E) Sa (N E Su))

insert :: * -> stree * -> stree *
insert x E = N E x E
insert x (N l w E) = N l w x
insert x (N E w r) = N x w r
insert x (N l w r) = insert x l , if x <w
                   = insert x r , otherwise

list2searchtree :: [*] -> tree *
list2searchtree [] = E
list2searchtree [x] = N E x E
list2searchtree (x:xs) = insert x (list2searchtree xs)

maxel :: tree * -> *
maxel E = error "empty"
maxel (N l w E) = w
maxel (N l w r) = maxel r

minel :: tree * -> *
minel E = error "empty"
minel (N E w r) = w
minel (N l w r) = minel l

||Traversing: going through values of tree,putting them in list

preorder,inorder,postorder :: tree * -> [*]
inorder E = []
inorder N l w r = inorder l ++ [w] ++ inorder r

preorder E = []
preorder N l w r = [w] ++ preorder l ++ preorder r

postorder E = []
postorder N l w r = postorder l ++ postorder r ++ [w]

height :: tree * -> num
height E = 0
height (N l w r) = 1 + max2 (height l) (height r)




amount :: num -> num
amount x = x ,if x >= 0
amount x = x*(-1), otherwise


and :: bool -> bool -> bool
and True True = True
and x y = False

|| A AVL-Tree is a tree where the difference between the of the child nodes is not higher than 1
|| i still have to test this

isAvl :: tree * -> bool
isAvl E = True
isAvl (N l w r) = and (isAvl l) (isAvl r), if amount ((nodecount l) - (nodecount r)) < 2
                = False, otherwise
                
                

                
delete :: * -> tree * -> tree *
delete x E = E
delete x (N E x E) = E
delete x (N E x r) = N E (minel r) (loeschen (minel r) r)
delete x (N l x r) = N (loeschen (maxel l) l) (maxel l) r
delete x (N l w r) = N (loeschen x l) w (loeschen x r)

Legături externe

• Site oficial