Hacker Read

Lyngbakr · 2023-06-01 13:07:01

Perhaps I've misunderstood, but several languages have REPLs so that isn't unique to Lisps, is it?

lispm | karma 12407 | avg karma 2.21 · | 2018-07-18 08:22:25+00:00

Most Lisp REPLS print a result somewhere.

kimi | karma 2185 | avg karma 3.07 · | 2022-03-23 03:59:09

No it's a Clojure thing. Other lisps may vary.

toyg | karma 35240 | avg karma 2.97 · | 2019-07-14 15:00:28+00:00

In primitives, yes; but that's not the point with Lisp, whereas it is for those alternatives.

darkhorn | karma 409 | avg karma 0.51 · | 2014-06-03 12:14:21+00:00

I was implying that a feature that is known to be in Lisp but not in most of the other languages. Such as Read–eval–print loop.

nerdponx | karma 22397 | avg karma 2.51 · | 2016-10-07 16:01:02+00:00

Isn't this a feature of Lisp-alikes in general?

lispm | karma 12407 | avg karma 2.21 · | 2015-12-02 23:08:17

Its core lives in Lisp dialects like Emacs Lisp just fine.

Try GNU Emacs and the REPL:

    M-x ielm

    *** Welcome to IELM ***  Type (describe-mode) for help.
    ELISP> (append '(this is a Lisp) '(REPL))
    (this is a Lisp REPL)

    ELISP> (cons 'This (append '(is a) (list 'Lisp 'REPL)))
    (This is a Lisp REPL)

This code is from McCarthy's Lisp 1.5 Programmer's manual, from 1962, running in Common Lisp:

    CL-USER 6 >  (defun my-length (l)
                   (prog (u v)
                     (setq v 0)
                     (setq u l)
                     a
                     (cond ((null u) (return v)))
                     (setq u (cdr u))
                     (setq v (+ v 1))
                     (go a)))
    MY-LENGTH

    CL-USER 7 > (my-length '(1 2 3 4 5))
    5

That's why it's called a 'Lisp' -> it runs Lisp code.

tincholio | karma 1025 | avg karma 1.68 · | 2020-03-13 11:55:18+00:00

Sure, and in CL is even better. My point was that other languages (non-lisps, such as Python, Ruby, etc) don't allow for that.

dimitrios1 | karma 2135 | avg karma 2.65 · | 2020-11-03 02:08:10+00:00

Save for Erlang and Elixir, this tends to be the case with ML-family FP languages, not so much with LISPs, in my opinion of course.

enduser | karma 1937 | avg karma 5.32 · | 2011-11-15 02:58:42

It's only an anti-pattern in languages that don't have resumable conditions (i.e. other than Common Lisp).

voldacar | karma 2978 | avg karma 2.23 · | 2020-04-13 11:28:38+00:00

i think there are some common lisp implementations that do this

edgyquant | karma 5727 | avg karma 1.57 · | 2022-03-22 19:01:47

Ah okay that’s cool then. I thought you were calling out some low level implementation detail of lisp I had overlooked. I’m trying to build a lisp as the intermediate of my new toy programming language. So I wanna get that right.

beders | karma 1052 | avg karma 1.84 · | 2020-08-31 15:39:49+00:00

Unfortunately, no direct comparison to Lisps.

The two downsides mentioned regarding FP are not an issue if you are using a REPL and a Lisp:

- excellent IDE support, since you are working inside your program (which can be inspected)

- paradigm a la carte: you want named arguments? Go for it (split :string "foo,bar" :by ",")

  you want different invocation syntax? (3 + 4) or (3 4 +) is just a macro away

and a bit easier to read than: (this Int).square | Int = this.*(this) YMMV

  you want to define your data shape? use your favorite schema language

  you want monads? just use a library

  you want go-routines? just use a library

  you want compile time types? just use a library

p_l | karma 8319 | avg karma 1.99 · | 2019-10-25 10:59:42

None and none, as what you need is to alias the symbols for most lisps.

mattbriggs | karma 194 | avg karma 1.66 · | 2012-05-16 13:03:42+00:00

It is a special case in other languages, in lisp it is one of a very few highly consistent rules

kruhft | karma 1034 | avg karma 1.38 · | 2017-02-06 04:29:56

Cool. That's one of the biggest pains I've found with implementing a lisp in a typed language.

flavio81 | karma 2332 | avg karma 2.08 · | 2018-03-15 10:54:11

Yes, you are correct. It's just that I considered "Lisp"="Common Lisp" in this case.

hazebooth | karma 885 | avg karma 18.83 · | 2023-08-18 11:20:02

I could be wrong, but can't Common Lisp do this?

eru | karma 30335 | avg karma 1.29 · | 2022-08-06 20:43:36

Yes, that's an interesting feature of Lisp.

You can do that in Haskell, too, but it's much, much less common.

reply

aidenn0 | karma 26449 | avg karma 2.17 · | 2016-03-17 23:36:12+00:00

So I guess you just have to be super careful with variable and function names? That's the dark-ages for lisp, but still usable.