Haskell AND Lisp vs. Haskell OR Lisp [gesloten]

Ik stel voor om beide te leren, eerst Haskell en dan Common Lisp. Mijn ervaring met Haskell was dat het statische typen aanvankelijk een beperkende ergernis leek, maar toen ik er eenmaal aan gewend was, merkte ik dat er bij de meeste van mijn typefouten logische fouten schuilgaan. Wanneer je op dit punt komt, en de volgende mijlpaal, namelijk leren denken in typen en je eigen typen definiëren als een middel om je oplossing uit te drukken, ben je klaar voor Common Lisp.

Met Common Lisp, je kunt monaden, currying en alles wat je leuk vindt van Haskell toevoegen, maar je krijgt ook meerdere overervingen, zoals Frank Shearar al zei, en generieke functies met meervoudige verzending en een geavanceerd systeem voor het afhandelen van uitzonderingen.

Dus waarom niet alleen eerst Common Lisp leren? Omdat ik uit een procedurele en OOP-achtergrond kom, is mijn ervaring dat ik functioneel programmeren pas echt begreep als ik het exclusief moest gebruiken. Zodra functioneel programmeren comfortabel is, kunt u de rest van de tools die Common Lisp beschikbaar stelt, toevoegen en de tool gebruiken die het beste bij de taak past.

Reacties

• Ik denk dat je het goed hebt gedaan – wat Haskell en Smalltalk zo nuttig maakt om te leren, is hun puurheid.
• Ik ben het eens met de zuiverheid maakt het leren van een taal een stuk gemakkelijker. Ik kon ' de functionele taal zelf niet begrijpen met LISP omdat alles mogelijk is in de taal en ik te veel dwingende, OO-achtergrond heb. Maar in Haskell zijn er geen dergelijke concepten die het leren verstoren.
• Het ' is grappig, ik ' ve had de tegenovergestelde ervaring. Ik leerde de belangrijkste punten van functioneel programmeren via Scheme, mijn eerste taal. Ik hack af en toe Haskell en het is onvermijdelijk dat ik 90% + van de dingen die ik kende opnieuw moet leren wanneer ik Haskell een tijdje verlaat. Dat gezegd hebbende, Haskell is een ongelooflijk rijke taal, met een enorme hoeveelheid om je (zeer krachtig) te leren Typen Typen Typen Typen! Volg de typen!

EN alsjeblieft.

Haskell leert je de puurste van FP, voor zover ik weet tenminste, net zoals Smalltalk de puurste OO onderwijst. (ik noem dit niet om te suggereren dat OO en FP niet kunnen trouwen, maar omdat beide talen edelsteen-talen zijn – een kernidee tot het uiterste doorgevoerd.)

Lisp is echt een talenfamilie, dus ik zal het hebben over Common Lisp omdat dat het specifieke lid van de familie is dat ik gebruik.

Lisp zal je nog veel leren:

• Het is multiparadigma, dus zoals dsimcha aangeeft zal het je laten zien hoe FP met andere paradigmas te integreren.
• Lisp zal je leren dat “code-is-data, data-is-code”, bijvoorbeeld door middel van zijn macros.
• CLOS is een zeer interessant merk van OO, met meerdere overerving die werkt, en generieke functies.

Haskell en Lisp zijn twee totaal verschillende beesten.

Haskell is een soort “puur functioneel programmeren in een ivoren toren”.

Lisp is een soort “code-is-data / data-is-code / maak je eigen taalconstructies”. Je kunt je code op elke manier manipuleren die je maar kunt bedenken.

Ze zijn heel verschillend. Beiden delen het aspect “functioneel programmeren”, maar dat is eigenlijk een heel klein gemeenschappelijk punt vergeleken met hun verschillen. Probeer ze gewoon uit en je zult zien hoe verschillend ze zijn!

Opmerkingen

• +1: Goed punt. Ik ken een paar Haskell en een beetje Lisp. Ook al ben ik geen expert in een van beide, ik denk dat je gelijk hebt dat ze heel verschillend zijn. In Haskell heb je heb niet het idee om gegevens als code te gebruiken. In Lisp heb je geen (AFAIK) patroonovereenkomst. Waarschijnlijk is de lijst (!) met verschillen langer.

Door Lisp later te leren, kun je Emacs aanpassen, wat misschien wel de meest geavanceerde teksteditor is die er is. Dat kun je niet doen in Haskell.

Opmerkingen

• [Verscherpt zijn haakjes]
• Misschien kan iemand er een teksteditor voor schrijven. Ik heb gehoord dat het Emacs-besturingssysteem er geen ' mee heeft. (Ik maak een grapje. Ik weet dat je de Viper-modus kunt krijgen. 🙂
• Eigenlijk is er een Emacs-kloon genaamd Yi, die Haskell op precies dezelfde manier gebruikt als Emacs Lisp gebruikt.In feite is Yi, vergeleken met (GNU) Emacs, nog puurder, omdat de kernel ook in Haskell is geschreven, terwijl Emacs-kernels over het algemeen niet in Lisp worden geschreven. GNU Emacs ' kernel is geschreven in C, JEmacs ' is bijvoorbeeld geschreven in Java.
• @J ö rg, als het een gedeeltelijke herimplementatie is in plaats van een volledige kloon van GNU Emacs of XEmacs, is het niet hetzelfde. Vergelijkbaar met het vergelijken van Word met Wordpad of Kladblok.
• @Thorbj ø rn Ravn Andersen: Ja, maar niet helemaal dat slecht. 🙂

Het belangrijkste voordeel dat ik zie als ik Lisp leer, is leren hoe je FP in een echte -wereldgerichte multiparadigma-taal, in plaats van het alleen te leren in de context van een academische taal die puurheid benadrukt.

Opmerkingen

• Ik denk dat je dat wel wilt een " Haskell vs Lisp " oorlog!
• Haskell is een academische taal die benadrukt zuiverheid … en veel mensen gebruiken het in de echte wereld. Smalltalk ' s ook in dat kamp.
• Veel mensen gebruiken Haskell in de echte wereld?
• @Jon Harrop: Nou, ik gebruik Haskell in de echte wereld (en het werkt prima voor bepaalde applicaties), misschien ben ik een van de weinige (?)

Ik heb ook een C / C ++ / Python-achtergrond en heb FP de afgelopen jaren een paar keer uitgeprobeerd. Aanvankelijk keek ik naar Haskell en kon er geen kop of staart van maken, daarna probeerde ik Ocaml maar kwam daar niet veel verder mee. Eindelijk begon ik goede dingen over Scala te horen, probeerde het en merkte dat het me heel goed beviel (ik had in het verleden ook een beetje Java gedaan), tot het punt dat na een jaar van zo veel dabbelen in Scala (en het verzenden van 161 Project Euler er problemen mee), lijkt Haskell veel logischer te zijn. In feite heb ik net een paar boeken over Haskell besteld en wil het nog een keer proberen, hoewel dit grotendeels wordt gemotiveerd door het bestaan van Scalaz.

Dus ik ontdekte dat ik een taal met meerdere paradigmas gebruikte (bijv. Scala, maar Lisp zou waarschijnlijk ook passen) een goede weg naar FP. Maar als je “graag in Haskell duikt (dat was ik niet), ga ervoor.

Reacties

• Interessant dat je verder bent gekomen met Scala dan OCaml. Hoe komt dat?
• @Jon: goede vraag; moeilijk te zeggen. Misschien was ik op dat moment niet ' klaar om " in " functioneel te komen. Misschien vond ik toevallig een Scala-tutorial op het juiste niveau. Misschien maakte Scala ' s C / C ++ / Java-afstamming het gewoon een beetje minder vreemd. Aangezien een redelijke weddenschap tegenwoordig op F # zou zijn in plaats van Scala, zal ik ' waarschijnlijk op een gegeven moment het OCaml-domein opnieuw bezoeken, hoewel, aangezien ik in dit spul alleen maar voor het plezier van om in een andere " programmeermentaliteit " naar mijn C ++ dagjob te komen, heb ik een perverse neiging om Haskell daarna opnieuw te proberen.
• Soepele aanpak 🙂

Ik kwam oorspronkelijk uit een C / C ++ / Ruby-achtergrond en ik gebruikte FP-concepten in Ruby wanneer ik maar kon. Staat heeft mijn hersenen een beetje pijn gedaan. Een van mijn vrienden belde me op een dag op en hij vroeg me iets in Haskell te schrijven (mijn eerste – en hopelijk niet laatste – Haskell-baan!). Ik leerde snel de taal en ik gooide iets samen dat werkte. Het was niet mooi of zo, maar het werkte.

Ik nam een maand pauze van Haskell omdat ik niets had om het voor te gebruiken. Maar toen ik besloot dat ik mijn eigen blogsoftware moest schrijven, gebruikte ik Haskell ( https://symer.io ). Haskell is echt gaaf omdat je een probleem in onderdelen kunt opsplitsen en deze onderdelen op basis van input anders kunt implementeren. Haskell behandelt mislukkingen ook buitengewoon goed door het intelligent in dozen doen van waarden. Er zijn zoveel tools om met deze boxen te werken dat je gewoon vergeet dat ze bestaan.

Mijn ervaring met lisp (Scheme) was volledig negatief. Niet alleen miste de taal deze intelligente, eenvoudige tools, het voelde net zo gevaarlijk los als Ruby of JavaScript. Het was een vreselijke ervaring en het biedt niets nieuws buiten Ruby of Python.

C ++ kan Haskell niet in de steek houden, afgezien van geheugenbeheer. Haskell is net zo snel (zo niet sneller), aanzienlijk beknopter en veel veiliger. Maar de veiligheid van Haskell komt nooit in de weg.

TL; TR Haskell is een verademing, en Lisp is een iets meer functionele Ruby.