Subject: Re: What is LISP?
From: Erik Naggum <>
Date: 2000/02/09
Newsgroups: comp.lang.lisp
Message-ID: <>

* Robert Posey <>
| Question 1:
| As I understand it nothing in CL standard requires an Interpreter, does
| it even require an interactive mode?

  standards always have explicitly and very strictly limited scope.  the
  way users interact with a Common Lisp system is outside the scope of the
  Common Lisp standard.

| Question 2:
| What should LISP typing method be called?

  it is already called "dynamic typing", "manifest typing", etc.

| I have heard several variations, but all the more advanced code I have
| seen makes use of typing for at least some of the symbols.

  you're applying static typing terminology to dynamic typing phenomena.
  this will hurt your understanding.  in Common Lisp, _values_ have type,
  and variables can (normally) hold values of any type.  therefore, you
  don't talk about the type of symbols (variables), but about the types of
  values that a variable can hold.  in statically typed languages, the type
  affects the layout and size of the memory allocated to a variable.  in
  Common Lisp, a variable is always allocated the same size memory, and
  what it holds is a pointer to the value, stored elsewhere, except in some
  obvious optimizations like (small) integers and characters, which fit in
  the space of such a pointer.  to make things work efficiently in this
  model, pointers carry type information.  this is very much unlike what
  you do in statically typed languages, where pointers are just machine
  addresses which the compiler hopes will point to values it knows, and
  then it tries to make sure its hopes come true by barfing on code that it
  can see will or does violate its hopes.  it can never actually be 100%
  certain, however.  using typed pointers, one doesn't have to deal with
  such silly hopes, and can instead work with whatever is there.

  put it another way, in a statically typed language, you may sometimes
  need to lie to your compiler to do the right thing, like you sometimes
  have to lie to officials who are anal-retentive about stupid laws and
  regulations, while in dynamically typed languages, you don't have to lie,
  because the laws and regulations can't be stupid.

| Question 3:
| Is it true that you can overload(in C++ Terms) built in operators in LISP? 

  no.  C++-style overloading is fundamentally evil, and is therefore not
  supported by good languages.  (note: this is not an opinion.)

| Question 4:
| What does the :ntest (I think) key do for applicable functions?

  whatever the function documents it to do.  the meaning of keywords
  arguments is not added vertically to functions in Common Lisp.

  :NTEST is unknown to me.  however, if you refer to the :TEST-NOT keyword,
  common to functions which also sport a :TEST keyword, for functions that
  support this semantics, it's a way to specify a test function to whose
  value NOT is applied before it is used.  another way to do the same thing
  is :TEST (COMPLEMENT <function>).