Clean (programmeertaal)

Uit Wikipedia, de vrije encyclopedie
Ga naar: navigatie, zoeken
Clean
Paradigma functioneel
Verschenen in 1987
Ontworpen door Radboud Universiteit Nijmegen
Huidige versie 2.4 (23 december 2011)
Typesysteem statisch, sterk
Beïnvloed door Haskell
Besturingssysteem Windows, Linux en OS X
Licentie LGPL
Website Officiële website
Portaal  Portaalicoon   Informatica

Clean is een functionele programmeertaal, ontwikkeld aan de Radboud Universiteit Nijmegen. Clean werd ontwikkeld voor het maken van praktische toepassingen.[1] Een functionele programmeertaal betekent dat programma’s opgesteld worden in de vorm van een functie die toegepast wordt om een resultaat te vinden.[2] Omdat Clean een functionele programmeertaal is, kan het gemakkelijker zijn om Clean aan te leren wanneer men al bekend is met algebra van de middelbare school.[3] Clean heeft veel gelijkenissen met andere moderne functionele programmeertalen zoals Miranda, Haskell en ML.[4] Clean is beschikbaar voor Windows, Linux en OS X.[5]

Geschiedenis[bewerken]

Oorspronkelijk was Clean een subset van Lean, ontworpen als experimentele programmeertaal met als doel het graph rewriting model te bestuderen.[1] Graph rewriting houdt in dat men een nieuwe grafiek maakt van de originele grafiek door gebruik te maken van een automatische machine.[6] Daar men zich wilde concentreren op de essentiële implementatieproblemen, werd doelbewust gekozen om weinig syntaxisregels in te voeren in Clean. Clean werd meer en meer gebruikt voor het maken van toepassingen en uiteindelijk werd Clean dan ook omgevormd naar een general purpose functionele programmeertaal.[1] Hiermee wordt bedoeld dat het een functionele programmeertaal is die gebruikt wordt voor verschillende doeleinden.[7] In mei 1995 werd Clean voor het eerst vrijgegeven.[1]

Dynamics[bewerken]

Dynamics is een feature in Clean die de mogelijkheid biedt een expressie weg te schrijven naar opslag of te verzenden over een netwerk. Hierdoor wordt het mogelijk een expressie door te sturen naar een ander systeem, of een module-gebaseerd systeem te ontwikkelen. Een reden kan zijn dat je in je code een functie wil gebruiken, maar je niet zeker weet of er mogelijk later nog een efficiëntere manier van deze functie gevonden wordt. In het geval van een sorteerfunctie zou je bijvoorbeeld kunnen zeggen dat je een functie wilt van type [a] → [a] uit bestand X. Dan kun je daarna dit bestand vervangen door een andere implementatie, waardoor je dus vrij eenvoudig een andere implementatie van dezelfde functie kunt gebruiken.

Type checking[bewerken]

Ervaring met het ontwikkelen van grote programma's heeft aangetoond dat het zeer handig is om het programma eerst te controleren voor het uit te voeren. Niet enkel kan de compiler de syntaxis controleren, maar er kan ook gecontroleerd worden of het wel zin heeft om een functie toe te passen op een bepaald argument (bv. een vierkantswortel nemen van een string heeft geen zin). Dit laatste wordt type checking genoemd. Enkele voorbeelden van programmeertalen die aan type checking doen zijn ML, Miranda, Haskell en natuurlijk ook Clean. De mogelijkheid om functies te definiëren die werken met andere functies en om functies als resultaat te hebben, is een belangrijke eigenschap van deze programmeertalen.[4]

Eigenschappen[bewerken]

Type checking van Clean garandeert dat runtime type errors niet zullen voorkomen. Dit elimineert de behoefte aan uitgebreide tests of het programma al dan niet vrij is van dit soort fouten. Type checking door de compiler is ook sneller en veiliger.

Samen maken deze eigenschappen het veel gemakkelijker om goede algoritmen te schrijven. Ook wordt het gemakkelijker om te begrijpen wat anderen geschreven hebben en om al bestaande functies te veranderen. Dit maakt functionele talen zoals Clean zeer geschikt voor evolutionaire ontwikkeling. Onderhoud wordt gemakkelijker en hergebruik is eindelijk mogelijk.

Voorbeelden[bewerken]

 square :: Int → Int
 square n = n * n

Lijn 1 duidt de types aan van de functie: integer als argument en integer als resultaat. Lijn 2 duidt aan hoe het resultaat berekend moet worden: vermenigvuldig het argument met zichzelf.

 fac :: Int →Int
 fac 0 = 1
 fac n = n * fac (n-1)

Lijn 2 wordt uitgevoerd wanneer het argument 0 is. Lijn 3 wordt uitgevoerd wanneer het argument iets anders dan 0 is.

 Start :: String
 Start = "Hello world"

De waarde van Start wordt getoond aan de gebruiker. Lijn 2 zorgt er dus voor dat Hello world op het scherm verschijnt.[8]

Zie ook[bewerken]

Externe links[bewerken]

Bronnen, noten en/of referenties
  1. a b c d FOLDOC (8 november 1995): 'Clean', FOLDOC, info verkregen op 8 november 2010.
  2. Wikipedia (21 oktober 2010): 'Functioneel programmeren', Wikipedia, info verkregen op 10 november 2010.
  3. Philippos Apolinario (z.j.): 'Programming in Clean', DISCENDA.org.
  4. a b Pieter Koopman, Rinus Plasmeijer, Sjaak Smetsers en Marko van Eekelen (2 september 2002): 'Functional Programming in CLEAN', Software Technologie, info verkregen op 5 november 2010.
  5. Clean (27 juli 2010): 'Clean', Clean
  6. Wikipedia (2 november 2010): 'Graph rewriting', Wikipedia, info verkregen op 10 november 2010.
  7. Wikipedia (28 oktober 2010): 'General purpose markup language', Wikipedia, info verkregen op 10 november 2010.
  8. Clean (27 juli 2010): 'Quick impression', Clean, info verkregen op 5 november 2010.