2 ms·
LISP isn't a pure functional language, it's a multi-paradigm language that is as dynamic as they come. Its problem isn't lack of expressivity, it's probably tha
by lolinder 4y ago
LISP isn't a pure functional language, it's a multi-paradigm language that is as dynamic as they come. Its problem isn't lack of expressivity, it's probably that it's too flexible (and of course the syntax throws people off).
As for Haskell, I guess that gets into the question of how you define expressivity, which is admittedly a very fuzzy term. Here I meant it to mean capable of fluently expressing many different kinds of algorithms without having to resort to circumlocution.
Functional programming is natively supported in almost all modern languages. You call a function which calls a function which calls a function which calls a function, return the result. There's no syntactic sugar, just function calls.
In Haskell, while I've seen people argue that do notation may as well be imperative code, it isn't. It's an approximation of imperative code using Church—Turing and a liberal dose of syntactic sugar, and using it effectively still requires you to understand the underlying monadic model.
- CrimsonCape 4y agoThis seems like an easy fix, re-release LISP with cleaner syntax. Lexers have come so far this seems like an easy fix. I can't say i've ever read the opinion that LISP's syntax allows more expressive programming; rather LISP itself allows more expressive programming at the tradeoff of the syntax.
- Kamq 4y ago> re-release LISP with cleaner syntax. A lot of the flexibility of lisp relies on there being no difference between a list of symbols and code (for, example, this is how the entire macro system works). Function calls being inside the parentheses (and, really, all language constructs just being lists of symbols) is generally what people mean when they say the syntax throws people. These two things are at odds. You could go with Racket's method of letting people use alternate delimiters, but that's a fairly trivial reader macro in common lisp and probably not worth releasing a language over.
- charcircuit 4y agoThe macro system can just work with an AST instead of a list.
- Kamq 4y agoPlenty of successors to lisp have tried that. They gunk up the whole experience.
- bslatkin 4y agoLet me know if you'd like to give it a shot to see how gunky it is!
- Kamq 4y agoI mean, I'd be down to try. Best I've seen so far (outside of lisp) is elixir, but it really bogs down the entire thing by requiring a bunch of extra information and metadata that common lisp can infer by position and an extra layer of indirection.
- bslatkin 4y agoContact form here: https://quil.la/FVZ3PMZC https://quil.la/FVZ3PMZC Thanks!
- coldtea 4y ago>I can't say i've ever read the opinion that LISP's syntax allows more expressive programming; rather LISP itself allows more expressive programming at the tradeoff of the syntax. The conventional idea from LISPers is the other way around: LISP's syntax allows for more expressive programming, because code and data are isomorphic (so, macros and rewriting, etc.), and any function you make looks (and is, and behaves) as "first class" as any native one. LISP's syntax is also said to be a better and more concise way than JSON (and or course XML) to describe arbitrary hierarchical structures.
- patrickmay 4y agoThere is no cleaner syntax than Lisp's. It is essential to Lisp's expressivity.
- naasking 4y agoO-expressions seem pretty good.
- kazinator 4y agoAdding different syntax to Lisp has been tried many times. No attempt has ever succeeded. Lisp users basically rejected all those systems, and they didn't gain any traction in bringing new users into Lisp. The first attempt was Lisp 2. This doesn't refer to Lisp-2 (two namespaces for variables and functions) but to a follow-up to Lisp 1.5, which was tried in the 1960's. Lisp 2, IIRC, featured an Algol-like syntax, with types, for speeding up numeric processing. It went nowhere. In the early 1970's, Vaughan Pratt (of "Pratt parser" fame, I think) created CGOL. That also went nowhere. After that we can identify numerous other things in that vein. Here we are today and most people using Lisp still have it (looking (like) this).
- chlorion 4y agoIMO the thing that makes lisp so powerful is the ability to extend the syntax, and this is only possible because the syntax is represented as a list. When your syntax can be manipulated like data (in this case lists), macros become regular functions operating on regular data, the data just happens to be syntax in this case. I can take a struct definition for example and use regular, built-in list manipulation functions to walk the definition and transform it into whatever I want. In something like Rust we can also run macros on struct definitions, but in that case you operate on a token stream, and need specialized libraries and functions to do meaningful transformations. It ends up being much more difficult but still pretty powerful. Super powered macros is what makes lisp "lispy" to me and the "abnormal" syntax is required for that, so I do think the syntax is what makes is uniquely expressive.
- coldtea 4y ago>LISP isn't a pure functional language In the modern history-rewritten sense of the term to mean Haskell and purity. In the past LISP was the 100% canonical idea of what a functional language is, including on HN before 2010 or so.
- wk_end 4y agoLisp was never "pure", but yes, there's definitely been a shift in the meaning of the term "functional language". Which makes sense: the things that made Lisp more "functional" or better suited to the functional style have almost universally adopted by other languages. There's nothing particularly functional about it anymore. Lisp has always been deeply multiparadigm, even if it was the harbinger of FP. It's had support for mutation and OOP since the 70s. If you wanted to (although most Lispers wouldn't), you could view that support as an escape hatch for when the functional paradigm, as expressed in Lisp, was inappropriate or insufficient to solve a problem. It's natural, then, that languages that have taken the functional paradigm and insisted on it, run further with it, are now the ones that are particularly functional. It's how language naturally evolves in cases like this; similar things can be seen with the term "artificial intelligence".
- goatlover 4y agoYou might be confusing Lisp with ML.
- coldtea 4y agoNope. ML, albeit ancient, was not even on the map on HN until after Haskell picked mindshare. I mean you could find a post here and a post there, but nothing like Lisp's posts and HN-mindshare. And, sure, HN was from the start a Lisp-built forum, made by a Lisp-advocate, and thus attracting Lispers, but it wasn't that different on the wider internet.
- kazinator 4y agoBut who said more or less of what on HackerNews, and in what years, bears no relevance to what is pure functional language. Lisp had mutable everything from the earliest beginning, and that has been maintained in the descendant dialects. We literally cannot go back to a time in which Lisp was the model of what is purely functional; though it may have been used as an instrument (in restricted ways) for conveying or practically making use of the ideas. There is something called "pure Lisp". Even such backwaters as the Webster Dictionary of Computing seem to know what this is: http://www.webster-dictionary.org/definition/Pure+Lisp http://www.webster-dictionary.org/definition/Pure+Lisp "A purely functional language derived from Lisp by excluding any feature which causes side-effects." I think you will rarely see an entire program written in nothing but pure Lisp. Functions or modules can be designated as being in pure Lisp. If the documentation says that a certain module is pure Lisp, that instantly sets certain expectations about what it will be like to interact with.
- physPop 4y agoIf you truly think "functional programming is natively supported in almost all modern languages" then you really don't know what modern FP is about. For instance implementations of monadic control flow, effect systems, higher kinded types, algebraic data types, exhaustive pattern matching etc are all laughably unergonomic or entireley missing in most "popular"/"enterprise" languages. Just having a labmda doesn't FP make. To me, FP in modern functional languages provides abstractions that enable much more straightforward problem solving and understandable code with fearless refactoring. Haskell and Ocaml are the pragmatic leaders here I think, with honorable mentions for things like Scala3, F#, and (kindof?) clojure. (edit spelling)
- lolinder 4y agoI've spent more time studying programming languages than anyone else I know, and I understand FP very well. The argument that I'm making is not that FP has nothing to offer (I dearly hope that many more features from FP languages make it into the mainstream!), it's that FP comes with a set of restrictions on what can and cannot be done, and those restrictions do not seem justified to the majority of programmers. It is as uncomfortable for them to work with Haskell as it is to work with Rust, but unlike with Rust they can't see why they should bother. The author of the article hopes to build a new functional programming language that will finally get traction by making a few different choices. I think that this is a mistake because a single-paradigm language will never reach mainstream adoption. Pragmatically multi-paradigm languages have historically been the only ones to get traction, and I believe that the reason is because they explicitly endorse multiple possible approaches, even if their support for any given approach isn't as strong as a specialized tool. They may not support FP as well as Haskell or OO as well as Smalltalk, but by sacrificing purity they buy pragmatism, and allow programmers more flexibility in problem solving.
- igouy 4y ago> They may not support FP as well as Haskell or OO as well as Smalltalk… The Smalltalk Collection enumeration protocol was probably the first time I'd seen anything like (1 to: 100) select: [ :n | n isPrime ] https://cuis-smalltalk.github.io/TheCuisBook/Fun-with-collections.html#index-block https://cuis-smalltalk.github.io/TheCuisBook/Fun-with-collec... (Now I recall, I had been required to write some Tower of Hanoi snippet in either Lisp or Prolog, and I'd used Prolog.)