REPL in Lisp

the acronym (?) REPL must be new in Lisp (and Scheme)

i'm sure i never saw it (used or mentioned) 25 years ago.

Lawrence D'Oliveiro

2024-07-11 02:26:04 UTC

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

There are many new terms coined for old concepts. Like “capture” for
“lexical binding”, or “dependency injection” for “callback”.

HenHanna

2024-07-11 05:41:21 UTC

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

There are many new terms coined for old concepts. Like “capture” for
“lexical binding”, or “dependency injection” for “callback”.

thanks. List "comprehension" was new to me.

maybe there're pronunciation changes....

in the old days, CONS was pronounced [kahnzzz]

i always preferred [cohns]

--- after all, it's short for "Construct"

Antonio Marques

2024-07-11 12:57:12 UTC

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

There are many new terms coined for old concepts. Like “capture” for
“lexical binding”, or “dependency injection” for “callback”.

I can more or less see how callbacks can be used as a kind of dependency
injection, but those are separate concepts.

Lawrence D'Oliveiro

2024-07-11 21:41:45 UTC

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

There are many new terms coined for old concepts. Like “capture” for
“lexical binding”, or “dependency injection” for “callback”.

I can more or less see how callbacks can be used as a kind of dependency
injection, but those are separate concepts.

“Dependency injection” is just packaging up a bunch of callbacks as
methods in a class.

Antonio Marques

2024-07-12 12:22:25 UTC

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

There are many new terms coined for old concepts. Like “capture” for
“lexical binding”, or “dependency injection” for “callback”.

I can more or less see how callbacks can be used as a kind of dependency
injection, but those are separate concepts.

“Dependency injection” is just packaging up a bunch of callbacks as
methods in a class.

That's like saying Formula One is just putting cigarette stickers in your
boat.

Julieta Shem

2024-07-12 21:12:48 UTC

Follow-up to comp.lang.lisp. Even though it doesn't even belong to
comp.lang.lisp, let's at least free other groups from this topic. Or
provide me with better judgement.

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

There are many new terms coined for old concepts. Like “capture” for
“lexical binding”, or “dependency injection” for “callback”.

I can more or less see how callbacks can be used as a kind of dependency
injection, but those are separate concepts.

“Dependency injection” is just packaging up a bunch of callbacks as
methods in a class.

Why would you say ``packaging up''? Can we look at Wikipedia? (I'd
appreciate a good reference. I don't know exactly where to look.)

--8<-------------------------------------------------------->8---
[...] dependency injection is a programming technique in which an
object or function receives other objects or functions that it
requires, as opposed to creating them internally. Dependency injection
aims to separate the concerns of constructing objects and using them,
leading to loosely coupled programs.[1][2][3] The pattern ensures that
an object or function that wants to use a given service should not
have to know how to construct those services. Instead, the receiving
'client' (object or function) is provided with its dependencies by
external code (an 'injector'), which it is not aware of. --Wikipedia
--8<-------------------------------------------------------->8---

So I see why you're saying ``callback'' because the object or function
will call your procedures to get what it needs (instead of creating them
internally). But why would say ``packaging up''? (Couldn't I
``inject'' the ``dependencies'' by passing them all as arguments.)

I suppose ``packaging up'' would be appropriate if we pass in to a
procedure an object containing all the callbacks that you say.

Anyway, my interpretation of the Wikipedia article is merely
abstraction. Nothing but abstraction. I don't see why we need to call
it ``injection'' or even ``dependency'', even though the choice of words
isn't absurd.

(*) The source

Dependency injection
https://en.wikipedia.org/wiki/Dependency_injection

Antonio Marques

2024-07-12 22:46:39 UTC

Post by Julieta Shem
Follow-up to comp.lang.lisp. Even though it doesn't even belong to
comp.lang.lisp, let's at least free other groups from this topic. Or
provide me with better judgement.

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

There are many new terms coined for old concepts. Like “capture” for
“lexical binding”, or “dependency injection” for “callback”.

I can more or less see how callbacks can be used as a kind of dependency
injection, but those are separate concepts.

“Dependency injection” is just packaging up a bunch of callbacks as
methods in a class.

(You shouldn't be trying to make sense of information provided by someone
who admits to not understanding it.)

Post by Julieta Shem
(Couldn't I
``inject'' the ``dependencies'' by passing them all as arguments.)

That's one way to do it. In languages that rely on 'objects' it's
fashionable to declare a field for each dependency, with an annotation that
says it's a dependency, and some framework will provide the values at run
time (there will be some framework-specific way to instantiate the
dependencies).

Post by Julieta Shem
I suppose ``packaging up'' would be appropriate if we pass in to a
procedure an object containing all the callbacks that you say.
Anyway, my interpretation of the Wikipedia article is merely
abstraction. Nothing but abstraction. I don't see why we need to call
it ``injection'' or even ``dependency'', even though the choice of words
isn't absurd.

Again, abstraction is just a requirement. There's few things in software
that don't imply some form of abstraction, so that word doesn't get us very
far.

Dependency injection is all about the injection: someone provides your
dependencies for you, and what concrete implementations of those is
something that can and will vary.

Post by Julieta Shem
(*) The source
Dependency injection
https://en.wikipedia.org/wiki/Dependency_injection

Lawrence D'Oliveiro

2024-07-12 23:10:05 UTC

Post by Julieta Shem
But why would say ``packaging up''? (Couldn't I
``inject'' the ``dependencies'' by passing them all as arguments.)

Precisely my point. You can indeed.

Julieta Shem

2024-07-11 16:13:02 UTC

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

There are many new terms coined for old concepts. Like “capture” for
“lexical binding”, or “dependency injection” for “callback”.

Can you elaborate on "dependency injection" for "callback"? It would be
nice if a small example be presented in a popular language such as Lisp
or Python.

Looking the term up, it seems sufficiently different from "callback".

(This is a genuine request for information. I never understood why we
need the term "dependency injection".

Antonio Marques

2024-07-11 16:21:21 UTC

Post by Julieta Shem
I never understood why we
need the term "dependency injection".

Would you just spell out 'determine/decide/provide concrete implementations
of dependencies dynamically' every time?

Kaz Kylheku

2024-07-12 01:39:26 UTC

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

There are many new terms coined for old concepts. Like “capture” for
“lexical binding”, or “dependency injection” for “callback”.

Lexical binding does not imply closure/capture.

C has lexical scoping without capture: the bindings are destroyed
when their associated scope terminates.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @***@mstdn.ca

Aidan Kehoe

2024-07-13 07:24:27 UTC

Post by Kaz Kylheku

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

There are many new terms coined for old concepts. Like “capture” for
“lexical binding”, or “dependency injection” for “callback”.

Lexical binding does not imply closure/capture.

I’ve never seen “capture” used as a general term for closures or for lexical
scope in this way; are we sure it’s what was meant?

Post by Kaz Kylheku
C has lexical scoping without capture: the bindings are destroyed
when their associated scope terminates.

--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after fourteen pints of stout’
(C. Moore)

George Neuner

2024-07-14 15:25:19 UTC

Post by Kaz Kylheku

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

There are many new terms coined for old concepts. Like “capture” for
“lexical binding”, or “dependency injection” for “callback”.

Lexical binding does not imply closure/capture.

I’ve never seen “capture” used as a general term for closures or for lexical
scope in this way; are we sure it’s what was meant?

"Capture" is exactly what was meant.

When a closure references variables from external scopes - that is
things are that are neither arguments nor locals - it is said to
"capture" those variables.

Lisp and Scheme create a copy of the captured variable in the closure
and compile the code to reference the closure's copy rather than the
original [which may no longer exist or may not be in scope when the
closure code finally is executed].

Post by Kaz Kylheku
C has lexical scoping without capture: the bindings are destroyed
when their associated scope terminates.

And C++ now has closures with control over capture. If you choose not
to capture, external variables that are referenced must be in scope
(at their right locations) if and when the closure code is executed.

Aidan Kehoe

2024-07-14 21:03:53 UTC

Post by George Neuner

Post by Kaz Kylheku

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

There are many new terms coined for old concepts. Like “capture” for
“lexical binding”, or “dependency injection” for “callback”.

Lexical binding does not imply closure/capture.

I’ve never seen “capture” used as a general term for closures or for lexical
scope in this way; are we sure it’s what was meant?

"Capture" is exactly what was meant.
When a closure references variables from external scopes - that is
things are that are neither arguments nor locals - it is said to
"capture" those variables.

Or to “close around” those variables.

Your reference to C++ clarified things, I had and have no interest in using
that language and so I had not known that “capture” is used for the Lisp
“closure” in recent versions of C++ that support it.

Post by George Neuner
Lisp and Scheme create a copy of the captured variable in the closure
and compile the code to reference the closure's copy rather than the
original [which may no longer exist or may not be in scope when the
closure code finally is executed].

Post by Kaz Kylheku
C has lexical scoping without capture: the bindings are destroyed
when their associated scope terminates.

--
‘As I sat looking up at the Guinness ad, I could never figure out /
How your man stayed up on the surfboard after fourteen pints of stout’
(C. Moore)

yeti

2024-07-11 05:26:03 UTC

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

I remember REPL back until the early 80s. Wikipedia does not contradict
and adds a bit more:

<https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop>

History

In 1964, the expression READ-EVAL-PRINT cycle is used by L. Peter
Deutsch and Edmund Berkeley for an implementation of Lisp on the
PDP-1.

Since at least the 1980s, the abbreviations REP Loop and REPL are
attested in the context of Scheme.

--
( $#"&?"#=-#@!!! )
/

_ _ _ _ _ _ _ _ _ _ _ _ |\ _ _ _ _ _ _ _ _ _ \o/ _ _ _ _ _ _ _ _ _ _ _ _

HenHanna

2024-07-11 05:37:41 UTC

Post by yeti

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

I remember REPL back until the early 80s. Wikipedia does not contradict
<https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop>
History
In 1964, the expression READ-EVAL-PRINT cycle is used by L. Peter
Deutsch and Edmund Berkeley for an implementation of Lisp on the
PDP-1.
Since at least the 1980s, the abbreviations REP Loop and REPL are
attested in the context of Scheme.

afaicr in the 1980's everyone spelled it out as

Read-Eval-Print Loop or Cycle.

(i think) Guy Steele's AI Memos sometimes used [R-E-P Loop]
but never REPL

Paul Rubin

2024-07-11 08:59:37 UTC

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop#History

"In 1964, the expression READ-EVAL-PRINT cycle is used by L. Peter
Deutsch and Edmund Berkeley for an implementation of Lisp on the
PDP-1.[3] Since at least the 1980s, the abbreviations REP Loop and REPL
are attested in the context of Scheme.[4][5] "

Kaz Kylheku

2024-07-11 10:14:52 UTC

Post by Paul Rubin

Post by HenHanna
the acronym (?) REPL must be new in Lisp (and Scheme)
i'm sure i never saw it (used or mentioned) 25 years ago.

https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop#History
"In 1964, the expression READ-EVAL-PRINT cycle is used by L. Peter
Deutsch and Edmund Berkeley for an implementation of Lisp on the
PDP-1.[3] Since at least the 1980s, the abbreviations REP Loop and REPL
are attested in the context of Scheme.[4][5] "

What's your one REP(L) max, dude?

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @***@mstdn.ca

George Neuner

2024-07-12 11:02:17 UTC