Vilket funktionellt språk?

Själv dyrkar jag O'Caml (Objective Caml). Syntaxen är ren (när man vänjer sig) och språket är kraftfullt. Dessutom är det mysigt att kunna blanda tre paradigmer (funktionellt, imperativt och objektorienterat) samt kunna köra det interprenterat, bytecode-kompilerat eller binärkompilerat.
Att det sedan kommer i närheten av C i hastighet när det gäller vissa saker gör ju inte saken sämre.

Visst, det är inget renrasigt funktionellt språk, men det är förbannat trevligt att arbeta med. Mitt favorit-"generic-språk".

Har inte kodat några andra funktionella språk (med undantag för ytterst lite Lisp och Scheme) så jag kan inte uttrycka mig så mycket om andra, tyvärr.

Haskell Eftersom det är det enda funktionella språket jag kodat i så kan jag inte påstå att jag vet om det är det mest lämpliga för att lära sig, men det är iaf en upplevelse, som gav mig en inte alltför vanlig känsla av ångestglädje-intresse
Kommer prova på Ericsson Erlang inom några veckor och det ska bli mycket intressant.

Finns många fina funktionella språk. Jag kommer dock rekommendera Scheme för då får du en ursäkt att läsa den bästa datavetenskapliga boken som någonsin skrivits: Structure and Interpretation of Computer Programs

Boken finns även online (fast är annars inte så dyr): http://mitpress.mit.edu/sicp/full-text/book/book.html

Prolog kan vara värt att ta en titt på om man vill programmera AI.

http://en.wikipedia.org/wiki/Prolog#Programming_in_Prolog

Scheme är en Lisp.

Ruby är en acceptabel Lisp.

Lisp är nog inte så dumt, men man kanske blir lite besvärad av alla () i början innan man har vant sig, då föredrar jag helt klart Haskells lösning på det istället med betydelsefulla whitespace. Så mitt förslag är Haskell (som används som intro till funktionell programmering på iaf Chalmers om du tyckte högskolespråk var intressantast). Sen är Scheme tänkt att vara väldigt "enkelt", har ju tagits upp här på swec några gånger hur liten hela specefikationen på språket är.

Men båda är iaf rena, till skillnad mot OCaml, och det kanske är en fördel i början så du blir tvingad in i det funktionella tänket. Eller så är det en nackdel om du vill mjukstarta..

(Om du funderar på pokerAI-tävligen så är Haskell en fördel då iaf 2 (en är jag) sagt att dom tänkt skriva i Haskell, så det kan ju vara fördel även om det säkert inte blir någon tok-djup AI).

Jag tycker Scheme - för det är så litet och enkelt. Man lär sig det på några timmar, typ. Inte riktigt, men nästan. Så kan man lägga all tid på att programmera istället för att slå upp syntaxen.

Annars Haskell, men det är mera att lära sig. Men det är väldigt snyggt och elegant. På Chalmers är Haskell mycket använt, tror jag.

Men funktionella språk är bra att ha tittat på.

Tja, även om O'Caml kan kodas imperativt och OO så måste man det inte.
Jag undviker den imperativa funktialiteten för det mesta (gäller dock att koll på vad som är imperativt i språket för det). Ibland är det dock bekvämt.

Men visst, vill man vara säker på att lära sig riktig funktionell programmering så underlättar det ju med ett språk som inte har något sådant.

Personligen tycker jag sml är väldigt mysigt. Funktionella språk var väldigt läskigt för mig i början, men när man började förstå hur kraftfullt rekursion och liknande är kan man inte sluta älska det.

Jag hade för mig att logikprogrammering ska vara bra för AI, men om man inte ska göra så otroligt avancerad AI går nog de flesta språken bra.

Prolog är dock ett logiskt språk, inte ett funktionellt.

Tur att nån är vaken...

Lite introföreläsningar som både tar upp funktionell och logisk programmering(real player):

http://webcast.berkeley.edu/course_details.php?seriesid=19069...

Ett coolt språk som inte har nämts är Clean:
http://clean.cs.ru.nl/About_Clean/about_clean.html

Det som är coolt med Clean (jag har tyvärr inte provat det själv ännu) är att det har lat evaluering men lyckas gömma latheten på något vis så att man kan uttrycka sig i det på vanligt sätt med tilldelningar och andra destruktiva operatorer. Det är vad de påstår iaf. I andra lata språk som t.ex. Haskell blir I/O och liknande i grunden imperativa uppgifter väldigt knöliga.

Jag skulle hur som helst helt klart rekommendera dig ett språk med lat evaluering. Detta eftersom du i andra funktionella språk visserligen kan uttrycka dig på ett rent och tydligt vis (funktionellt, dvs utan sidoeffekter), men där drabbas av negativa effekter på prestanda om du använder dig av denna programmeringstil. Om du t.ex. vill utföra två väsensskilda beräkningar på en datastruktur så vill du antagligen lägga dessa beräkningar i olika funktioner. Om du applicerar dem i tur och ordning på datastrukturen i ett språk utan lat evaluering så kommer datastrukturen att gås igenom två ggr, men med lat evaluering kommer kompilatorn förhoppningsvis att kunna väva ihop bägge operatiorna och nöja sig med att traversera strukturen en gång. Du kan alltså separera delar som ska vara separerade, medans du i språk som Scheme eller Java hade varit tvungen att slå ihop bägge funktionerna Foo och Bar till en funktion DoFooAndBar() för att undvika att behöva gå igenom datastrukturen två gånger.

Jag hade nog valt Haskell, Clean eller Scheme (om jag inte redan kunde Scheme). Scheme är ganska coolt eftersom det är så lätt att experimentera och bygga egna språkkonstruktioner i. Schemes regelbundna syntax (eller brist på syntax över huvud taget) gör det lättare att skriva kraftfulla macron som skriver om kodsnuttar till andra kodsnuttar. Där har Scheme ett övertag mot andra funktionella språk.

En annan cool grej med Haskell är pattern matching. Det kan du iofs få i andra funktionella språk också (i många scheme'ar och i OCaml iaf), men jag har fått för mig att det funkar som bäst i Haskell. Kanske funkar lika bra i OCaml dock, jag vet inte säkert.

Något jag missade förut med O'Caml som (jag tycker) är coolt är att det är starkt typat. Man kan inte blanda datatyperna, eller casta dem.

Betrakta detta:

# 1 = 1.0;;

i andra språk hade detta returnerat true, eftersom att 1 är detsamma som 1.0. Men inte i O'Caml:

# 1 = 1.0;;
This expression has type float but is here used with type int

Självklart gäller detsamma vid andra operationer, som addition, subtraktion, multiplikation, division, osv.

Finns dock lite smågenvägar, som funktionen (detta är något annat jag gillar med O'Caml, dess sätt att beskriva funktioner)

val int_of_float -> float -> int

Så visst, med lite vilja går det att "blanda", men det går inte utan att omvandla värden först.

Jag själv älskar detta, ger en mer robust känsla på något vis.
Självklart är inte det här något nytt koncept, men det är ändå trevligt, och i kombination med O'Caml så blir det ännu trevligare.

EDIT: Hmm, kom just på att Haskell också är starkt typat, om jag inte minns fel?

sml är mysigt, precis som OCaml.
Båda är ju ML-varianter så det känns rätt lika, fast OCaml är lite bättre (som sagt prestanda). Utna någon riktig pluggande (bara lite uppslag av syntax) lyckades jag snabbt få ihop ett OCaml-program för att lösa lite problem på mathchallenge, bara genom att kunna SML.

AI finns det ju många olika saker som behövs olika saker för. För att bevisa logiska satser osv kan jag tänka mig logikspråk är utmärkt till, för andra uppgifter kan man ju ha expert system (som en miljö) att arbeta i.

På det hela så är det så jäkla intresseant med andra paradigmer och andra sätt att lösa problemen. Man inser att procedurprogrammering som C är "skitigt".

Lisp är ju parantesernas språk, jäkligt kraftfullt vad det gäller listor.

Prolog är oerhört trevligt och har fina möjligheter för att parsa naturliga språk (den typen som människor använder för kommunikation alltså), använde det när jag läste en kurs i språkbehandling och datalingvistik.

Det första funktionella språket som jag lärde mig var SML (Standard ML, googla), enkelt och trevligt.

(define (cube x)
  (* x (* x x)))

(define (isCubeMod tal ref inc)
  (cond
    ((= inc 0) (isCubeMod tal ref 1))
    ((= inc 1) (cond
                 ((< (cube ref) tal) (isCubeMod tal (+ ref inc) inc))
                 ((= (cube ref) tal) #T)
                 ((> (cube ref) tal) #F)))
    ((< (cube ref) tal) (isCubeMod tal (+ ref inc) inc))
    ((> (cube ref) tal) (isCubeMod tal (- ref inc) (floor (/ inc 3))))
    ((= (cube ref) tal) #T)))

(define (isCube tal)
  (isCubeMod tal 0 tal))

Hmm, var det inte då man skrev Lambda eller nåt?
Kolla boken Psionicist länkade till.

Den boken är jävligt bra. Då menar jag jävligt bra. Den ska läsas.

Jo precis, anledningen till att jag syslat med sml (eller moscow sml) är att det lärs ut på den utbildningen jag går, men OCaml verkar ju användas mer i "verkligheten" så att säga =).

Jag läste Haskell (LTU) och tyckte det var lärorikt, fast det är väl inget jag skulle vilja koda något stort i direkt
Mycket bra grejer som list comprehension, map och whatnot finns ju med i python också dock så det följer ju med den vägen