McCarthy wrote this in ``History of Lisp''.

> Numbers were originally implemented in LISP I as lists of atoms, and
> this proved too slow for all but the simplest computations.

Was that Church numerals? Does anyone have examples of code from back
then? I'm picturing things such as

(defconstant zero nil)
(defconstant one (cons nil zero))

(defun zero? (x) (eq zero x))
(defun add1 (x) (cons nil x))
(defun sub1 (x) (cdr x))

(defun add (x y)
(cond ((zero? x) y)
(t (add (sub1 x) (add1 y)))))

CL-USER> (add one one)
(NIL NIL)

The paragraph continued:

> A reasonably efficient implementation of numbers as atoms in
> S-expressions was made in LISP 1.5, but in all the early LISPs,
> numerical computations were still 10 to 100 times slower than in
> FORTRAN. Efficient numerical computation requires some form of typing
> in the source language and a distinction between numbers treated by
> themselves and as elements of S-expressions. Some recent versions of
> LISP allow distinguishing types, but at the time, this seemed
> incompatible with other features.

Julieta Shem <jshem@yaxenu.org> writes:

> McCarthy wrote this in ``History of Lisp''.
>
>> Numbers were originally implemented in LISP I as lists of atoms, and
>> this proved too slow for all but the simplest computations.
>
> Was that Church numerals? Does anyone have examples of code from back
> then? I'm picturing things such as
>
> (defconstant zero nil)
> (defconstant one (cons nil zero))
>
> (defun zero? (x) (eq zero x))
> (defun add1 (x) (cons nil x))
> (defun sub1 (x) (cdr x))
>
> (defun add (x y)
> (cond ((zero? x) y)
> (t (add (sub1 x) (add1 y)))))
>
> CL-USER> (add one one)
> (NIL NIL)
>
> The paragraph continued:
>
>> A reasonably efficient implementation of numbers as atoms in
>> S-expressions was made in LISP 1.5, but in all the early LISPs,
>> numerical computations were still 10 to 100 times slower than in
>> FORTRAN. Efficient numerical computation requires some form of typing
>> in the source language and a distinction between numbers treated by
>> themselves and as elements of S-expressions. Some recent versions of
>> LISP allow distinguishing types, but at the time, this seemed
>> incompatible with other features.

Wow! I am also interested in knowing this. I like this early LISP stuff
:-) .

Julieta Shem <jshem@yaxenu.org> writes:

McCarthy wrote this in ``History of Lisp''.

> Numbers were originally implemented in LISP I as lists of atoms, and
> this proved too slow for all but the simplest computations.

Was that Church numerals?

Certainly not.

The "atoms" is question were probably machine words containing the
digits of the number in some suitable base. I would guess base 2^36 or
2^35, depending on how they chose to represent negative numbers --
similar to the way GMP still works today. But I don't know for sure.
I've never seen this documented anywhere.

- Alan

Alan Bawden <alan@csail.mit.edu> writes:

> Julieta Shem <jshem@yaxenu.org> writes:
>
> McCarthy wrote this in ``History of Lisp''.
>
> > Numbers were originally implemented in LISP I as lists of atoms, and
> > this proved too slow for all but the simplest computations.
>
> Was that Church numerals?
>
> Certainly not.
>
> The "atoms" is question were probably machine words containing the
> digits of the number in some suitable base. I would guess base 2^36 or
> 2^35, depending on how they chose to represent negative numbers --
> similar to the way GMP still works today. But I don't know for sure.
> I've never seen this documented anywhere.

Do you know if they have big numbers in those early implementations?
(Why would they use a list of things?) I'm now thinking that by ``list
of atoms'' (and with the light of from your post) they were supporting
big numbers. Their algorithms were perhaps naive, explaining ``the too
slow for all but the simplest computations''. Thanks!

Julieta Shem <jshem@yaxenu.org> writes:

> McCarthy wrote this in ``History of Lisp''.
>
< > Numbers were originally implemented in LISP I as lists of atoms, and
< > this proved too slow for all but the simplest computations.
>
> Was that Church numerals? Does anyone have examples of code from back
> then? I'm picturing things such as
>

I doubt it. check turning machine.

in original lambda-calc numbers where represented as applications of
lambda. check the wiki, it has mostly math since his science would not
fit well with these machines.

> (defconstant zero nil)
> (defconstant one (cons nil zero))
>
> (defun zero? (x) (eq zero x))
> (defun add1 (x) (cons nil x))
> (defun sub1 (x) (cdr x))
>
> (defun add (x y)
> (cond ((zero? x) y)
> (t (add (sub1 x) (add1 y)))))
>
> CL-USER> (add one one)
> (NIL NIL)
>
> The paragraph continued:
>
< > A reasonably efficient implementation of numbers as atoms in
< > S-expressions was made in LISP 1.5, but in all the early LISPs,
< > numerical computations were still 10 to 100 times slower than in
< > FORTRAN. Efficient numerical computation requires some form of typing
< > in the source language and a distinction between numbers treated by
< > themselves and as elements of S-expressions. Some recent versions of
< > LISP allow distinguishing types, but at the time, this seemed
< > incompatible with other features.

yes, church made the math and the original concepts I believe. Turning
machines were actually usefull if you could find your way into one.

On Thu, 16 May 2024 16:28:01 -0400, steve wrote:

> check turning machine.

Sounds like some kind of scam operation.

“The police raid of the check-turning operation arrested a dozen people
and seized half a dozen check-turning machines.”

“You are on trial for 350 counts of check-turning. How do you plead?”

Julieta Shem <jshem@yaxenu.org> writes:

> Alan Bawden <alan@csail.mit.edu> writes:
>
< > Julieta Shem <jshem@yaxenu.org> writes:
< >
< > McCarthy wrote this in ``History of Lisp''.
< >
< > > Numbers were originally implemented in LISP I as lists of atoms, and
< > > this proved too slow for all but the simplest computations.
< >
< > Was that Church numerals?
< >
< > Certainly not.
< >
< > The "atoms" is question were probably machine words containing the
< > digits of the number in some suitable base. I would guess base 2^36 or
< > 2^35, depending on how they chose to represent negative numbers --
< > similar to the way GMP still works today. But I don't know for sure.
< > I've never seen this documented anywhere.
>
> Do you know if they have big numbers in those early implementations?
> (Why would they use a list of things?) I'm now thinking that by ``list
> of atoms'' (and with the light of from your post) they were supporting
> big numbers.

it goes back to the CAR and CDR register.

> Their algorithms were perhaps naive, explaining ``the too
> slow for all but the simplest computations''. Thanks!

lisp was about the lambda and the closure. lexical scope possible. the
concept of numbers were not issues. https://en.wikipedia.org/wiki/S-expression

think of vixie tubes - how many numbers? infinite (with many tubes and a
cary flag )

vixie tubes are russian, soviet, Ukraine and therefor hard to get (very expensive; very
hard to trade for evil LEDs (photo dio). I have one for a heating mantel.
just set the timer function ..

(let ((x 5))
(funcall (lambda () (print x))))
(let ((y 3))
(funcall (lambda (x) (+ x y)) 3))

=> 6

(let ((y 'a))
(funcall (lambda (x) (list x y)) 3))

=> (3 a)

;; This is the best option but symbols and funcall took a lot of
;; hardware. notice the ``shadowing'' ; the set operator violates the
;; pure lambda . the pure lambda would be the programming language
;; called scheme. it is designed for specification not for efficiency.
;; I dunno it seems to be a french thing (RS5) (?)

;; apply was written by Guy Steele; (initially).

https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://en.wikipedia.org/wiki/Guy_L._Steele_Jr.&ved=2ahUKEwjhur3l25aGAxWthIkEHcPtACMQFnoECC8QAQ&usg=AOvVaw0oeV0gO0WRACOWzK2hZByX

(set 'number-1 (lambda ()
(lambda () 3)))

(funcall (funcall number-1))

=> 3

that would be 3 closures - or three LEDs.

;; in scheme

((lambda () ... ))

blah blah...

The (( means evaluate. scheme is not a bad language; but CL dives right
in.

> “The police raid of the check-turning operation arrested a dozen people
> and seized half a dozen check-turning machines.”
>
> “You are on trial for 350 counts of check-turning. How do you plead?”

Thanks!

Stefan