fset

It's a matter of not modifying things once constructed. CL has hooks to help do that, although a user can always get around them. A package I've been involved with lately is fset, which is available through quicklisp, or at https://github.com/slburson/fset It has some interesting features, including "functional setf expansion". This would turn something like (setf (fcar x) y) into something equivalent to (setf x (cons y (fcdr x))) (where "fcar" and "fcdr" are the same as "car" and "cdr", except when they are in a setf-able place form.) (fcar and fcdr are not in fset; I used those names just for exposition here.) It could work with nested accessors, but only if it bottoms out in a variable.

Have you looked at FSet? https://github.com/slburson/fset

Hah! I've been using/committing to that lately. I think the GitHub repo is where quicklisp pulls from: https://github.com/slburson/fset

For a much better experience programming functionally in Common Lisp, try the FSet functional collections library: https://github.com/slburson/fset

If you want to use functional (immutable) collections in Common Lisp, try FSet [0]. (It's QuickLisp-loadable.) FSet greatly expands the space of programs that can naturally be written in a functional style in CL. [0] https://github.com/slburson/fset

It's somewhat hit-and-miss which submissions make the front page. A submission has only a few minutes to get several upvotes before it's pushed off the front "new" page, after which it's unlikely to recover. Since you're here I'll add a little to my previous comment [0], which was very short because I didn't think many people would see it. I don't advocate completely pure functional programming as one would do in Haskell, but I do think there are lots of places in most code where the functional style would be clearer and easier to understand and debug than the fully imperative style more common in Lisp. That's why I created FSet [1], a functional collections library. It has been my observation that having high-quality functional collections is often the most important missing piece to make it possible to write more code functionally. [

• Are there any functional programming advocates in the Common Lisp open source community? Yo! https://github.com/slburson/fset

R uses a pass-by-value semantic for function calls. This means that when a function modifies the contents of one of its arguments, it is a local copy of the value which is changed, not the original value. This has many desirable properties, including aiding reasoning about and debugging code, and ensuring precious data is not corrupted. However, it is very expensive as many more computations need to be done to copy the data, and many computations require excessive memory due to the large number of copies needed to guarantee these semantics. I don't know what implementation R uses for its data frames, but building efficient collections with functional semantics is now a solved problem, as demonstrated by the functional collections libraries supplied by or available for many languages -- Clojure, Scala, ML, Haskell, and no doubt many others

> Clojure is better because of better functional programming features than CL CL now has [shameless plug] an excellent functional collections library, FSet [0]. Using FSet greatly expands the range of algorithms that can easily be written in a functional style. It's been a while since I looked at Clojure, but my impression is that FSet has a substantially richer API, including a bag (multiset) type and many more operations. I don't know exactly which Clojure features you have in mind, but I suspect that FSet makes CL at least as good for functional programming as Clojure. [0] https://github.com/slburson/fset

The FSet functional collections library [0] greatly improves CL's support for functional programming. [0] https://github.com/slburson/fset

> Lisp lists lack encapsulation; they are not opaque bags with which you do things like (add list item). That takes getting used to: always capturing the result value of a list construction. You're conflating two properties: lack of encapsulation and functional update. It's true that lists expose their internal structure as conses, and it's also true that they're usually updated functionally (requiring, as you say, capturing the result), but these properties don't have to go together. It's entirely possible, and arguably desirable, to have functional collections -- where instances are immutable, but which provide operations for creating new instances from existing ones -- which are also opaque data types; see for example FSet [0]. Conversely, it's possible to have fully-mutable lists that expose their internal structure; you just have

You have to think about this ecologically. What niche would a new CL occupy? What use would anyone have for something similar to CL but not identical? How could such a thing catch on? If the features you think should be added are just extensions, it's very likely they can be added as libraries (though there are occasional exceptions). If they actually change the language so as to break existing code, it's very hard to see why anyone currently using CL would want to use your language. The CL ecosystem is already considered to be behind other major languages in terms of library coverage; your new language would be starting from zero on that point. I think the only way a completely new Lisp would catch on is for some company to create their own, and then to spend enough years using it for enough different things that they create an adeq

Lisp (what is a Common Lisp "flavor"? Racket is Scheme) has answers to all... Of course the benefit of Clojure baking those things in is you can rely on them in other people's programs, but still idiomatic Lisp seems to do an ok job managing state, especially compared to other languages. Plus its other features that Clojure lacks might make the tradeoff worth it. Parallel programming: https://lparallel.org/overview/ Functional collections: https://github.com/slburson/fset STM: https://common-lisp.net/project/cl-stm/doc/index.html

I like to call Lisp "semi-functional" -- it provides better support for the functional style than ordinary imperative languages, particularly if you use FSet [0] (shameless plug), but is still perfectly good for imperative programming when you want to do that. [0] https://github.com/slburson/fset

While I certainly don't want to discourage anyone from hacking on anything they enjoy, if your primary purpose is to use ordered collections, FSet [0] has them, and much, much, much more. It's Quicklisp-loadable. [0] https://github.com/slburson/fset