News for hackers. Stuff that matters.
Re:These years in Common Lisp: 2023-2024 in review by nesarkvechnep on Saturday February 22, 2025 @08:56AM (#43138969)
A few cool thing happened! I might give the CLOS course a try! I’m a functional guy but I feel CLOS isn’t your typical object system.
Re:These years in Common Lisp: 2023-2024 in review by pjmlp on Saturday February 22, 2025 @11:36AM (#43140464)
Indeed, most successful FP languages have their OOP like approaches.

Another thing all modern Lisps have since the 1980's, is all major data structures, not only lists as many think when discussing Lisp.

Re:These years in Common Lisp: 2023-2024 in review by fovc on Saturday February 22, 2025 @07:13PM (#43144752)
Having the data structures is nice and all, but using them is kind of painful. They are certainly second class.

Having to use accessor functions or destructuring macros instead of just a period or -> is often annoying too. The lack of syntax has cons as well as pros.

Re:These years in Common Lisp: 2023-2024 in review by cenamus on Sunday February 23, 2025 @02:48AM (#43147530)
I mean you can write a macro that let's you write

(object -> slot)

and transforms it to (slot object)

"->" should be unused

Re:These years in Common Lisp: 2023-2024 in review by tmtvl on Sunday February 23, 2025 @10:04AM (#43149750)
Writing a reader macro that allows for something like...

  [some-numbers 0]
...to get the first (many programming languages make this mistake, using 0 to refer to the first element of a collection, so we can forgive CL for this) element. But I'm curious how you can write...

  (object -> slot)
...without getting an error about OBJECT not being a valid function or macro.
Re:These years in Common Lisp: 2023-2024 in review by fovc on Sunday February 23, 2025 @10:07AM (#43149769)
And also make sure that slot is a symbol in the correct package. Or do like Elisp and do without packages but then have a 16 character prefix
Re:These years in Common Lisp: 2023-2024 in review by Jach on Wednesday February 26, 2025 @06:43AM (#43182785)
A late reply but it's worth addressing one way of doing this. First, your concern about object not being a valid function or macro isn't relevant at read time. Second, note that Lisp already has similar syntax: '(1 . 2) is essentially (cons 1 2). Implementing this type of syntax is not a privilege of the implementation alone. You're allowed to redefine your own reader for left paren. In SBCL:

    CL-USER> (get-macro-character #\()
    SB-IMPL::READ-LIST
You can write `(set-macro-character #\( 'sb-impl::read-list)` and everything continues to work just fine. You can also jump-to-source and modify it if you want -- though it's cleaner to just copy it out to your own project, that's what I did for a quick hack/proof of concept. Essentially I added before the existing (when...) which handles the special dot syntax:

      (when (and (eq firstchar #\-)
                 (eq (peek-char t stream t nil t) #\>))
        (read-char stream t) ; actually read the nextchar > to discard it
        (let ((next-obj (read stream)))
          (sb-impl::flush-whitespace stream rt)
          (return `(slot-value ,@listtail ',next-obj))))
I won't claim this is good or proper, but it shows that it's quite feasible. We've turned (foo -> bar) into (slot-value foo 'bar).

    CL-USER> (defclass vec2 ()
      ((x :initarg :x)
       (y :initarg :y)))
    #<STANDARD-CLASS COMMON-LISP-USER::VEC2>
    CL-USER> (defparameter vec (make-instance 'vec2 :x 3 :y 4))
    VEC
    CL-USER> (vec -> y)
    4
    CL-USER> (read-from-string "(print (vec -> x))")
    (PRINT (SLOT-VALUE VEC 'X))
    18
Personally I wouldn't use this even if it was more properly/carefully implemented. (There's really no reason to replace the default left-paren reader, and no reason we have to have a space surrounding the "->". One thing I like about the infix reader macro package https://github.com/quil-lang/cmu-infix is that it doesn't care about spaces, I can write #I(1+1 + 4) and get 6.) I'm quite happy putting my class in its own package, and thus getting the primary tab-completion behavior I care about. e.g. "(ma:<tab>" could complete to "(math:" and then "(math:v<tab>" could complete to a list of options like "vector-x" "vector-y" or so on. I also like the somewhat unusual approach of naming my accessors with a dot prefix, e.g. (.x vec) and (.y vec), or even (math:.x vec) if I haven't imported the symbol.
Re:These years in Common Lisp: 2023-2024 in review by tmtvl on Wednesday February 26, 2025 @02:55PM (#43187481)
Good things are worth waiting for. I never considered making a reader macro for a regular opening bracket, that's equal parts genius and insanity.
Re:These years in Common Lisp: 2023-2024 in review by kazinator on Wednesday February 26, 2025 @02:46PM (#43187381)
> so we can forgive CL for this

The 1962 dated Lisp 1.5 Programmer's Manual already describes a 0 based array feature. Lisp was clearly one of the historic instigators of zero based array, rather than just playing along.

Re:These years in Common Lisp: 2023-2024 in review by tmtvl on Wednesday February 26, 2025 @04:55PM (#43188677)
Yes, but the various Lisps that Common Lisp is the more-or-less common subset of are (were?) all 0-indexed. Between easy heap implementation (left is (ash index 1), right is (1+ (ash index 1)), parent is (ash index -1)) and easy last element selection (nth seq (length seq)) I prefer 1-indexing, but I realize that's an unpopular opinion.
Re:These years in Common Lisp: 2023-2024 in review by pjmlp on Sunday February 23, 2025 @03:19AM (#43147706)
Everything needed is place, there is no second class about using arrays instead of lists.
Re:These years in Common Lisp: 2023-2024 in review by ludston on Sunday February 23, 2025 @12:39AM (#43146943)
Common Lisp isn't a functional programming language to be clear.
Re:These years in Common Lisp: 2023-2024 in review by pjmlp on Sunday February 23, 2025 @03:18AM (#43147697)
It definitely isn't one, when instead of looking at it with the eyes of CS knowledge, people take the mindset whatever Haskell does.

FP predates Haskell by decades.

Re:These years in Common Lisp: 2023-2024 in review by ludston on Sunday February 23, 2025 @04:58AM (#43148164)
It also isn't one when "looking at it with the eyes of CS knowledge", given that Common Lisp has very powerful support for OO and procedural programming out of the box, and in order to most effectively use an FP style it's necessary to rely on community developed libraries...
Re:These years in Common Lisp: 2023-2024 in review by pjmlp on Sunday February 23, 2025 @05:26AM (#43148287)
What FP style? Haskell style, I guess.

When I learnt Lisp, Lisp and Scheme were FP, Miranda was still around, and Caml Light had just started being known outside INRIA.

I really dislike revisionism regarding what it means to be FP.

Re:These years in Common Lisp: 2023-2024 in review by veqq on Sunday February 23, 2025 @05:59AM (#43148424)
The issue's that Schemes (and Clojure) are way more functional than Common Lisp and e.g. `funcall` feels like a kludge compared to lisp-1. If you read the old CL codebases or modern code, destructive and imperative use are common, so it doesn't feel terribly revisionist (just compared to pascal, c, bliss etc.).
Re:These years in Common Lisp: 2023-2024 in review by andsoitis on Sunday February 23, 2025 @09:48AM (#43149608)
Wikipedia page for “functional programming”:

”The first high-level functional programming language, Lisp, was developed in the late 1950s…”

https://en.wikipedia.org/wiki/Functional_programming

Re:These years in Common Lisp: 2023-2024 in review by ludston on Sunday February 23, 2025 @04:47PM (#43153523)
Common Lisp has Lisp in the name, but it is not the same thing. We're talking about languages developed 30 years apart here.

In the 80s, things like immutability just weren't pragmatic due to memory constraints, and CL was designed with pragmatism in mind. Scheme could be argued as FP. Clojure certainly is. CL is not.

Re:These years in Common Lisp: 2023-2024 in review by pjmlp on Sunday February 23, 2025 @12:13PM (#43151021)
So that rules out most ML derived language as well, pity Standard M, OCaml, F#, Scala are no FP as well. /s
Re:These years in Common Lisp: 2023-2024 in review by dartos on Saturday February 22, 2025 @09:35AM (#43139254)
As a functional fan, CLOS is amazing.
Re:These years in Common Lisp: 2023-2024 in review by f1shy on Saturday February 22, 2025 @11:08AM (#43140186)
When I learned CLOS it was the first time OOP started making sense for me.
Re:These years in Common Lisp: 2023-2024 in review by asplake on Saturday February 22, 2025 @11:26AM (#43140360)
I've never used CLOS but I loved the metaobject protocol book. So many learnings outside of OOP – it’s a masterclass in API design.
Re:These years in Common Lisp: 2023-2024 in review by jjtheblunt on Saturday February 22, 2025 @11:31AM (#43140422)
What’s the metaobject protocol book?
Re:These years in Common Lisp: 2023-2024 in review by pjmlp on Saturday February 22, 2025 @11:33AM (#43140434)
Re:These years in Common Lisp: 2023-2024 in review by jjtheblunt on Saturday February 22, 2025 @12:10PM (#43140798)
No idea how i missed that; thank you.
Re:These years in Common Lisp: 2023-2024 in review by f1shy on Saturday February 22, 2025 @12:50PM (#43141271)
Re:These years in Common Lisp: 2023-2024 in review by codr7 on Saturday February 22, 2025 @03:45PM (#43143037)
My main takeaway was multi-methods, they didn't really click for me before I started seriously digging into CLOS. I wish more languages supported them/played around with similar ideas.
Re:These years in Common Lisp: 2023-2024 in review by runevault on Saturday February 22, 2025 @01:35PM (#43141680)
As someone who's dabbled with Scheme, Clojure, and CL long ago and started wanting to get back into CL, I really enjoyed that course as a combination refresher plus deep dive into some topics I didn't really know before (including CLOS).
Re:These years in Common Lisp: 2023-2024 in review by nextos on Saturday February 22, 2025 @02:53PM (#43142520)
CLOS is great, but CL also supports pure typed FP with https://coalton-lang.github.io

Coalton progress is discussed briefly in the OP: https://lisp-journey.gitlab.io/blog/these-years-in-common-li...

Re:These years in Common Lisp: 2023-2024 in review by trenchgun on Sunday February 23, 2025 @02:34AM (#43147465)
Coalton is its own language, just implemented and embedded in CL.
Re:These years in Common Lisp: 2023-2024 in review by nextos on Sunday February 23, 2025 @08:00PM (#43154818)
Sure, but Coalton has decent interop with CL.

Eventually, I expect this to be a relationship similar to Java and Scala or Clojure.