
	Where results make sense

Topic: LISP atom

Related Topics

Handel House Trust

Mauzac

Ney

Lancre

Nostromo

Deline

Star Trek

Aura the Finnish Maiden

Ryle Telescope

PVDF

Uno Sosuke

Gdov

Zhores Ivanovich Alferov

In the News (Thu 17 Dec 09)

Northern Trust

Marvin Harrison

Peter Chernin

Gary Locke

Match Play

Penelope Cruz

Mickey Rourke

AR Rahman

Danny Boyle

Hugh Jackman

	Programming in Emacs Lisp - List Processing
		In Lisp, all of the quoted text including the punctuation mark and the blank spaces is a single atom.
		You can also evaluate an atom that is not part of a list--one that is not surrounded by parentheses; again, the Lisp interpreter translates from the humanly readable expression to the language of the computer.
		Since Emacs Lisp is large, it is customary to name symbols in a way that identifies the part of Emacs to which the function belongs.
	www.math.utah.edu /docs/info/emacs-lisp-intro_2.html (6334 words)

	SUNY Geneseo A Quick Guide to Common Lisp Spring 2000
		Note that Common Lisp, particularly in its simpler features, has much in common with other Lisps (to a certain extent, that's what the word "Common" in its name means).
		Lisp iimplementations are usually interactive interpreters, i.e., programs to which you can type expressions and have them evaluated immediately.
		Much of the input and output that you would need to write in other languages are unnecessary in Lisp's interpreted environment, because inputs to a computation can often be entered simply as part of an expression typed interactively to the interpreter, and the interpreter automatically prints the result of every expression you give it.
	www.cs.geneseo.edu /~baldwin/csci341/spring2000/lisp-body.html (1346 words)

	LISP atom (Site not responding. Last check: 2007-10-18)
		In the original LISP, the originator of the Lisp programming language family, there were two fundamental data types, atoms and lists.
		The essential difference between atoms and lists was that atoms were immutable and unique.
		Two atoms that appeared in different places in source code but were written in the exact same way represented the same object, whereas each list was a separate object that could be altered independently of other lists and could be distinguished from other lists by comparison operators.
	www.worldhistory.com /wiki/L/LISP-atom.htm (302 words)

	From LISP 1 to LISP 1.5 (Site not responding. Last check: 2007-10-18)
		LISP has them in the form of the rplaca and rplacd pseudo-functions, but programs that use them cannot be conveniently represented in logic, because, regarded as functions, they don't permit replacement of equals by equals.
		Since LISP works with lists, it was also convenient to provide for functions with variable numbers of arguments by supplying them with a list of arguments rather than the separate arguments.
		It was written in LISP and was claimed to be the first compiler written in the language to be compiled.
	www-formal.stanford.edu /jmc/history/lisp/node4.html (1008 words)

	LISP [laze.net]
		LISP was developed in the 1950's by mathematician John McCarthy.
		The ATOM predicate returns a t(rue) or nil (also represented as empty set) based on whether the argument is an atom or not.
		Since LISP is an interpreted language with dynamic data typing, a runtime error would occur if a list was sent to N rather than an integer.
	www.laze.net /papers/lisp.php (1136 words)

	[No title]
		LISP supports complex numbers, which are written #c(r i) (where r is the real part and i is the imaginary part).
		LISP debuggers are all different; but most will respond to the command ":help" by giving some form of help.
		If the form is a list, LISP treats its first element as the name of a function; it evaluates the remaining elements recursively, and then calls the function with the values of the remaining elements as arguments.
	www-2.cs.cmu.edu /~ggordon/lisp-hints.txt (3811 words)

	Prolog: Allegro Prolog
		The Lisp form is compiled (at the same time the Prolog predicate is compiled) and may refer to variables in the surrounding dynamic Lisp environment.
		The output syntax is Lisp syntax, not Edinburgh.
		cl-user(42): (defparameter inst (make-instance 'foo)) inst cl-user(43): (?- (lisp ?i inst) (slot-value!
	www.franz.com /support/documentation/8.0/doc/prolog.html (4709 words)

	Math 61 -- Notes LISP
		LISP has led to several "children" languages, among which is SCHEME, which is (or has been) used as several universities as the first computer languages taught.
		A node is represented as a dotted pair of atoms enclosed in parentheses.
		LISP is free format, so that it is up to the programmer to determine how much or how little is put on a line and whether or not to use indentation.
	math.scu.edu /~dsmolars/ma61/lisp.html (1944 words)

	Successful Lisp - Chapter 3, Lesson 2
		Lisp treats the atom as a name, and retrieves the value for the name (if a value exists).
		Lisp will store the value as if the atom had a variable value, and add a note to the effect that the value is not allowed to change.
		Experienced Lisp programmers don't do this when the created value will just be taken apart into its components and then forgotten, since the composite value then becomes garbage (see Chapter 29) that eventually slows down the operation of the program.
	psg.com /~dlamkins/sl/chapter03-02.html (1259 words)

	Crossing borders: The beauty of Lisp
		Though Lisp is not strictly a functional language -- some of its features disqualify it from the strictest sense of the term -- many of Lisp's idioms and features have a strong functional flair to them.
		The first atom is the operator, and the rest of the atoms in the list are the arguments.
		Lisp provides coding structures for iteration, but recursion is a far more popular way to navigate lists.
	www.ibm.com /developerworks/java/library/j-cb02067.html?ca=dgr-lnxw06Lisp (2074 words)

	Successful Lisp - Chapter 3, Lesson 1
		Atoms are separated by whitespace or parentheses Now that you can recognize a list, you'd like to have a name for the things that appear between the parentheses -- the things that are not themselves lists, but rather (in our examples so far) words and numbers.
		is an atom, and not an arithmetic expression.
		Since an atom can be marked off by either whitespace or a parenthesis, we could eliminate any whitespace between an atom and a parenthesis, or between two parentheses.
	www.psg.com /~dlamkins/sl/chapter03-01.html (608 words)

	CS 3723/3721 -- Lisp Basics
		Lisp is a full-featured programming language that has traditionally supported AI applications.
		Lisp is an interpreted language, and as such it has flexibility and power not available to traditional compiled languages such as C, C++, or Java.
		Lisp is not case-sensitive, so our input to the Lisp interpreter will be in lower-case, and Lisp will change it to upper-case, except for letters inside double quotes.
	www.cs.utsa.edu /~wagner/CS3723/lisprecs/lisp_basics.html (1011 words)

	Functional programming
		Lisp was invented as a language for manipulating symbols rather than numbers.
		Lisp has a very simple syntax, and is a very simple language.
		Lisp has a long and complicated history, dating back to the first released version (1.0) in 1959.
	simonwillison.net /2002/Sep/27/functionalProgramming (1010 words)

	SAILDART/2006-06
		In standard UCI LISP, if an error was noticed after carriage return was struck, the user was forced to abort the entire procedure via ^G. ILISP now provides a "reread character" ^Z which causes READ to ignore what was typed previously and start over.
		ATOM, CONSP, and PATOM ←←←←←←←←←←←←←←←←←←←←←← ATOM has been fixed to return T only for a true LISP atom (i.e., an atomic symbol or a number).
		These atoms are defined as macros which expand to NIL; expressions starting with , , or ** may be placed in function definitions anywhere a NIL could be placed without harm, e.g., at the top level of LAMBDAs and PROGs (when the function is subsequently compiled, these expressions will disappear).
	www.saildart.org /prog/LSP/RUT_LSP/.html/000035?34,104960 (9195 words)

	Dr. Dobb's \| An Improved Lisp-Style Library for C \| September 1, 1992
		The result is an improved Lisp library in C which I call "C-lisp." This library should facilitate the translation of Lisp programs to C. I've tested the library on a variety of platforms, using different C and C++ compilers.
		A key strength of Lisp is the language's ability to represent highly abstract data structures--sets, trees, and lattices--using Lisp atoms and their associated indicator-property structures.
		In Lisp, the atom which is the pointer to Tweety would have the set of indicators and associated properties shown in Example 1.
	www.ddj.com /184408836;jsessionid=WG14UVICQQHEYQSNDLQSKH0CJUNN2JVN?_requestid=60227 (2290 words)

	t - definition by dict.die.net
		A Lisp compiler by Johnathan A. Rees in 1982 at Yale University.
		"false" is represented using the same atom as an empty list, nil.
		When a waiter or flight attendant asks whether a hacker wants coffee, he may absently respond `T', meaning that he wants coffee; but of course he will be brought a cup of tea instead.
	dict.die.net /t (690 words)

	[No title]
		Lisp and Smalltalk come the closest, I think, but even with those there are issues of corrupted data structures hanging around and causing problems. I know it's all in fashion right now, but I'm starting to contemplate my dream language.
		It still doesn't have macros the way Lisp does and it doesn't have sexprs (yes, I really do like the parenthesis), but it is a better follow-on to C than C++ and still hits the system-programming domain that Java missed so bady.
		While Emacs Lisp is not Common Lisp and suffers from a number of deficiencies (no lexical closures!), it's still Lisp and there are some advantages to developing an application this way: You get a fairly-good full-screen text UI almost for free.
	www.findinglisp.com /blog/atom.xml (4680 words)

	Common Lisp Tutorial (12-Jan-1996)
		The things which you type to the LISP interpreter are called forms; the LISP interpreter repeatedly reads a form, evaluates it, and prints the result.
		LISP debuggers are all different; but most will respond to the command "help" or ":help" by giving some form of help.
		LISP structures are analogous to C structs or Pascal records.
	www.notam02.no /internt/cm-sys/cm-2.2/doc/clt.html (3965 words)

	[No title]
		term) 1 j where Predicate = a predicate symbol (a LISP atom declared as a predicate) term = constant symbol (a LISP atom declared as a k constant) or a logic variable (a LISP atom declared as a variable) or (function term...
		Helpful Common Lisp Code for a First Order Logic Theorem Prover Computer Science CSW4701 ;For simplicity, we assume that literals are represented as ;follows: ; A positive literal is of the form (P t1 t2...
		If renamed is sent an atom that is NOT a logic ;variable, it simply returns that atom and makes no change to variable-assoc.
	www.cs.columbia.edu /~sal/notes/thm-prover.txt (2892 words)

	SAILDART/2006-06
		RUTGERS/UCI LISP MANUAL Page 111 V. Additions to the Editor ←←←←←←←←←←←←←←←←←←←←←←← (EDIT @) If is an atom EDIT simply returns ; otherwise the editor is called with as the object to be edited.
		Whenever an atom with such a property appears as the first element in a list being prettyprinted, SPRINT takes special action, such action depending on the value of the PRINTMACRO property: (1) If the value is a string the string is simply PRINCed and the CADR of the original expression (if present) is SPRINTed.
		One can thus use DUMPATOMS to REMOB all NOCALL atoms (to save space), and if it is later discovered that one of the RUTGERS/UCI LISP MANUAL Page 27 functions or special variables is needed after all, DSKIN the DUMPATOMS file to restore things to their previous state.
	www.saildart.org /prog/LSP/RUT_LSP/.html/000032?31,87040 (7169 words)

	Sample: Semantics of LISP
		For a: atom, store(a)::= address(Node(atom, Atom(a,...))), -- atoms that are not strings and numbers are capitalized at this point in the processing.
		Inside the S_expression, the atoms (if any) are new variables which are bound to a value when the lambda_form is applied as a function.
		In pure LISP variables are actual formal parameters that are bound to a value when functions are called and freed when the function returns a result.
	www.csci.csusb.edu /dick/samples/lisp.semantics.html (883 words)

	[No title] (Site not responding. Last check: 2007-10-18)
		SECTION 10 ATOM, STRING, ARRAY, AND STORAGE MANIPULATION 10.1 Pnames and Atom Manipulation The term "print name" (of an atom) in LISP 1.5 referred to the characters that were output whenever the atom was printed.
		The pname of a pointer are those characters that are output when the 1 pointer is printed using prin1, 2 e.g., the pname of the atom ABC%(D consists of the five characters ABC(D. The pname of the list (A B C) consists of the seven characters (A B C) (two of the characters are spaces).
		Since the internal pname of literal atoms also consists of a pointer to the beginning of a string of characters and a byte count, conversion between literal atoms and strings does not require any additional storage for the characters of the pname, although one cell is required 13 for the string pointer.
	pdp-10.trailing-edge.com /decuslib20-01/01/decus/20-0004/10lisp.tty (2506 words)

	Successful Lisp (Site not responding. Last check: 2007-10-18)
		Lisp space on my hard disk runs from a low of about 5 megabytes for one system to a high of about 30 megabytes for another system that is a total programming environment, including a built in file manager, WYSIWYG word processor, graphics program, appointment calendar, and (almost forgot) Lisp development environment.
		Lisp will store the value as if the atom had a variable value, and add a note to the effect that the value is not allowed to change.
		Lisp represents a single character using the notation #\char, where char is a literal character or the name of a character that does not have a printable glyph.
	www.selectorweb.com /lisp_success.html (17837 words)

	LISP: List Processing Language
		Lisp is the favored language for developing Artificial Intelligence(AI) because of its recursive properties and built-in functions for creating, processing and manipulating nested lists.
		As this is the Lisp expression for adding 1 and 1 it should evaluate to 2.
		Lisp statements are only complete when all the sets of parenthesis are closed or "matched." That is, (NIL) is complete statement, (NIL is not.
	home.att.net /~gobruen/progs/lisp (916 words)

	Stat 540#3, Introduction to Lisp (Site not responding. Last check: 2007-10-18)
		Lisp evaluates a form in a direct manner, leading to a very simple syntax.
		If the form to evaluate is an atom, Lisp returns the value of the atom.
		If the form to evaluate is a list, Lisp treats the first element as a function and evaluates the remaining elements.
	www-stat.wharton.upenn.edu /~bob/stat540/class3.html (438 words)

	Programming in Emacs Lisp
		Lisp was first developed in the late 1950s at the Massachusetts Institute of Technology for research in artificial intelligence.
		When you type a Lisp expression in GNU Emacs using either Lisp Interaction mode or Emacs Lisp mode, you have available to you several commands to format the Lisp expression so it is easy to read.
		Whenever you give an editing command to Emacs Lisp, such as the command to move the cursor or to scroll the screen, you are evaluating an expression, the first element of which is a function.
	www.gnu.org /software/emacs/emacs-lisp-intro/html_mono/emacs-lisp-intro.html (13658 words)

	Lemonodor - a mostly lisp weblog (Site not responding. Last check: 2007-10-18)
		First, Joel lets it be known that he's tried Lisp in a Box, and has read Practical Common Lisp.
		Dave: Well, I was talking with a friend of mine who was a Lisp programmer, really loved Lisp, and he was telling me about a feature that they had in Lisp editors called Function Illusion, which allowed you to - you know, Lisp was all about names with parentheses.
		And I thought, since I wasn't programming in Lisp, I was programming in Pascal and then C, that it would be nice to have something like that for those languages.
	lemonodor.com (4563 words)

	Programming in Emacs Lisp
		Lisp was first developed in the late 1950s at the Massachusetts Institute of Technology for research in artificial intelligence.
		GNU Emacs Lisp is largely inspired by Maclisp, which was written at MIT in the 1960's.
		The same thing could happen in Lisp if a variable that is used inside of one function has the same name as a variable that is used inside of another function, and the two are not intended to refer to the same value.
	www.csse.uwa.edu.au /programming/emacs-lisp-intro-1.04 (16559 words)

	pure_LISP reference manual
		Atom names are used also as short strings.
		(concat a1 a2) returns atom which name is a concatenation of the names of atoms a1 and a2.
		If st is 'lisp' e is ordered to be more readable as a lisp program.
	skelet.ludost.net /sec/reference.html (2179 words)

Try your search on: Qwika (all wikis)