Back to site
Since 2004, our University project has become the Internet's most widespread web hosting directory. Here we like to talk a lot about web development, networking and server security. It is, after all, our expertise. To make things better we've launched this science section with the free access to educational resources and important scientific material translated to different languages.

Haskell programer

Evolucija jednog Haskell programera

Fritz Ruehr, Willamette University

Pogledajte Iavor Diatchki stranicu "The Evolution of a Programmer" za “original”( iako on nije autor stranice) i takođe pogledajte ispod za priču koja stoji iza ove verzije
 

Brucoš (Freshman) Haskell programer

fac n = if n == 0 
           then 1
           else n * fac (n-1)
 

Student druge godine (Sophomore) Haskell programer, na MIT-u

(studirao nacrt kao brucoš)
fac = (\(n) ->
        (if ((==) n 0)
            then 1
            else ((*) n (fac ((-) n 1)))))
 

Student treće godine (Junior) Haskell programer

(počinje sa Peano plejerom)
fac  0    =  1
fac (n+1) = (n+1) * fac n
 

Još jedan Junior Haskell programer

(pročitajte da su n+k obrasci “odvratni deo Haskell-a” [1]
i pridružite se pokretu- “Zabranite n+k obrasce” [2])
fac 0 = 1
fac n = n * fac (n-1)
 

Student zadnje godine (Senior) Haskell programer

(glasao za   Nixona   Buchanan   i Bush-a-”naginje u desno”)
fac n = foldr (*) 1 [1..n]
 

Još jedan Senior Haskell programer

(glasao za   McGovern   Biafra   Nader- “naginje u levo”)
fac n = foldl (*) 1 [1..n]
 

I još jedan Senior Haskell programer

(do sada je naginjao na desnu stranu ali se vratio levo ponovo!)
-- using foldr to simulate foldl

fac n = foldr (\x g n -> g (x*n)) id [1..n] 1
 

Мemoizing Haskell programer

(svaki dan uzima ginko bilobu)
facs = scanl (*) 1 [1..]

fac n = facs !! n
 

Besmisleni (ahem) Ԑoints-free Haskell programer

(studirao na Oksfordu)
fac = foldr (*) 1 . enumFromTo 1
 

Iterativni Haskell programer

(bivši Pascal programer)
fac n = result (for init next done)
        where init = (0,1)
              next   (i,m) = (i+1, m * (i+1))
              done   (i,_) = i==n
              result (_,m) = m

for i n d = until d n i
 

Iterativni jednolinijski Haskell programer

(bivši APL i C programer)
fac n = snd (until ((>n) . fst) (\(i,m) -> (i+1, i*m)) (1,1))
 

Akumulirajući Haskell programer

(gradeći do brzog vrhunca)
facAcc a 0 = a
facAcc a n = facAcc (n*a) (n-1)

fac = facAcc 1
 

Nastavljanje- Prolaženje (continuation-passing) Haskell programer

(u ranim godinama gajio zečeve zatim se preselio za Nju Džersi)
facCps k 0 = k 1
facCps k n = facCps (k . (n *)) (n-1)

fac = facCps id
 

Izviđač Haskell programer

(voli vezivanje čvorova; uvek pun poštovanja,
član je crkve najmanja fiksna tačka [8])
y f = f (y f)

fac = y (\f n -> if (n==0) then 1 else n * f (n-1))
 

Haskell programer kombinatorike

(izbegava varijabile, ako ne i zavaravanje;
sve ovo je samo fraza, mada retko otežava)
s f g x = f x (g x)

k x y   = x

b f g x = f (g x)

c f g x = f x g

y f     = f (y f)

cond p f g x = if p x then f x else g x

fac  = y (b (cond ((==) 0) (k 1)) (b (s (*)) (c b pred)))
 

Haskell programer za kodiranje lista

(preferira da računa u unarnom sistemu)
arb = ()    -- "undefined" is also a good RHS, as is "arb" :)

listenc n = replicate n arb
listprj f = length . f . listenc

listprod xs ys = [ i (x,y) | x<-xs, y<-ys ]
                 where i _ = arb

facl []         = listenc  1
facl n@(_:pred) = listprod n (facl pred)

fac = listprj facl
 

Haskell interpretativni programer

(nikad “nije sreo jezik” koji mu se nije dopadao)
-- a dynamically-typed term language

data Term = Occ Var
          | Use Prim
          | Lit Integer
          | App Term Term
          | Abs Var  Term
          | Rec Var  Term

type Var  = String
type Prim = String


-- a domain of values, including functions

data Value = Num  Integer
           | Bool Bool
           | Fun (Value -> Value)

instance Show Value where
  show (Num  n) = show n
  show (Bool b) = show b
  show (Fun  _) = ""

prjFun (Fun f) = f
prjFun  _      = error "bad function value"

prjNum (Num n) = n
prjNum  _      = error "bad numeric value"

prjBool (Bool b) = b
prjBool  _       = error "bad boolean value"

binOp inj f = Fun (\i -> (Fun (\j -> inj (f (prjNum i) (prjNum j)))))


-- environments mapping variables to values

type Env = [(Var, Value)]

getval x env =  case lookup x env of
                  Just v  -> v
                  Nothing -> error ("no value for " ++ x)


-- an environment-based evaluation function

eval env (Occ x) = getval x env
eval env (Use c) = getval c prims
eval env (Lit k) = Num k
eval env (App m n) = prjFun (eval env m) (eval env n)
eval env (Abs x m) = Fun  (\v -> eval ((x,v) : env) m)
eval env (Rec x m) = f where f = eval ((x,f) : env) m


-- a (fixed) "environment" of language primitives

times = binOp Num  (*)
minus = binOp Num  (-)
equal = binOp Bool (==)
cond  = Fun (\b -> Fun (\x -> Fun (\y -> if (prjBool b) then x else y)))

prims = [ ("*", times), ("-", minus), ("==", equal), ("if", cond) ]


-- a term representing factorial and a "wrapper" for evaluation

facTerm = Rec "f" (Abs "n" 
              (App (App (App (Use "if")
                   (App (App (Use "==") (Occ "n")) (Lit 0))) (Lit 1))
                   (App (App (Use "*")  (Occ "n"))
                        (App (Occ "f")  
                             (App (App (Use "-") (Occ "n")) (Lit 1))))))

fac n = prjNum (eval [] (App facTerm (Lit n)))
 

Statički Haskell programer

(on to radi sa svoji razredom, dobio je funkcionalnu nezavisnost od tog Jones-a!
Posle Thomas Hallgren-ov “ Zabava sa tom Funkcionalnom Zavisnošću” [7])
-- static Peano constructors and numerals

data Zero
data Succ n

type One   = Succ Zero
type Two   = Succ One
type Three = Succ Two
type Four  = Succ Three


-- dynamic representatives for static Peanos

zero  = undefined :: Zero
one   = undefined :: One
two   = undefined :: Two
three = undefined :: Three
four  = undefined :: Four


-- addition, a la Prolog

class Add a b c | a b -> c where
  add :: a -> b -> c
  
instance              Add  Zero    b  b
instance Add a b c => Add (Succ a) b (Succ c)


-- multiplication, a la Prolog

class Mul a b c | a b -> c where
  mul :: a -> b -> c

instance                           Mul  Zero    b Zero
instance (Mul a b c, Add b c d) => Mul (Succ a) b d


-- factorial, a la Prolog

class Fac a b | a -> b where
  fac :: a -> b

instance                                Fac  Zero    One
instance (Fac n k, Mul (Succ n) k m) => Fac (Succ n) m

-- try, for "instance" (sorry):
-- 
--     :t fac four
 

Postdiplomski student (Graduate) Haskell programer

(postdiplomsko obrazovanje da se oslobodi od sitnih briga, npr efikasnost
hardver-baziranih celih brojeva)
-- the natural numbers, a la Peano

data Nat = Zero | Succ Nat


-- iteration and some applications

iter z s  Zero    = z
iter z s (Succ n) = s (iter z s n)

plus n = iter n     Succ
mult n = iter Zero (plus n)


-- primitive recursion

primrec z s  Zero    = z
primrec z s (Succ n) = s n (primrec z s n)


-- two versions of factorial

fac  = snd . iter (one, one) (\(a,b) -> (Succ a, mult a b))
fac' = primrec one (mult . Succ)


-- for convenience and testing (try e.g. "fac five")

int = iter 0 (1+)

instance Show Nat where
  show = show . int

(zero : one : two : three : four : five : _) = iterate Succ Zero
 

Haskell Origamist programer

(uvek počinje sa osnovnim “Bird fold”)
-- (curried, list) fold and an application

fold c n []     = n
fold c n (x:xs) = c x (fold c n xs)

prod = fold (*) 1


-- (curried, boolean-based, list) unfold and an application

unfold p f g x = 
  if p x 
     then [] 
     else f x : unfold p f g (g x)

downfrom = unfold (==0) id pred


-- hylomorphisms, as-is or "unfolded" (ouch! sorry ...)

refold  c n p f g   = fold c n . unfold p f g

refold' c n p f g x = 
  if p x 
     then n 
     else c (f x) (refold' c n p f g (g x))
                         

-- several versions of factorial, all (extensionally) equivalent

fac   = prod . downfrom
fac'  = refold  (*) 1 (==0) id pred
fac'' = refold' (*) 1 (==0) id pred
 

Dekartovksi Haskell programer

(preferira Grčku hranu, izbegava začinjenu Indijsku hranu;
inspiriše ga “Sorting Morphisms” Lex Augusteijn-a [3])
-- (product-based, list) catamorphisms and an application

cata (n,c) []     = n
cata (n,c) (x:xs) = c (x, cata (n,c) xs)

mult = uncurry (*)
prod = cata (1, mult)


-- (co-product-based, list) anamorphisms and an application

ana f = either (const []) (cons . pair (id, ana f)) . f

cons = uncurry (:)

downfrom = ana uncount

uncount 0 = Left  ()
uncount n = Right (n, n-1)


-- two variations on list hylomorphisms

hylo  f  g    = cata g . ana f

hylo' f (n,c) = either (const n) (c . pair (id, hylo' f (c,n))) . f

pair (f,g) (x,y) = (f x, g y)


-- several versions of factorial, all (extensionally) equivalent

fac   = prod . downfrom
fac'  = hylo  uncount (1, mult)
fac'' = hylo' uncount (1, mult)
 

Haskell doktor programer

(pojeo je toliko banana da su mi oči iskočile, ali sada treba nova sočiva!)
-- explicit type recursion based on functors

newtype Mu f = Mu (f (Mu f))  deriving Show

in      x  = Mu x
out (Mu x) = x


-- cata- and ana-morphisms, now for *arbitrary* (regular) base functors

cata phi = phi . fmap (cata phi) . out
ana  psi = in  . fmap (ana  psi) . psi


-- base functor and data type for natural numbers,
-- using a curried elimination operator

data N b = Zero | Succ b  deriving Show

instance Functor N where
  fmap f = nelim Zero (Succ . f)

nelim z s  Zero    = z
nelim z s (Succ n) = s n

type Nat = Mu N


-- conversion to internal numbers, conveniences and applications

int = cata (nelim 0 (1+))

instance Show Nat where
  show = show . int

zero = in   Zero
suck = in . Succ       -- pardon my "French" (Prelude conflict)

plus n = cata (nelim n     suck   )
mult n = cata (nelim zero (plus n))


-- base functor and data type for lists

data L a b = Nil | Cons a b  deriving Show

instance Functor (L a) where
  fmap f = lelim Nil (\a b -> Cons a (f b))

lelim n c  Nil       = n
lelim n c (Cons a b) = c a b

type List a = Mu (L a)


-- conversion to internal lists, conveniences and applications

list = cata (lelim [] (:))

instance Show a => Show (List a) where
  show = show . list

prod = cata (lelim (suck zero) mult)

upto = ana (nelim Nil (diag (Cons . suck)) . out)

diag f x = f x x

fac = prod . upto
 

Post-Doktorski Haskell programer

(iz Uustale, Veneova i Pardova “Recursion Scheme from Comonads” [4])
-- explicit type recursion with functors and catamorphisms

newtype Mu f = In (f (Mu f))

unIn (In x) = x

cata phi = phi . fmap (cata phi) . unIn


-- base functor and data type for natural numbers,
-- using locally-defined "eliminators"

data N c = Z | S c

instance Functor N where
  fmap g  Z    = Z
  fmap g (S x) = S (g x)

type Nat = Mu N

zero   = In  Z
suck n = In (S n)

add m = cata phi where
  phi  Z    = m
  phi (S f) = suck f

mult m = cata phi where
  phi  Z    = zero
  phi (S f) = add m f


-- explicit products and their functorial action

data Prod e c = Pair c e

outl (Pair x y) = x
outr (Pair x y) = y

fork f g x = Pair (f x) (g x)

instance Functor (Prod e) where
  fmap g = fork (g . outl) outr


-- comonads, the categorical "opposite" of monads

class Functor n => Comonad n where
  extr :: n a -> a
  dupl :: n a -> n (n a)

instance Comonad (Prod e) where
  extr = outl
  dupl = fork id outr


-- generalized catamorphisms, zygomorphisms and paramorphisms

gcata :: (Functor f, Comonad n) =>
           (forall a. f (n a) -> n (f a))
             -> (f (n c) -> c) -> Mu f -> c

gcata dist phi = extr . cata (fmap phi . dist . fmap dupl)

zygo chi = gcata (fork (fmap outl) (chi . fmap outr))

para :: Functor f => (f (Prod (Mu f) c) -> c) -> Mu f -> c
para = zygo In


-- factorial, the *hard* way!

fac = para phi where
  phi  Z             = suck zero
  phi (S (Pair f n)) = mult f (suck n)
  

-- for convenience and testing

int = cata phi where
  phi  Z    = 0
  phi (S f) = 1 + f

instance Show (Mu N) where
  show = show . int
 

Redovni profesor

(predaje Haskell brucošima)
fac n = product [1..n]


 

Biografija

19. juna 2001 godine, na ОGI PacSoft Seminarima utorkom ujutru , Iavor Diatchki je predstavio rad “Recursion Schemes from Comonads” od strane Uustalu, Vene i Pardo [4]. Prisustvovao sam izvrsnoj prezentaciji i primetio sam da sam našao da je kraj rada više anti klimatski: nakon mnogo kategoričkog napora i definicija nekoliko opštih definicija rekurzije, glavni primeri su bili faktorijelne i Fibonači fukncije. ( Naravno, ni sam nisam ponudio bolje primere, tako da bi bilo nefer od mene da zakeram.)

Nešto kasnije, naišao sam na Iavor-ovu stranu sa šalama, uključujući i smešni deo zvan "The Evolution of a Programmer" u kojoj je tradicionalni imperativni program “Hello, world” razvijen pomoću nekoliko varijacija, od jednostavnog početka do smešno zakomplikovanog kraja. Trenutak za misao i pojavila se faktorijalna funkcija kao najbolji funkcionalni duplikat “Hello World” programa. Odjednom je “Muse” udario i ja sam znao da moram da napišem ove primere, kuliminirajući (ok, skoro) u teško generalizovanoj kategoričkoj verziji faktorijala obezbeđenog od strane Uustalu, Vene i Pardo-a.

Pretpostavljam da je ovo ono što bi nazvali humor za “malu publiku”.

PS: Ceo kod sam stavio u better-formatted text file za one koji bi hteli da eksperimentišu sa različitim varijacijama ( ili možete samo preseći i nalepiti sekciju iz vašeg pretraživača).

PPS: Kao što je rečeno iznad, Iavor nije originalni autor “The Evolution of a Programmer”. Brza pretraga na mreži sugeriše da ima na hiljade kopija koje kruže okolo i pojavljuju se (neatribuisani) u humor grupa vestima još od 1995 godine. Ali sumnjam da neke verzije datiraju i još kasnije od ovoga. Naravno, ako neko zna ko je napisao original, molim vas da me obavestite, da mogu da im odam počast ovde na stranici.


 

Narode, ali ozbiljno,...

Na ozbiljnijoj belešci, mislim da osnovna ideja šale ( sukcesivne varijacije na temu, složenost u izgradnji) može služiti kao dobar pedagoški cilj, baš kao i duhovitost i humor. U tom smislu, i za vas koji možda niste upoznati sa svim idejama prikazanim iznad, nudim vam sledeće komentare ovih varijacija:

Prva verzija (ravna rekurzija sa kondicionalima) je verovatno poznata programerima svih boja; fanovima LISP-a i Scheme-a će naći verziju studenta sa druge godine koja je posebno čitljiva, osim zbog smešnog spelovanja “lambda” i odsustvo “define” (ili “defun”). Upotreba obrazaca može izgledati kao malo pomeranje u perspektivi, ali pored ogledanja matematičkih notacija, obrasci ohrabruju pogled na tipove podataka kao inicijalni algebarski brojevi ( ili induktivno definisani).

Upotreba više “strukturnih” kombinacija rekurzije (kao što su foldr i foldl) je srce i duša funkcionalnog programiranja: ove funkcije višeg reda izvlače se od zajedničkih detalja različitih instanci definicija rekurzije, oporavljajući specifičnosti kroz funkcionalne argumente. Stil " points-free" (definiše funkcije bez eksplicitnih referenci do njihovih formalnih parametera) može biti nesavladiv, ali takođe može biti “prekuvan”; ovde je namera da se proriče slična upotreba u nekim o kasnijih, više oštrijih algebarskih varijacija.

Verzija аkumulirajućih parametara prikazuje tradicionalnu tehniku za ubrzavanje funkcionalnog koda. To je druga najbrža implementacija ovde, barem izmerena u uslovima brojeva redukcija, prijavljenih od strane Hugs-a, sa iterativnom verzijom koja dolazi na treće mesto. Iako je poslednji pokrenut nešto kao protiv duha funkcionalnog programiranja, on dodaje malo ukusa izjavama funkcionalnih simulacija kao što se koristi u označenoj semantici ili u tom slučaju u monadima. ( Monadi su žalosno izostavljeni ovde; Bio bih zahvalan ako neko može da doprinese sa par primera u duhu razvoja prikazanog iznad) Verzija continuation-passing se priseća denotacionog izveštaja kontrole ( reference su Steele RABIT kompajler za Scheme i SML/NJ kompajler).

Verzija fixed-point version demonstrira da možemo da izolujemo rekurziju u opštem Y kombinatoru. Verzija Kombinacijska obezbeđuje ekstremno preuzimanje point-free stila, inspirisanog od strane Kombinacijske Logike, izolaciona nezavisnost na promenjivim imenima nekoliko kombinatora. Naravno, mogli bi i još dalje da odemo, definišući Prirodne i Boleanske brojeve u uslovima kombinacija, ali zapazite da će se prethodna funkcija malo teže prilagoditi ( ovo je dobro opravdanje za algebarske tipove). Takođe primetite da ne možemo definisati Y kombinator u uslovima ostalih , bez naletanja na probleme u kucanju (u suštini zbog pitanja auto aplikacije). Interesantno, ovo je najbrža od svih implementacija, možda reflektujući fundamentalni mehanizam redukcije grafike koja se koristi u implementaciji.

Verzija kodriane liste eksploatiše prostu observaciju da možemo da računamo u unarnom sistemu, pomoću liste arbitražnih elemenata, tako da dužina liste kodira prirodni broj. U nekom smislu, ova ideja predskazuje kasnije verzije bazirane na definicijama rekurzivnog tipa za Peano prirodne brojeve, pošto su liste jedinica izomorfne za prirodne brojeve. Jedina interesnatna stvar ovde je da se množenje (numerički proizvod) vidi da prirodno nestaje iz kombinacije (Dekartvoski proizvod), prostom kardinalnošću. Kucanje pitanja otežava da se izrazi korespondencija tako direktno kao što bi mi želeli: sledeća definicija “listprod” bi razbila definiciju facl funkcije zbog “occurs-check” tipa.

listprod xs ys = [ (x,y) | x<-xs, y<-ys ]
Naravno da mi možemo takođe pojednostaviti kao što sledi, ali samo na račun skrivanja između dve vrste proizvoda:
listprod xs ys = [ arb | x<-xs, y<-ys ]

Verzija interpretacije implementira male jezičke objekte, dovoljno bogate da izraze faktorijal, i onda implementiraju tumača za to, bazirano na prostom modelu okruženja. Vežbe unutar tih linija prolaze sve kroz kasnije polovine Friedman-a, Wand-a i Haynes-a ([6]), iako se izrazio već u Scheme-i. Dobijali smo kritike od studenata na Oberlin kada smo im implementirali 12 tumača u jednonedeljnoj laboratoriji, sukcesivno izlažući većinu implementacija pomeranjem pravog rada sa meta-jezika do tumača. Ova implementacija ostavlja još mnogo toga na ramenima meta-jezika, odgovarajući do “O Sredi i Četvrtku” u njihovim radnim nedeljama. Marljivi čitači su pozvani da implementiraju kompajler za Squiggol-like jezik politipskih nabora i odvijača (folds, unfolds), ciljanja (i simualcija) pogodno kategoričke abstraktne mašine (vidi [9]), i onda implementirajte faktorijal na to mesto (ali ne krivite mene ako zakasnite na ručak....)

Verzija statički-kompjuterizovana koristi tipove klasa i funkcionalne zavisnosti da olakša računanje vremena kompiliranja (kasnije dolaze skorije ekstenzije za Haskell 98 standard od strane Mark Jones-a i dostupne su na Hugs i GHC). Iste vrste tehika se mogu koristiti takođe i za kodiranje ponašanja koje je često povezano sa zavisnim tipovima politipskog programiranja, i stoga su tema od velikog značaja u Haskell zajednici. Kod prikazan ovde je baziran na izveštaju Thomas Hallgren-a (videti [7]), i proširen je da uključi i faktorijal. Prolog fanovi će naći da je definicija jednostavna za čitanje, iako je malo nazadna).

Prva od "diplomiranihverzija postaje ozbiljnija po pitanju rekurzije, definišući prirodne brojeve kao rekurzivni algebarski tip podataka i naglašavajući razliku između iteracije i primitivne rekurzije. Varijacije kao npr:” origamist" I "dekartovski" prave mali korak unazad u tom pogledu, jer se vraćaju korišćenju internih celih brojeva i liste tipova. Međutim, oni služe za predstavljanje anamorfnih i hilomorfnih pojmova u više poznatom kontekstu.

"Dr” primeri upošljavaju kategorički stil od BMF/Squiggol na ozbiljan način ( mogli bi da odemo i malo dalje, korišćenjem ko-proizvoda više direktno, i na taj način eliminišemo neke od otvorenih zavisnosti na “internim sumama” mehanizma definicije tipova podataka).

Dok smo mi stigli na “komad otpora”, “ comonadic ” verzije od strane Vene i Pardo, pokrili smo većinu osnovnih ideja i možemo se (nadamo se) bolje koncentrisati na njihove specifične doprinose. Konačna verzija, pomoću Prelude-definisane proizvodne funkcije i elipsa notacija, tako ja mislim da je funkcija najjasnije izražena, pretpostavljajući neko znanje jezika i Prelude(Uvod) definicija. (Ova definicija takođe potiče od KRC* jezika David Turner-a [5].)

Utešno je znati da Prelude(Uvod) naposletku koriste kombinator rekurzije (foldl’, stroga verzija foldl) da definišu proizvod. Pretpostavljam da svi možemo da se nadamo da ćemo videti dan kada će Prelude definisati gcta amorfne, zigomorfne i paramorfne kombinatore za nas, tako da faktorijal može biti definisan i konvencionalno i sa većim dostojanstvom :).



 

Revizija Istorije

  • 20. avgust 01: dodata interpretivna verzija, bazirana na modelu okruženja jezika sa malim objektom (ne, ne u tom smislu objekta...). Mislim na preuređenju reda primera, tako da oni duži koji nisu deo glavne linije razvoja ne smetaju toliko. Takođe reklamiram stranicu na the Haskell Cafe mejling listi i zahtevao sam da link bude dodat do Haskell humor stranice. Konačno, imam zanimljivi novi primer u mojim radovima koji će možda imati neku originalnu istraživačku vrednost, više o tome uskoro.

  • 14 avgust 01 (afternoon): dodata kombinatorska verzija, trenutno najbrža od svih, izmerena u broju redukcija izveštaja od Hugs-a.

  • 14 avgust 01 (jutro): unapređena sophomore/Scheme verzija da koristi eksplicitni “lambda” (iako mi to drugačije spelujemo u Haskell zemlji) i dodata fixed-point verzija.

  • 10 avgust 01: dodata lista kodiranja i statički kompjuterizovana versions (kasnija izdanja koriste tipove klasa i funkcionalnu zavisnost da izračunaju faktorijal tokom tip-provere, to je proširena verzija koda iz Thomas Hallgren-ove “Fun with Functional Dependencies” [7]).

  • 1 avgust 01: dodata verzija аkumulirajućih parametara i continuation-passing verzija (potonja je revidirana transliteracija od Friedman-a, Wand-a i Haynes-a “Essentials of Programming Languages” [5]).

  • 11 jul 01: datum originalnog postavljanja.


 

Reference

  1. Highlights from nhc - a Space-efficient Haskell Compiler, Niklas Rojemo. In the FPCA 95 proceedings. ACM Press, 1995 (see also CiteSeer or Chalmers ftp archive)

  2. n+k patterns, Lennart Augustsson. Message to the haskell mailing list, Mon, 17 May 93 (see the mailing list archive)

  3. Sorting Morphisms,Lex Augusteijn. In Advanced Functional Programming, (LNCS 1608). Springer-Verlag, 1999 (see also CiteSeer).

  4. Recursion Schemes from Comonads, T. Uustalu, V. Vene and A. Pardo. Nordic Journal of Computing, to appear (see also Tarmo Uustalus papers page).

  5. Recursion Equations as a Programming Language, D. A. Turner. In Functional Programming and its Applications. Cambridge University Press, 1982.

  6. Essentials of Programming Languages, D. Friedman, M. Wand and C. Haynes. MIT PRess and McGraw-Hill, 1994.

  7. Fun with Functional Dependencies, Thomas Hallgren. Joint Winter Meeting of the Departments of Science and Computer Engineering, Chalmers University of Technology and Gateborg University, Varberg, Sweden, 2001 (available at the authors web archive).

  8. The Church of the Least Fixed-Point, authour unknown. (A little bit of lambda calculus humor which circulated in the mid-1980s (at least thats when I saw it), probably from the comp.lang.functional newsgroup or somesuch. Please write me if you know the author or any other citation information).

  9. Categorical Combinators, Sequential Algorithms and Functional Programming, Pierre-Louis Curien. Springer Verlag (2nd edition), 1993.


Published (Last edited): 01-04-2013 , source: http://www.willamette.edu/~fruehr/haskell/evolution.html