Hacker News Reader

Comment by latenightcoding | Hacker News Reader

>> it does not use linked lists at its core

does Clojure?

I can implement a Scheme interpreter that passes most test suites using vectors instead of linked lists, would you not consider it a lisp?

View on HN

> I can implement a scheme that passes most test suites using vectors instead of linked lists, would you not consider it a lisp?

My Symbolics Lisp Machine has a Lisp implementation where some form of vectors are an optimization of lists (-> CDR coding). But that's an implementation detail. For most purposes the thing behaves as it uses linked lists - and even has primitive operators for linked lists as CPU instructions.

CLISP, another Lisp implementation, has its own virtual machine, written in C. There too, CAR, CDR, CONS are primitive operations in the VM:

  [1]> (defun foo (list) (cons (cdr list) (car list)))
  FOO
  [2]> (disassemble #'foo)

  Disassembly of function FOO
  1 required argument
  0 optional arguments
  No rest parameter
  No keyword parameters
  5 byte-code instructions:
  0     (LOAD&CDR&PUSH 1)
  2     (LOAD 2)
  3     (CAR)
  4     (CONS)
  5     (SKIP&RET 2)

For me Lisp means more than parentheses or some vague idea of a language "family". It's a language, a bunch of implementations which have a similar core (data structures, operators) and which share code. These languages tend to have the name 'Lisp' in their language.

Then there is this meaning that Lisp is a very diverse group of languages bases on largely undefined criteria. Like C is a member of the ALGOL language family.

That's the "Lisp family": It includes JavaScript/ECMAScript, Dylan, Clojure, Scheme, Racket, R, SKILL... Some have s-expressions, some not. Some use linked lists, some not. Some are object-oriented, some not. And so on.

But for practical purposes it's meaningless: if I want to know about how a particular Scheme construct works, I would look into a Scheme documentation (or its particular implementation), not into a Lisp book.

Scheme, Clojure, .. all have their own language family by now: there are language definitions, a bunch of similar implementations, shared code, books, ...

It's also funny how people claim that language X is a Lisp, as if that would mean something "special" or even "better". There are lots of excellent and useful programming languages out there, which are not Lisp.

So if Janet refactored the interpreter to use linked lists, CONS/CAR/CDR everywhere in the C code but the language stayed the same (if possible) would it fit your definition of being a lisp ?

> So if Janet refactored the interpreter to use linked lists

Which interpreter do you mean? A Lisp interpreter, which runs Lisp source code or a byte code interpreter?

Lisp is defined that it processes lists, either compiled or interpreted.

I'm looking at interpreted Lisp code in a debugger:

  CL-USER 19 : 1 > :lambda 
  (LAMBDA (A) (DECLARE (SYSTEM::SOURCE-LEVEL #<EQ Hash Table{0} 8010058C43>)) (DECLARE (LAMBDA-NAME FOO)) (SETF A (+ 10 A)) (BREAK) (+ A 20))

  CL-USER 20 : 1 > (car (nthcdr 5 *))
  (BREAK)

The code which is interpreted, is Lisp code in the form of lists. Lists are processed in user programs and the implementation itself processes Lisp code in the form of lists. Both are using the same list data structure, the same representation of the list data structure and the same primitive operators for it.

For me that's the core of Lisp.

If the language and its implementation does not process lists, then don't call it to be a "List Processor".

Am I understand right that Janet becames a Lisp (in your understanding of Lisp) if two conditions will be fullfilled: if everything will be reimplemented on linked lists with CAR/CDR everywhere and also a byte code interpreter will somehow coerce all the C syntax with ability to recompile all C code in such a way to fullfill a "no compile time" condition and that's it?

Sorry for speaking about things I do not understand, just I am searching for a comprehensive answer in "C vs Janet" question. I have a feel that there is something beautiful in Janet but I don't know what, so I have started this tree of discussion.

JavaScript and R are more Lisp-inspired to me. I tend to think of the Lisp family as containing Scheme, Clojure, and other languages with a fairly close resemblance. Common Lisp, its predecessors, and a few other languages like uLisp are more closely related still and are practically, if not strictly, the same language.

I’m not sure this informal taxonomy is “right,” but it seems to be useful and in line with common usage.

what is this fairly close resemblance? Parentheses?

There are a bunch of Lisp like languages without s-expression syntax: Lisp 2, Logo, MDL, RLISP, CLISP (not the CL implementation), Dylan, Racket with its new syntax (Racket2, Rhombus), Skill, ...

For example Dylan is based on Scheme & CLOS + a different syntax + some other influences. https://opendylan.org

https://github.com/dylan-lang/opendylan/blob/master/sources/...

Expression-based and supporting macros are two big features JavaScript lacks that the ones with the close resemblance have. Subjectively, they also have constructs in common that make coding relatively similar (although the presence of features like CLOS, continuations, and multimethods can have a pretty big effect). And yes, they use the same S-expression syntax. (Although you can be a Lisp without it.)

In fairness, R might be closer than I realized since I’ve never done extensive programming in it.

JavaScript started as a Scheme inspired language. It has runtime evaluation, a serialized data structure format, first class functions, garbage collection, dynamic typing, functional/imperative/object-oriented features, Many languages are not just looking at the syntax or the user-facing features of the language, but also at the implementation techniques of Lisp-like languages. An early example was Garbage Collection, which was invented for automatic and dynamic memory management of linked lists in the first Lisp implementation. R for example started as an attempt to reimplement S with a Scheme-like runtime.

Reply on news.ycombinator.com