[Tutorial] Haskell part 1

[Glimi]

Welkom bij mijn intro over Functioneel programmeren. Dit heeft eerder in het abo forum gestaan, dus als je het daar al gelezen hebt, don't bother

Wat te vinden in deze introductie? (Klikbaar)

1. Wat is functioneel programmeren
   
2. Haskell
   
3. Types
   
4. Functies
   

Wat is functioneel programmeren
Functioneel programmeren gaat over het programmeren in functies. Ik heb al veel mensen gehoord die dan roepen "ow functioneel programmeren. In mijn C++ programma kan ik ook functies maken".
Err... Als het hetzelfde was geweest had het wel gelijk geheten toch? 'Functioneel' in 'Functioneel programmeren' staat namelijk voor het wiskundige begrip van een functie.

Een wiskundige functie is niets meer tussen de relatie tussen de parameters en het antwoord. Een wiskundige functie zal dan ook altijd hetzelfde antwoord geven bij dezelfde parameters. Dit in tegenstelling tot de meeste functies in imperatieve talen (C, C++, PHP, Java ed.), welke een output geven naar gelang de systeemtijd/ een globale variabele en allerlei andere invloeden van buiten de functie.

Haskell
Haskell is de taal die ik zal gaan gebruiken in deze introductie. Er zijn ook allerlei andere functionele talen, waarvan veel van het gezegde ook op zal gaan. Voorbeelden hiervan zijn Clean en Miranda

Haskell is een functionele taal met enkele mooie eigenschappen. Zo is Haskell type safe en heeft het lazy evaluation.

Type safe
Type safe betekend dat overal de types van gecontroleerd worden. Als een functie bijvoorbeeld een getal nodig heeft, dan is het niet mogelijk om daar een zin aan mee te geven. Immers met een zin is niet op te tellen en andere rekenkundige operaties, dus vandaar dat het een fout zal geven bij het draaien.

Bij type safe languages wordt dus bij het compileren gecontroleerd of het type van de parameters wel correct is. Als dat uitgesteld zou zijn tot run-time (als de functie gedraait wordt) dan kan er altijd nog in een hoekje van je programma een type fout zitten.
Type safe is dus een extra veiligheidscheck

Lazy Evaluation
Het woord zegt het eigenlijk al. Luie evaluatie. Kort gezegd kun je zeggen dat er pas wat uitgerekend zal worden als het echt niet anders meer kan.
Een voordeel daarvan is dat je bijvoorbeeld oneindige resultaten gebruikt kunnen worden!
Ik kan bijvoorbeeld de kop van een oneindige lijst getallen gaan pakken. Dit omdat haskell de getallen die ik toch niet gebruik, nooit zal uitrekenen.

Helium
In dit verhaal zal ik de Helium compiler gaan gebruiken. Dit omdat het een distributie is die speciaal gericht is op onderwijs, gratis is en klein om te downloaden. Deze distributie is geschreven door Arjan van IJzendoorn.

Omdat Helium toegespitst is op onderwijs en nog redelijk nieuw is, ondersteunt het nog geen type classes (kom ik later op terug) en optimaliseerd het erg weinig. Voor real life applicaties kun je dan nu ook nog beter GHC gebruiken.

Types
Eerder vertelde ik al dat Types belangrijk zijn voor de veiligheid van de applicatie. Alle variabelen moeten een type hebben voordat ze kunnen worden gecontroleerd. Omdat alles gecontroleerd wordt, moet dus alles moet een type hebben

In Haskell heb je 6 basistypes. Int, Float, Bool, , Char, Lijsten en Tupels

Int
Een Int is een geheel getal. Getallen als 3, 39, 4999 dus.

Float
Een gebroken getal. Getallen als 4.3, pi, 49999.0 ed

Bool
Een waarheidwaarde. Kan alleen True of False zijn.

Char
Een char is een teken. Bijvoorbeeld 'a', 'z', '2' of '@'. Een char staat altijd tussen enkele quotes

Lijsten
Een lijst is een verzameling van objecten van hetzelfde type. De notering ervan is door het omsluiten van vierkanten haken en scheiden met komma's.
Voorbeelden zijn dus [1,2,3,4], [True, False, True] en [4.3, pi] Deze verzamelingen mogen een variabele lengte hebben

Tupels
Een tupel is een beetje het omgekeerde van een lijst. Een tupel is een verzameling van een vaste lengte, zonder beperking van het type.
De notatie is dmv ronde haken en gescheiden met een komma
Voorbeelden (1, True), (True, 3.0, 1), (1,1,1)

Strings
Strings zijn geen echt datatypes in Haskell. Strings zijn simpelweg lijsten van Char's. Je kunt dus alle functies die je op lijsten kan toepassen, ook op Strings toepassen.

Functies
Nu we de basistypes weten, willen we nu gaan beginnen met het echte werk. Het creëren van die zgn. wiskundige functies. Laten we beginnen met een voorbeeld, welke ik dan zal uitleggen.

code:

discriminant            :: Int -> Int -> Int -> Int
discriminant a b c      = b*b - 4*a*c

Een functie hoort altijd uit 2 delen te bestaan. Bovenaan zien we de signature en daaronder zijn definitie

Signature
De signature vertelt hoe de functie in elkaar zit. De signature van discriminant zegt 4x Int met pijltjes ertussen. Dit betekend dat hij 3 Int waardes aanneemt als parameter en één Int als resultaat zal opleveren.
Dat klopt ook met de berekening van de discriminant als ik het goed heb

Andere voorbeelden van signatures zijn

code:

odd :: Int -> Bool

Odd bekijkt of een Int (zijn enige parameter) oneven is. Als dat zo is, zal odd een True opleveren, anders een False

code:

isUpper :: Char -> Bool

isUpper kijkt of een Char (zijn enige parameter) een hoofdletter is. Als dat zo is, zal isUpper een True opleveren, anders een False

code:

product :: [Int] -> Int

Neemt het product over een lijst van Ints. Bijvoorbeeld [1,3,5,8] zal (1*3*5*8) = 120 opleveren.

Definitie
In de definitie staat de werkelijke code, wat de functie zal gaan uitvoeren.
Dit is op te delen in 2 delen, gescheiden door het = teken.

Links van het = teken zien we staan discriminant a b c. Dit komt overeen met onze signature. We hebben nu alleen elke parameter een naam gegeven (namelijk a voor de eerste int, b voor de tweede int en c voor de derde)

Rechts van het = teken staat b*b - 4*a*c. Dit doet gewoon wat je er van verwacht, namelijk b kwadrateren en daar 4 maal ac van af trekken. Het antwoord hiervan, zal het antwoord van de functie worden

Hoe dit te maken in Helium?
Als je Helium geïnstalleerd hebt, krijg je als het goed is een snelkoppeling op je bureaublad (in Windows iig ). Start deze op en er zal een scherm verschijnen.

Zoals je ziet bestaat het scherm uit 2 delen. Het uitvoerscherm (het grote witte vlak) en het aanroepveld (het textveld onderin)
In het aanroepveld, roep je je functies aan en de output zal je zien in het uitvoerscherm.

Als je een functie wil definieren in Helium, zul je een Texteditor moeten pakken. Een die veel gebruikt wordt is ConTeXT. Deze ondersteunt nl. Helium syntax coloring, met de language file op de helium website.
Maar goed. Je opent dus de tekst editor.
Dan voer je je functie in. Neem bijvoorbeeld de functie discriminant en zet deze in de textfile. Sla dan de file op als [naamMetHoofdletter].hs

Vervolgens open je je juist gecreëerde hs file in Helium. Dit kan door in het menu File te kiezen voor Open Module. Dan kies je je hs file.
Helium zal dan je hs file gaan compileren. Een lvm file zal ontstaan, als alles goed gaat.

Om dan vervolgens discriminant aan te roepen, typ je 'discriminant' en daarachter 3 getallen (Int's) gescheiden dmv een spatie, in het aanroepveld. De uitvoer zal daarna in het uitvoerscherm terecht komen.

Predefined functies
Helium bevat een hoop voorgefinieerde functies. Hier staan ze allemaal Hieronder zal ik er een paar noemen zodat je zelf wat kunt gaan programmeren

Int functies

code:

+, - *  Plus, min en vermenigvuldigen
==      (Int -> Int -> Bool) vergelijk 2 Ints met elkaar
>=      (Int -> Int -> Bool) kijkt of de Int links groter of gelijk aan de Int rechts is
<=      (Int -> Int -> Bool) kijkt of de Int links kleiner of gelijk aan de Int rechts is
        NB. Je hebt ook de versies zonder = bij >= en <=, 
        deze controleren namelijk niet op gelijkheid
max     (Int -> Int -> Int) geeft de grootste van twee Ints terug
min     (Int -> Int -> Int) geeft de kleinste van twee Inst terug
odd     (Int -> Bool)       geeft aan of de Int oneven is
even    (Int -> Bool)       geeft aan of de Int even is

Float functies
Zie +, -, *, ==, >= en <= bij de Int functies, maar zet er dan een punt achter
Dit omdat Helium geen overloading (verschillende functies met gelijke namen) ondersteunt

Bool functies

code:

not     (Bool -> Bool)        draai de waarheidswaarde om. False wordt True, True wordt False
&&      (Bool -> Bool -> Bool)logische AND
||      (Bool -> Bool -> Bool)logische OR

Lijsten

code:

head    Geef het eerste element van de lijst
tail    Geef alle elementen van de lijst, behalve het eerste element
last    Geef het laaste element van de lijst
map     Voer een functie uit op een lijst
        Aanroep gaat volgens map functie lijst, waarbij functie op elk 
        element van de lijst uitgevoerd zal worden en het resultaat dus 
        een lijst met de antwoorden zal zijn
filter  filter alle elementen uit de lijst die niet aan de voorwaarde voldoen
        Aanroep gaat volgens filter voorwaarde lijst, waarbij de voorwaarde
        een functie van X -> Bool is, waarbij X gelijk moet zijn aan de
        elementen in de lijst
null    Geeft true als de lijst leeg is
length  Geeft een integer met de lengte van de lijst

Enige functies op Strings en Tupels mogen jullie zelf opzoeken in http://www.cs.uu.nl/~afie/helium/docs/TourOfPrelude.html .

End of story
Hiermee gaat het los. Ga zelf aan de slag met dingentjes proberen ed.
Volgende keer zal ik dieper overal op in gaan. Ik zal dan gaan kijken hoe lijsten in elkaar zitten, wat functies nou precies doen, wat partieel parameteriseren is en operator's gaan behandelen.
Vragen/opermkingen kunnen via ICQ/Mail en hier

[ Voor 104% gewijzigd door Glimi op 02-06-2003 15:47 ]

[Verwijderd]

Leuk!!!

[Skinkie]

kunnen we binnen kort ook een tutorial APL verwachten? Uiteraard met keyboard mods en de hele ratteplan?
That's gonna be fun

[whoami]

Wat is het toepassingsgebied eigenlijk voor functioneel programmeren? Volgens mij is dat vooral iets voor mensen die veel met wiskunde bezig zijn enzo...
Ik zie mijzelf nog niet direct aan functioneel proggen, aangezien ik niet denk dat ik dat ooit nodig zal hebben...

[Verwijderd]

functioneel programmeren: ALLES IS EEN FUNCTIE!

1 is een functie die zonder argument een waarde 1 oplevert .. (1::Nat) waarom is dit feit nuttig om in te zien? Dit geeft je meer inzicht in waarom '(+)::Nat->Nat->Nat' en '((+)1)::Nat->Nat'. Let op, ik maak hier van de + wat een infix functie is een prefix functie door er haken omheen te zetten. Door de + functie een onvolledig aantal argumenten te geven heb ik in feite een nieuwe functie gemaakt die gelijk staat aan:

code:

plus1::Nat->Nat
plus1 n = n+1

Nuttig voor als ik het volgende wil doen:

code:

xs=[1,2,3,4,5,6]
map ((+)1) xs
filter ((>)1) xs

het echte verschil tussen een functionele taal een een imperatieve taal is dat we geen variabelen kennen, alleen maar functies. En we functies op elkaar los laten om een programma te bouwen. Misschien lijkt de xs in het stukje hierboven een variabele, maar in feite is het een functie dat geen argument verwacht en altijd [1,2,3,4,5,6] oplevert.

En nu komen we dan bij de referente transparatie terecht (alles levert dezelfde waarde op bij zelfde aanroep), omdat functies alleen via argumenten werken, en nooit via globale variablen of andere 'enge' dingen worden beinvloed, zijn functies in functionele talen altijd referent transparant, dit in tegenstelling tot imperatieve talen, waar functie ook bij globale variabelen kunnen komen. Moeilijk wordt het echter voor interactieve functies die input vragen van de gebruiker .. die zijn niet referent transparant, immers de gebruiker kan steeds iets anders invullen .. gelukkig hebben we hier wel oplossingen voor bedacht ..

[MisterData]

Leuk die tutorial! Geweldig dat er nog mensen zijn die daarvoor tijd hebben/maken In de Ct van een paar maanden geleden stond ook al een artikel over Clean, een vergelijkbare taal.

* MisterData wacht met smart op deel 2

[TD-er]

Op de uni gebruiken we Hugs om Haskell progsels te runnen.
@Ozymandias: Mischien handig als je ook ff uitlegd wat je programmatje doet, want ik neem aan dat de meeste mensen hier niet meteen begrijpen wat map en filter doen

code:

xs=[1,2,3,4,5,6]
map ((+)1) xs
filter ((>)1) xs

In de eerste regel wordt het rijtje getallen 1 .. 6 xs genoemd.
In de 2e regel voert map op elk getal in de array de operatie (+)1 uit, oftewel we krijgen dan het rijtje [2,3,4,5,6,7]
Nu laat mijn geheugen me even in de steek of het zo ook in de array xs wordt opgeslagen of niet (dacht van niet)
De operatie filter kijkt welke waarden aan het kriterium voldoen (kriterium is eerste parameter, hier dus (>)1 )

@TS: het is enige, niet enigste

[Verwijderd]

Inderdaad erg leuk, maar net als whoami vraag ik me af waar je het voor kunt gebruiken.

[Glimi]

Verwijderd schreef op 05 mei 2003 @ 16:12:

Waarom (+) 1 ipv 1+, dan heb je net zo hard dezelfde geparameteriseerde functie?

TD-er schreef op 05 May 2003 @ 16:33:
@TS: het is enige, niet enigste

Ik vind 1 spelfout op zoveel regels nog best wel hip

[ Voor 35% gewijzigd door Glimi op 05-05-2003 18:21 ]

[Verwijderd]

@Glimi

Waarom (+) 1 ipv 1+, dan heb je net zo hard dezelfde geparameteriseerde functie?

tja, ik ben niet zo bedreven in Haskell, echter wel in functioneel programmeren. De ene taal kan dat soort dingetjes de andere niet en ik had geen zin om het echt live uit te proberen voordat ik ging posten .. want officieel levert 1+ namelijk niet een nieuwe functie op, immers je laat + (::Nat->Nat->Nat) los op 1 (::Nat) met 1 + en dat is een syntax error, behalve als de taal (Haskell dus) slim genoeg is om eerst de prefix/infix rommel weg te werken, alvorens het statement verder te evalueren, dus in feite eerst de 1+ om te schrijven naar + 1 ...

@whoami
Tja, waarvoor? Eigenlijk is het alleen leuk voor mensen die er een beetje in bedreven zijn. Je kunt er namelijk heel gemakkelijk typische wiskundige vraagen mee oplossen danwel bewijzen. Veel raadseltjes kun je bijvoorbeeld erg snel en elegant oplossen in een functionele taal als je er een beetje bedreven in bent. Of neem de berekening van (alle) priem getallen, slechts 1 regeltje in haskell:
'sieve (x:xs) = x:sieve [c|c<-xs, mod c x > 0]'
nouja, je moet hem nog aanroepen via: 'sieve [2..]'. Maar dat doe je in een imperatieve taal niet na!

Een echt praktisch nut is verder weg, maar soms wordt een functionele taal gebruikt om de programmeurs te dwingen minder fouten te maken, als ik me niet vergis is erlang ontwikkeld om telefooncentrales mee te bouwen; Telefooncentrales mogen slechts 1 keer down zijn in 40 jaar.

[Verwijderd]

Ey gaaf. Ik heb op de uni net lambda-calculus gehad, leuk en toevallig dat je net deze intro schreef

Ik weet bijna zeker dat ik er anders zo langs gelezen zou hebben

[licensed]

Haskell is echt fantastisch! Op de uni hebben we een vak 'Functioneel programmeren' gehad. Echt heel leuk.

Aanrader: "Haskell, the craft of functional programming 2nd edition" ISBN 0-201-34275-8

Hier een progsel dat ik in Haskell gemaakt heb:

Haskell:

type Table = (String , [String] , [[String]])

top10 = 
  ( "Top10"
  , [ "Nr","Artiest", "Liedje" ]
  , [ [ "1", "Shakira", "Whenever Wherever" ]
    , [ "2", "Marco en Sita", "Lopen op het water" ]
    , [ "3", "Pink", "Get the Party Started" ]
    , [ "4", "Within Temptation", "Ice Queen" ]
    , [ "5", "Linkin Park", "In the End" ]
    , [ "6", "Gigi d'Agostino", "L'Amour Toujours" ]
    , [ "7", "Nelly Furtado", "Shit on the Radio" ]
    , [ "8", "Nickelback", "How You Remind Me" ]
    , [ "9", "Alanis Morissette", "Hands Clean" ]
    , [ "10", "Kane", "Let It Be" ]
    ]
  )

herkomst =
    ( "Herkomst"
    , [ "Artiest", "Land" ]
    , [ [ "Marco en Sita", "Nederland" ]
      , [ "Marco en Sita", "Italie" ]
      , [ "Alanis Morissette", "Canada" ]
      , [ "Kane", "Nederland" ]
      , [ "Within Temptation", "Nederland" ]
      , [ "Shakira", "Colombia" ]
      , [ "Pink", "Verenigde Staten" ]
      ]
    )

lengthTable :: [[String]] -> Int -> Int
lengthTable [] n = 0
lengthTable (a:k) n = max (length (a!!n)) (lengthTable k n)

colWidth :: Table -> Int -> Int
colWidth (t, tn, r) n = max (length (tn!!n)) (lengthTable r n)

allColWidth :: Table -> Int -> [Int]
allColWidth t 0 = [(colWidth t 0)]
allColWidth t n = ((allColWidth t (n-1)) ++ [(colWidth t n)])

sumWidth :: [Int] -> Int
sumWidth [] = 1
sumWidth (a:k) = a + 1 + (sumWidth k)

showTable :: Table -> String
showTable (t, tn, r) = t ++ ":\n" ++ (showRow tn ar) ++ (replicate ...
(sumWidth ar) '-') ++ "\n" ++ (showData r ar)
    where ar = (allColWidth (t, tn, r) ((length tn)-1))

showRow :: [String] -> [Int] -> String
showRow [] [] = "|\n"
showRow (a:k) (b:l) = "|" ++ a ++ (replicate(b-(length a)) ' ') ++ (showRow k l)

showData :: [[String]] -> [Int] -> String
showData [] l = ""
showData (a:k) l = (showRow a l) ++ (showData k l)

giveNumber :: [String] -> [String] -> [Int]
giveNumber [] l = []
giveNumber (a:k) l = (giveIndex a l 0):(giveNumber k l)

giveIndex :: String -> [String] -> Int -> Int
giveIndex s [] x = x
giveIndex s (a:k) x
  | s == a = x
  | otherwise = (giveIndex s k (x+1))

listIndices :: [Int] -> [String]  -> [String]
listIndices [] l = []
listIndices (a:k) l = (drop a (take (a+1) l)) ++ (listIndices k l)

filterData :: [Int] -> [[String]] -> [[String]]
filterData l [] = []
filterData l (a:k) = (listIndices l a) : (filterData l k)

project :: [String] -> Table -> Table
project l (t, tn, r) = (t, (listIndices gn tn), (filterData gn r))
               where gn = (giveNumber l tn)

select :: String -> (String -> Bool) -> Table -> Table
select s f (t, tn, r) = (t, tn, (selectData r (giveIndex s tn 0) f))

selectData :: [[String]] -> Int -> (String -> Bool) -> [[String]]
selectData [] x f = []
selectData (a:k) x f
  | (check f (listIndices [x] a)) = a : (selectData k x f)
  | otherwise = (selectData k x f)

check :: (String -> Bool) -> [String] -> Bool
check f [a] = f a

findEqual :: [String] -> Int -> [String] -> Int -> (Int, Int)
findEqual s x t y
  | (s !! x) == (t !! y) = (x,y)
  | y == ((length t) - 1) = (findEqual s (x+1) t 0)
  | otherwise = (findEqual s x t (y+1))

joinRecords :: [[String]] -> [[String]] -> Int -> (Int, Int) -> [[String]]
joinRecords [] l n (x,y) = []
joinRecords (a:k) l n (x,y)
  | n == (length l) = joinRecords k l 0 (x,y)
  | (a !! x) == (d !! y) = (a ++ ((take y d) ++ drop (y+1) d)) :  ...
(joinRecords (a:k) l (n+1) (x,y))
  | otherwise = (joinRecords (a:k) l (n+1) (x,y))
        where d = (l !! n)

join :: Table -> Table -> Table
join (t1, tn1, r1) (t2, tn2, r2) = ("(" ++ t1 ++ " join " ++ t2 ++ ")",  ...
tn1 ++ ((take y tn2) ++ (drop (y+1) tn2)), (joinRecords r1 r2 0 (x,y)))
                   where (x,y) = findEqual tn1 0 tn2 0

query = project ["Land"] (select "Nr" eersteDrie (join top10 herkomst))
    where eersteDrie string = read string <= 3

3 x raden wat het voorstelt

[Glimi]

licensed schreef op 05 May 2003 @ 18:29:

Een soort SQL implementatie
Volgens mij heb ik die hier ook nog wel liggen hoor

[licensed]

Glimi schreef op 05 mei 2003 @ 18:38:
[...]

Een soort SQL implementatie
Volgens mij heb ik die hier ook nog wel liggen hoor

Dan studeer je in Groningen of Utrecht ?

[Infinitive]

Type safe

Interessanter is om te zeggen dat Haskell een type checker heeft die op compiletime controleert of de programmacode type correct is en bovendien van veel correcte programma's deze typen zelf kan afleiden, zonder tussenkomst van de gebruiker. Onder de definitie van type safe vallen ook talen waar de controle slechts op runtime gedaan wordt.

Definitie van een type onder haskell

Je hebt basistypen en samengestelde typen. En type classes die hier een predicaat over gooien. Mocht iemand ooit "Learning functional programming through multimedia" van Paul Hudak lezen, dan vind je in appendix A wel een leuk stukje text: "Built-in types are not special.".

kunnen we binnen kort ook een tutorial APL verwachten?

Staat er geen dictaat op de website van de Universiteit Utrect?

Wat is het toepassingsgebied eigenlijk voor functioneel programmeren? Volgens mij is dat vooral iets voor mensen die veel met wiskunde bezig zijn enzo... Ik zie mijzelf nog niet direct aan functioneel proggen, aangezien ik niet denk dat ik dat ooit nodig zal hebben..."

Als mensen het over programma transformaties hebben, hebben ze het ook vaak over functionele talen. Of voor bijvoorbeeld prototyping (Haskell als specificatie taal). Op Haskell.org staan volgens mij ook een aantal projecten waar Haskell voor gebruikt wordt.

[TD-er]

@licenced: He ik heb in het eerste trimester tegelijk met jou Functioneel gevolgd
@infinitive: leuke sig voor dit onderwerp Heb je die formule gevonden met een programmatje wat je bij Numeriek moest maken, of gewoon met Mathematica?

[Verwijderd]

licensed schreef op 05 mei 2003 @ 18:57:
[...]

Dan studeer je in Groningen of Utrecht ?

Utrecht, onze opdracht kwam ook uit Utrecht dus dat kan kloppen Overigens is functioneel programmeren idd erg leuk, alleen heb ik het nog nooit IRL kunnen toepassen.

[ Voor 20% gewijzigd door Verwijderd op 05-05-2003 19:44 ]

[Eelis]

.

[ Voor 99% gewijzigd door Eelis op 18-02-2015 19:42 ]

[mbravenboer]

Infinitive: Staat er geen dictaat op de website van de Universiteit Utrecht?

Inderdaad: http://www.cs.uu.nl/~jeroen/

[Skinkie]

mbravenboer schreef op 05 mei 2003 @ 20:48:
[...]

Inderdaad: http://www.cs.uu.nl/~jeroen/

Ben ik scheel of staat APL daar niet tussen, want daar dacht ik dat hij op reageerde met de vraag of het op de website stond.

[Infinitive]

@infinitive: leuke sig voor dit onderwerp Heb je die formule gevonden met een programmatje wat je bij Numeriek moest maken, of gewoon met Mathematica?

Dat was mijn eerste Haskell programmatje die ik ooit geschreven heb.
Als ik die nu weer terug zie dan schaam ik me

[mbravenboer]

Skinkie: Ben ik scheel of staat APL daar niet tussen, want daar dacht ik dat hij op reageerde met de vraag of het op de website stond.

Hum ja, ik zie het nu. Niet goed gelezen .

[Verwijderd]

mbravenboer schreef op 06 May 2003 @ 09:24:
[...]

Hum ja, ik zie het nu. Niet goed gelezen .

Nog veel erger, ik had het verkeerde stukje gequote