Let's write some very silly code to turn an integer into a list of digits in Common Lisp:

  (deftype Digit ()
    "A non-negative integer smaller than 10."
    '(Mod 10))

  (defun integer->digits (integer)
    "Turns a given INTEGER into a list of digits."
    (declare (type Integer integer))
    (labels ((digit-loop (integer digits)
                (declare (type Integer integer)
                         (type List digits))
                (if (< integer 10)
                    (list* integer digits)
                    (multiple-value-bind (quotient remainder)
                        (truncate integer 10)
                      (declare (type Integer quotient)
                               (type Digit remainder))
                      (digit-loop quotient
                                  (list* remainder digits))))))
      (declare (ftype (Function (Integer List) List) digit-loop))
      (digit-loop (abs integer)
                  nil)))

  (digit-loop 2026) ; => (2 0 2 6)

  (digit-loop "2026")
  ; The value
  ;     "2026"
  ; is not of type
  ;     INTEGER
  ; when binding INTEGER
  ;
  ; Type HELP for debugger help, or (SB-EXIT:EXIT) to exit from SBCL.
  ;
  ; Restarts:
  ;   0: [ABORT] Exit debugger, returning to top level.

Statements are terminated by either a dedicated graphical character, in which case it's easy to forget the character and have a problem, or by a newline (or maybe a different white space character, but I haven't encountered that yet) in which case decent formatting of code may require a dedicated graphical character to indicate that the newline DOESN'T terminate the statement, in which case we have the same problem. Having newline-terminated statements without continuation character would be consistent, but would hamper readability because identifiers would need to be strictly limited in length to keep certain lines from exceeding available screen space (or alternatively readability would suffer from lines only being partially readable).

And that's before getting into the weeds of how mathematical notation is tricky (most people have learned infix notation at maths class in school, so they mightn't appreciate how horrible it is), how different types of brackets (round, square, curly) can have inconsistent semantics, the downsides to the various ways of indicating lexical blocks (brackets, white space, keywords,...), et cetera.

The ideal programming language would probably be one which allows switching between different syntaxes based on what works best for the user (for example, someone could write code in S-expressions, another person could have that code automatically translated into SRFI-119 Wisp expressions and work with it like that, a third person could then have it rendered into something more Lua-like,...). Which is something I think the Racket people are working on, but I may be mistaken.

Comments URL: https://news.ycombinator.com/item?id=48322125

Points: 42

# Comments: 17

I actually don't mind Ant very much, but I haven't had good luck using Ivy for dependency management. Maven's been very nice in the decade and a half I've used it, Gradle's always felt off to me. I think there was also another Java build tool written in like Ruby or something, but I'm blanking on the name at the moment.

> it's considered very beautiful

Funny, I've heard it described as 'porridge with fingernail clippings', which doesn't seem to me like a description evoking a 'very beautiful' image.

> it takes a long time to become fluent in it

Not more so than many other programming languages. Of course, most people don't start with Lisp, so their frame of reference is off.

> it "expands your mind"

A fairly meaningless statement which is claimed of a great many things. Is Lisp any more or less mind-expanding than, say, marijuana?

> in theory it can "work on the street" but in practice people reach for other tools

What do you mean, 'in theory'? Lisp has been used, in practise, by NASA, for running a robot on Mars: <https://www.corecursive.com/lisp-in-space-with-ron-garret/>. If that isn't 'working on the street', then, by golly, that's a mean street you've got there.